7 years ago · e2606cf087
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
 
				+.idea/*
			
--- a/src/index.html
+++ b/src/index.html
@@ -0,0 +1,11 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <script src="js/angularjs" type="text/javascript"></script>
			
 
				+    <title>督导</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/src/js/angularjs/angular-animate.js
+++ b/src/js/angularjs/angular-animate.js
--- a/src/js/angularjs/angular-animate.min.js
+++ b/src/js/angularjs/angular-animate.min.js
--- a/src/js/angularjs/angular-animate.min.js.map
+++ b/src/js/angularjs/angular-animate.min.js.map
--- a/src/js/angularjs/angular-aria.js
+++ b/src/js/angularjs/angular-aria.js
@@ -0,0 +1,321 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngAria
			
 
				+ * @description
			
 
				+ *
			
 
				+ * The `ngAria` module provides support for common
			
 
				+ * [<abbr title="Accessible Rich Internet Applications">ARIA</abbr>](http://www.w3.org/TR/wai-aria/)
			
 
				+ * attributes that convey state or semantic information about the application for users
			
 
				+ * of assistive technologies, such as screen readers.
			
 
				+ *
			
 
				+ * <div doc-module-components="ngAria"></div>
			
 
				+ *
			
 
				+ * ## Usage
			
 
				+ *
			
 
				+ * For ngAria to do its magic, simply include the module as a dependency. The directives supported
			
 
				+ * by ngAria are:
			
 
				+ * `ngModel`, `ngDisabled`, `ngShow`, `ngHide`, `ngClick`, `ngDblClick`, and `ngMessages`.
			
 
				+ *
			
 
				+ * Below is a more detailed breakdown of the attributes handled by ngAria:
			
 
				+ *
			
 
				+ * | Directive                                   | Supported Attributes                                                                   |
			
 
				+ * |---------------------------------------------|----------------------------------------------------------------------------------------|
			
 
				+ * | {@link ng.directive:ngModel ngModel}        | aria-checked, aria-valuemin, aria-valuemax, aria-valuenow, aria-invalid, aria-required |
			
 
				+ * | {@link ng.directive:ngDisabled ngDisabled}  | aria-disabled                                                                          |
			
 
				+ * | {@link ng.directive:ngShow ngShow}          | aria-hidden                                                                            |
			
 
				+ * | {@link ng.directive:ngHide ngHide}          | aria-hidden                                                                            |
			
 
				+ * | {@link ng.directive:ngClick ngClick}        | tabindex                                                                               |
			
 
				+ * | {@link ng.directive:ngDblclick ngDblclick}  | tabindex                                                                               |
			
 
				+ * | {@link module:ngMessages ngMessages}        | aria-live                                                                              |
			
 
				+ *
			
 
				+ * Find out more information about each directive by reading the
			
 
				+ * {@link guide/accessibility ngAria Developer Guide}.
			
 
				+ *
			
 
				+ * ##Example
			
 
				+ * Using ngDisabled with ngAria:
			
 
				+ * ```html
			
 
				+ * <md-checkbox ng-disabled="disabled">
			
 
				+ * ```
			
 
				+ * Becomes:
			
 
				+ * ```html
			
 
				+ * <md-checkbox ng-disabled="disabled" aria-disabled="true">
			
 
				+ * ```
			
 
				+ *
			
 
				+ * ##Disabling Attributes
			
 
				+ * It's possible to disable individual attributes added by ngAria with the
			
 
				+ * {@link ngAria.$ariaProvider#config config} method. For more details, see the
			
 
				+ * {@link guide/accessibility Developer Guide}.
			
 
				+ */
			
 
				+ /* global -ngAriaModule */
			
 
				+var ngAriaModule = angular.module('ngAria', ['ng']).
			
 
				+                        provider('$aria', $AriaProvider);
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc provider
			
 
				+ * @name $ariaProvider
			
 
				+ *
			
 
				+ * @description
			
 
				+ *
			
 
				+ * Used for configuring the ARIA attributes injected and managed by ngAria.
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * angular.module('myApp', ['ngAria'], function config($ariaProvider) {
			
 
				+ *   $ariaProvider.config({
			
 
				+ *     ariaValue: true,
			
 
				+ *     tabindex: false
			
 
				+ *   });
			
 
				+ * });
			
 
				+ *```
			
 
				+ *
			
 
				+ * ## Dependencies
			
 
				+ * Requires the {@link ngAria} module to be installed.
			
 
				+ *
			
 
				+ */
			
 
				+function $AriaProvider() {
			
 
				+  var config = {
			
 
				+    ariaHidden: true,
			
 
				+    ariaChecked: true,
			
 
				+    ariaDisabled: true,
			
 
				+    ariaRequired: true,
			
 
				+    ariaInvalid: true,
			
 
				+    ariaMultiline: true,
			
 
				+    ariaValue: true,
			
 
				+    tabindex: true
			
 
				+  };
			
 
				+
			
 
				+  /**
			
 
				+   * @ngdoc method
			
 
				+   * @name $ariaProvider#config
			
 
				+   *
			
 
				+   * @param {object} config object to enable/disable specific ARIA attributes
			
 
				+   *
			
 
				+   *  - **ariaHidden** – `{boolean}` – Enables/disables aria-hidden tags
			
 
				+   *  - **ariaChecked** – `{boolean}` – Enables/disables aria-checked tags
			
 
				+   *  - **ariaDisabled** – `{boolean}` – Enables/disables aria-disabled tags
			
 
				+   *  - **ariaRequired** – `{boolean}` – Enables/disables aria-required tags
			
 
				+   *  - **ariaInvalid** – `{boolean}` – Enables/disables aria-invalid tags
			
 
				+   *  - **ariaMultiline** – `{boolean}` – Enables/disables aria-multiline tags
			
 
				+   *  - **ariaValue** – `{boolean}` – Enables/disables aria-valuemin, aria-valuemax and aria-valuenow tags
			
 
				+   *  - **tabindex** – `{boolean}` – Enables/disables tabindex tags
			
 
				+   *
			
 
				+   * @description
			
 
				+   * Enables/disables various ARIA attributes
			
 
				+   */
			
 
				+  this.config = function(newConfig) {
			
 
				+    config = angular.extend(config, newConfig);
			
 
				+  };
			
 
				+
			
 
				+  function camelCase(input) {
			
 
				+    return input.replace(/-./g, function(letter, pos) {
			
 
				+      return letter[1].toUpperCase();
			
 
				+    });
			
 
				+  }
			
 
				+
			
 
				+
			
 
				+  function watchExpr(attrName, ariaAttr, negate) {
			
 
				+    var ariaCamelName = camelCase(ariaAttr);
			
 
				+    return function(scope, elem, attr) {
			
 
				+      if (config[ariaCamelName] && !attr[ariaCamelName]) {
			
 
				+        scope.$watch(attr[attrName], function(boolVal) {
			
 
				+          if (negate) {
			
 
				+            boolVal = !boolVal;
			
 
				+          }
			
 
				+          elem.attr(ariaAttr, boolVal);
			
 
				+        });
			
 
				+      }
			
 
				+    };
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * @ngdoc service
			
 
				+   * @name $aria
			
 
				+   *
			
 
				+   * @description
			
 
				+   *
			
 
				+   * The $aria service contains helper methods for applying common
			
 
				+   * [ARIA](http://www.w3.org/TR/wai-aria/) attributes to HTML directives.
			
 
				+   *
			
 
				+   * ngAria injects common accessibility attributes that tell assistive technologies when HTML
			
 
				+   * elements are enabled, selected, hidden, and more. To see how this is performed with ngAria,
			
 
				+   * let's review a code snippet from ngAria itself:
			
 
				+   *
			
 
				+   *```js
			
 
				+   * ngAriaModule.directive('ngDisabled', ['$aria', function($aria) {
			
 
				+   *   return $aria.$$watchExpr('ngDisabled', 'aria-disabled');
			
 
				+   * }])
			
 
				+   *```
			
 
				+   * Shown above, the ngAria module creates a directive with the same signature as the
			
 
				+   * traditional `ng-disabled` directive. But this ngAria version is dedicated to
			
 
				+   * solely managing accessibility attributes. The internal `$aria` service is used to watch the
			
 
				+   * boolean attribute `ngDisabled`. If it has not been explicitly set by the developer,
			
 
				+   * `aria-disabled` is injected as an attribute with its value synchronized to the value in
			
 
				+   * `ngDisabled`.
			
 
				+   *
			
 
				+   * Because ngAria hooks into the `ng-disabled` directive, developers do not have to do
			
 
				+   * anything to enable this feature. The `aria-disabled` attribute is automatically managed
			
 
				+   * simply as a silent side-effect of using `ng-disabled` with the ngAria module.
			
 
				+   *
			
 
				+   * The full list of directives that interface with ngAria:
			
 
				+   * * **ngModel**
			
 
				+   * * **ngShow**
			
 
				+   * * **ngHide**
			
 
				+   * * **ngClick**
			
 
				+   * * **ngDblclick**
			
 
				+   * * **ngMessages**
			
 
				+   * * **ngDisabled**
			
 
				+   *
			
 
				+   * Read the {@link guide/accessibility ngAria Developer Guide} for a thorough explanation of each
			
 
				+   * directive.
			
 
				+   *
			
 
				+   *
			
 
				+   * ## Dependencies
			
 
				+   * Requires the {@link ngAria} module to be installed.
			
 
				+   */
			
 
				+  this.$get = function() {
			
 
				+    return {
			
 
				+      config: function(key) {
			
 
				+        return config[camelCase(key)];
			
 
				+      },
			
 
				+      $$watchExpr: watchExpr
			
 
				+    };
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+var ngAriaTabindex = ['$aria', function($aria) {
			
 
				+  return function(scope, elem, attr) {
			
 
				+    if ($aria.config('tabindex') && !elem.attr('tabindex')) {
			
 
				+      elem.attr('tabindex', 0);
			
 
				+    }
			
 
				+  };
			
 
				+}];
			
 
				+
			
 
				+ngAriaModule.directive('ngShow', ['$aria', function($aria) {
			
 
				+  return $aria.$$watchExpr('ngShow', 'aria-hidden', true);
			
 
				+}])
			
 
				+.directive('ngHide', ['$aria', function($aria) {
			
 
				+  return $aria.$$watchExpr('ngHide', 'aria-hidden', false);
			
 
				+}])
			
 
				+.directive('ngModel', ['$aria', function($aria) {
			
 
				+
			
 
				+  function shouldAttachAttr(attr, elem) {
			
 
				+    return $aria.config(attr) && !elem.attr(attr);
			
 
				+  }
			
 
				+
			
 
				+  function getShape(attr, elem) {
			
 
				+    var type = attr.type,
			
 
				+        role = attr.role;
			
 
				+
			
 
				+    return ((type || role) === 'checkbox' || role === 'menuitemcheckbox') ? 'checkbox' :
			
 
				+           ((type || role) === 'radio'    || role === 'menuitemradio') ? 'radio' :
			
 
				+           (type === 'range'              || role === 'progressbar' || role === 'slider') ? 'range' :
			
 
				+           (type || role) === 'textbox'   || elem[0].nodeName === 'TEXTAREA' ? 'multiline' : '';
			
 
				+  }
			
 
				+
			
 
				+  return {
			
 
				+    restrict: 'A',
			
 
				+    require: '?ngModel',
			
 
				+    link: function(scope, elem, attr, ngModel) {
			
 
				+      var shape = getShape(attr, elem);
			
 
				+      var needsTabIndex = shouldAttachAttr('tabindex', elem);
			
 
				+
			
 
				+      function ngAriaWatchModelValue() {
			
 
				+        return ngModel.$modelValue;
			
 
				+      }
			
 
				+
			
 
				+      function getRadioReaction() {
			
 
				+        if (needsTabIndex) {
			
 
				+          needsTabIndex = false;
			
 
				+          return function ngAriaRadioReaction(newVal) {
			
 
				+            var boolVal = newVal === attr.value;
			
 
				+            elem.attr('aria-checked', boolVal);
			
 
				+            elem.attr('tabindex', 0 - !boolVal);
			
 
				+          };
			
 
				+        } else {
			
 
				+          return function ngAriaRadioReaction(newVal) {
			
 
				+            elem.attr('aria-checked', newVal === attr.value);
			
 
				+          };
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      function ngAriaCheckboxReaction(newVal) {
			
 
				+        elem.attr('aria-checked', !!newVal);
			
 
				+      }
			
 
				+
			
 
				+      switch (shape) {
			
 
				+        case 'radio':
			
 
				+        case 'checkbox':
			
 
				+          if (shouldAttachAttr('aria-checked', elem)) {
			
 
				+            scope.$watch(ngAriaWatchModelValue, shape === 'radio' ?
			
 
				+                getRadioReaction() : ngAriaCheckboxReaction);
			
 
				+          }
			
 
				+          break;
			
 
				+        case 'range':
			
 
				+          if ($aria.config('ariaValue')) {
			
 
				+            if (attr.min && !elem.attr('aria-valuemin')) {
			
 
				+              elem.attr('aria-valuemin', attr.min);
			
 
				+            }
			
 
				+            if (attr.max && !elem.attr('aria-valuemax')) {
			
 
				+              elem.attr('aria-valuemax', attr.max);
			
 
				+            }
			
 
				+            if (!elem.attr('aria-valuenow')) {
			
 
				+              scope.$watch(ngAriaWatchModelValue, function ngAriaValueNowReaction(newVal) {
			
 
				+                elem.attr('aria-valuenow', newVal);
			
 
				+              });
			
 
				+            }
			
 
				+          }
			
 
				+          break;
			
 
				+        case 'multiline':
			
 
				+          if (shouldAttachAttr('aria-multiline', elem)) {
			
 
				+            elem.attr('aria-multiline', true);
			
 
				+          }
			
 
				+          break;
			
 
				+      }
			
 
				+
			
 
				+      if (needsTabIndex) {
			
 
				+        elem.attr('tabindex', 0);
			
 
				+      }
			
 
				+
			
 
				+      if (ngModel.$validators.required && shouldAttachAttr('aria-required', elem)) {
			
 
				+        scope.$watch(function ngAriaRequiredWatch() {
			
 
				+          return ngModel.$error.required;
			
 
				+        }, function ngAriaRequiredReaction(newVal) {
			
 
				+          elem.attr('aria-required', !!newVal);
			
 
				+        });
			
 
				+      }
			
 
				+
			
 
				+      if (shouldAttachAttr('aria-invalid', elem)) {
			
 
				+        scope.$watch(function ngAriaInvalidWatch() {
			
 
				+          return ngModel.$invalid;
			
 
				+        }, function ngAriaInvalidReaction(newVal) {
			
 
				+          elem.attr('aria-invalid', !!newVal);
			
 
				+        });
			
 
				+      }
			
 
				+    }
			
 
				+  };
			
 
				+}])
			
 
				+.directive('ngDisabled', ['$aria', function($aria) {
			
 
				+  return $aria.$$watchExpr('ngDisabled', 'aria-disabled');
			
 
				+}])
			
 
				+.directive('ngMessages', function() {
			
 
				+  return {
			
 
				+    restrict: 'A',
			
 
				+    require: '?ngMessages',
			
 
				+    link: function(scope, elem, attr, ngMessages) {
			
 
				+      if (!elem.attr('aria-live')) {
			
 
				+        elem.attr('aria-live', 'assertive');
			
 
				+      }
			
 
				+    }
			
 
				+  };
			
 
				+})
			
 
				+.directive('ngClick', ngAriaTabindex)
			
 
				+.directive('ngDblclick', ngAriaTabindex);
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-aria.min.js
+++ b/src/js/angularjs/angular-aria.min.js
--- a/src/js/angularjs/angular-aria.min.js.map
+++ b/src/js/angularjs/angular-aria.min.js.map
--- a/src/js/angularjs/angular-cookies.js
+++ b/src/js/angularjs/angular-cookies.js
@@ -0,0 +1,206 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngCookies
			
 
				+ * @description
			
 
				+ *
			
 
				+ * # ngCookies
			
 
				+ *
			
 
				+ * The `ngCookies` module provides a convenient wrapper for reading and writing browser cookies.
			
 
				+ *
			
 
				+ *
			
 
				+ * <div doc-module-components="ngCookies"></div>
			
 
				+ *
			
 
				+ * See {@link ngCookies.$cookies `$cookies`} and
			
 
				+ * {@link ngCookies.$cookieStore `$cookieStore`} for usage.
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+angular.module('ngCookies', ['ng']).
			
 
				+  /**
			
 
				+   * @ngdoc service
			
 
				+   * @name $cookies
			
 
				+   *
			
 
				+   * @description
			
 
				+   * Provides read/write access to browser's cookies.
			
 
				+   *
			
 
				+   * Only a simple Object is exposed and by adding or removing properties to/from this object, new
			
 
				+   * cookies are created/deleted at the end of current $eval.
			
 
				+   * The object's properties can only be strings.
			
 
				+   *
			
 
				+   * Requires the {@link ngCookies `ngCookies`} module to be installed.
			
 
				+   *
			
 
				+   * @example
			
 
				+   *
			
 
				+   * ```js
			
 
				+   * angular.module('cookiesExample', ['ngCookies'])
			
 
				+   *   .controller('ExampleController', ['$cookies', function($cookies) {
			
 
				+   *     // Retrieving a cookie
			
 
				+   *     var favoriteCookie = $cookies.myFavorite;
			
 
				+   *     // Setting a cookie
			
 
				+   *     $cookies.myFavorite = 'oatmeal';
			
 
				+   *   }]);
			
 
				+   * ```
			
 
				+   */
			
 
				+   factory('$cookies', ['$rootScope', '$browser', function($rootScope, $browser) {
			
 
				+      var cookies = {},
			
 
				+          lastCookies = {},
			
 
				+          lastBrowserCookies,
			
 
				+          runEval = false,
			
 
				+          copy = angular.copy,
			
 
				+          isUndefined = angular.isUndefined;
			
 
				+
			
 
				+      //creates a poller fn that copies all cookies from the $browser to service & inits the service
			
 
				+      $browser.addPollFn(function() {
			
 
				+        var currentCookies = $browser.cookies();
			
 
				+        if (lastBrowserCookies != currentCookies) { //relies on browser.cookies() impl
			
 
				+          lastBrowserCookies = currentCookies;
			
 
				+          copy(currentCookies, lastCookies);
			
 
				+          copy(currentCookies, cookies);
			
 
				+          if (runEval) $rootScope.$apply();
			
 
				+        }
			
 
				+      })();
			
 
				+
			
 
				+      runEval = true;
			
 
				+
			
 
				+      //at the end of each eval, push cookies
			
 
				+      //TODO: this should happen before the "delayed" watches fire, because if some cookies are not
			
 
				+      //      strings or browser refuses to store some cookies, we update the model in the push fn.
			
 
				+      $rootScope.$watch(push);
			
 
				+
			
 
				+      return cookies;
			
 
				+
			
 
				+
			
 
				+      /**
			
 
				+       * Pushes all the cookies from the service to the browser and verifies if all cookies were
			
 
				+       * stored.
			
 
				+       */
			
 
				+      function push() {
			
 
				+        var name,
			
 
				+            value,
			
 
				+            browserCookies,
			
 
				+            updated;
			
 
				+
			
 
				+        //delete any cookies deleted in $cookies
			
 
				+        for (name in lastCookies) {
			
 
				+          if (isUndefined(cookies[name])) {
			
 
				+            $browser.cookies(name, undefined);
			
 
				+          }
			
 
				+        }
			
 
				+
			
 
				+        //update all cookies updated in $cookies
			
 
				+        for (name in cookies) {
			
 
				+          value = cookies[name];
			
 
				+          if (!angular.isString(value)) {
			
 
				+            value = '' + value;
			
 
				+            cookies[name] = value;
			
 
				+          }
			
 
				+          if (value !== lastCookies[name]) {
			
 
				+            $browser.cookies(name, value);
			
 
				+            updated = true;
			
 
				+          }
			
 
				+        }
			
 
				+
			
 
				+        //verify what was actually stored
			
 
				+        if (updated) {
			
 
				+          updated = false;
			
 
				+          browserCookies = $browser.cookies();
			
 
				+
			
 
				+          for (name in cookies) {
			
 
				+            if (cookies[name] !== browserCookies[name]) {
			
 
				+              //delete or reset all cookies that the browser dropped from $cookies
			
 
				+              if (isUndefined(browserCookies[name])) {
			
 
				+                delete cookies[name];
			
 
				+              } else {
			
 
				+                cookies[name] = browserCookies[name];
			
 
				+              }
			
 
				+              updated = true;
			
 
				+            }
			
 
				+          }
			
 
				+        }
			
 
				+      }
			
 
				+    }]).
			
 
				+
			
 
				+
			
 
				+  /**
			
 
				+   * @ngdoc service
			
 
				+   * @name $cookieStore
			
 
				+   * @requires $cookies
			
 
				+   *
			
 
				+   * @description
			
 
				+   * Provides a key-value (string-object) storage, that is backed by session cookies.
			
 
				+   * Objects put or retrieved from this storage are automatically serialized or
			
 
				+   * deserialized by angular's toJson/fromJson.
			
 
				+   *
			
 
				+   * Requires the {@link ngCookies `ngCookies`} module to be installed.
			
 
				+   *
			
 
				+   * @example
			
 
				+   *
			
 
				+   * ```js
			
 
				+   * angular.module('cookieStoreExample', ['ngCookies'])
			
 
				+   *   .controller('ExampleController', ['$cookieStore', function($cookieStore) {
			
 
				+   *     // Put cookie
			
 
				+   *     $cookieStore.put('myFavorite','oatmeal');
			
 
				+   *     // Get cookie
			
 
				+   *     var favoriteCookie = $cookieStore.get('myFavorite');
			
 
				+   *     // Removing a cookie
			
 
				+   *     $cookieStore.remove('myFavorite');
			
 
				+   *   }]);
			
 
				+   * ```
			
 
				+   */
			
 
				+   factory('$cookieStore', ['$cookies', function($cookies) {
			
 
				+
			
 
				+      return {
			
 
				+        /**
			
 
				+         * @ngdoc method
			
 
				+         * @name $cookieStore#get
			
 
				+         *
			
 
				+         * @description
			
 
				+         * Returns the value of given cookie key
			
 
				+         *
			
 
				+         * @param {string} key Id to use for lookup.
			
 
				+         * @returns {Object} Deserialized cookie value.
			
 
				+         */
			
 
				+        get: function(key) {
			
 
				+          var value = $cookies[key];
			
 
				+          return value ? angular.fromJson(value) : value;
			
 
				+        },
			
 
				+
			
 
				+        /**
			
 
				+         * @ngdoc method
			
 
				+         * @name $cookieStore#put
			
 
				+         *
			
 
				+         * @description
			
 
				+         * Sets a value for given cookie key
			
 
				+         *
			
 
				+         * @param {string} key Id for the `value`.
			
 
				+         * @param {Object} value Value to be stored.
			
 
				+         */
			
 
				+        put: function(key, value) {
			
 
				+          $cookies[key] = angular.toJson(value);
			
 
				+        },
			
 
				+
			
 
				+        /**
			
 
				+         * @ngdoc method
			
 
				+         * @name $cookieStore#remove
			
 
				+         *
			
 
				+         * @description
			
 
				+         * Remove given cookie
			
 
				+         *
			
 
				+         * @param {string} key Id of the key-value pair to delete.
			
 
				+         */
			
 
				+        remove: function(key) {
			
 
				+          delete $cookies[key];
			
 
				+        }
			
 
				+      };
			
 
				+
			
 
				+    }]);
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-cookies.min.js
+++ b/src/js/angularjs/angular-cookies.min.js
--- a/src/js/angularjs/angular-cookies.min.js.map
+++ b/src/js/angularjs/angular-cookies.min.js.map
--- a/src/js/angularjs/angular-csp.css
+++ b/src/js/angularjs/angular-csp.css
@@ -0,0 +1,13 @@
 
				+/* Include this file in your html if you are using the CSP mode. */
			
 
				+
			
 
				+@charset "UTF-8";
			
 
				+
			
 
				+[ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak],
			
 
				+.ng-cloak, .x-ng-cloak,
			
 
				+.ng-hide:not(.ng-hide-animate) {
			
 
				+  display: none !important;
			
 
				+}
			
 
				+
			
 
				+ng\:form {
			
 
				+  display: block;
			
 
				+}
			
--- a/src/js/angularjs/angular-loader.js
+++ b/src/js/angularjs/angular-loader.js
@@ -0,0 +1,405 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+
			
 
				+(function() {'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * @description
			
 
				+ *
			
 
				+ * This object provides a utility for producing rich Error messages within
			
 
				+ * Angular. It can be called as follows:
			
 
				+ *
			
 
				+ * var exampleMinErr = minErr('example');
			
 
				+ * throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
			
 
				+ *
			
 
				+ * The above creates an instance of minErr in the example namespace. The
			
 
				+ * resulting error will have a namespaced error code of example.one.  The
			
 
				+ * resulting error will replace {0} with the value of foo, and {1} with the
			
 
				+ * value of bar. The object is not restricted in the number of arguments it can
			
 
				+ * take.
			
 
				+ *
			
 
				+ * If fewer arguments are specified than necessary for interpolation, the extra
			
 
				+ * interpolation markers will be preserved in the final string.
			
 
				+ *
			
 
				+ * Since data will be parsed statically during a build step, some restrictions
			
 
				+ * are applied with respect to how minErr instances are created and called.
			
 
				+ * Instances should have names of the form namespaceMinErr for a minErr created
			
 
				+ * using minErr('namespace') . Error codes, namespaces and template strings
			
 
				+ * should all be static strings, not variables or general expressions.
			
 
				+ *
			
 
				+ * @param {string} module The namespace to use for the new minErr instance.
			
 
				+ * @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
			
 
				+ *   error from returned function, for cases when a particular type of error is useful.
			
 
				+ * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
			
 
				+ */
			
 
				+
			
 
				+function minErr(module, ErrorConstructor) {
			
 
				+  ErrorConstructor = ErrorConstructor || Error;
			
 
				+  return function() {
			
 
				+    var code = arguments[0],
			
 
				+      prefix = '[' + (module ? module + ':' : '') + code + '] ',
			
 
				+      template = arguments[1],
			
 
				+      templateArgs = arguments,
			
 
				+
			
 
				+      message, i;
			
 
				+
			
 
				+    message = prefix + template.replace(/\{\d+\}/g, function(match) {
			
 
				+      var index = +match.slice(1, -1), arg;
			
 
				+
			
 
				+      if (index + 2 < templateArgs.length) {
			
 
				+        return toDebugString(templateArgs[index + 2]);
			
 
				+      }
			
 
				+      return match;
			
 
				+    });
			
 
				+
			
 
				+    message = message + '\nhttp://errors.angularjs.org/1.3.5/' +
			
 
				+      (module ? module + '/' : '') + code;
			
 
				+    for (i = 2; i < arguments.length; i++) {
			
 
				+      message = message + (i == 2 ? '?' : '&') + 'p' + (i - 2) + '=' +
			
 
				+        encodeURIComponent(toDebugString(arguments[i]));
			
 
				+    }
			
 
				+    return new ErrorConstructor(message);
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc type
			
 
				+ * @name angular.Module
			
 
				+ * @module ng
			
 
				+ * @description
			
 
				+ *
			
 
				+ * Interface for configuring angular {@link angular.module modules}.
			
 
				+ */
			
 
				+
			
 
				+function setupModuleLoader(window) {
			
 
				+
			
 
				+  var $injectorMinErr = minErr('$injector');
			
 
				+  var ngMinErr = minErr('ng');
			
 
				+
			
 
				+  function ensure(obj, name, factory) {
			
 
				+    return obj[name] || (obj[name] = factory());
			
 
				+  }
			
 
				+
			
 
				+  var angular = ensure(window, 'angular', Object);
			
 
				+
			
 
				+  // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
			
 
				+  angular.$$minErr = angular.$$minErr || minErr;
			
 
				+
			
 
				+  return ensure(angular, 'module', function() {
			
 
				+    /** @type {Object.<string, angular.Module>} */
			
 
				+    var modules = {};
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc function
			
 
				+     * @name angular.module
			
 
				+     * @module ng
			
 
				+     * @description
			
 
				+     *
			
 
				+     * The `angular.module` is a global place for creating, registering and retrieving Angular
			
 
				+     * modules.
			
 
				+     * All modules (angular core or 3rd party) that should be available to an application must be
			
 
				+     * registered using this mechanism.
			
 
				+     *
			
 
				+     * When passed two or more arguments, a new module is created.  If passed only one argument, an
			
 
				+     * existing module (the name passed as the first argument to `module`) is retrieved.
			
 
				+     *
			
 
				+     *
			
 
				+     * # Module
			
 
				+     *
			
 
				+     * A module is a collection of services, directives, controllers, filters, and configuration information.
			
 
				+     * `angular.module` is used to configure the {@link auto.$injector $injector}.
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * // Create a new module
			
 
				+     * var myModule = angular.module('myModule', []);
			
 
				+     *
			
 
				+     * // register a new service
			
 
				+     * myModule.value('appName', 'MyCoolApp');
			
 
				+     *
			
 
				+     * // configure existing services inside initialization blocks.
			
 
				+     * myModule.config(['$locationProvider', function($locationProvider) {
			
 
				+     *   // Configure existing providers
			
 
				+     *   $locationProvider.hashPrefix('!');
			
 
				+     * }]);
			
 
				+     * ```
			
 
				+     *
			
 
				+     * Then you can create an injector and load your modules like this:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * var injector = angular.injector(['ng', 'myModule'])
			
 
				+     * ```
			
 
				+     *
			
 
				+     * However it's more likely that you'll just use
			
 
				+     * {@link ng.directive:ngApp ngApp} or
			
 
				+     * {@link angular.bootstrap} to simplify this process for you.
			
 
				+     *
			
 
				+     * @param {!string} name The name of the module to create or retrieve.
			
 
				+     * @param {!Array.<string>=} requires If specified then new module is being created. If
			
 
				+     *        unspecified then the module is being retrieved for further configuration.
			
 
				+     * @param {Function=} configFn Optional configuration function for the module. Same as
			
 
				+     *        {@link angular.Module#config Module#config()}.
			
 
				+     * @returns {module} new module with the {@link angular.Module} api.
			
 
				+     */
			
 
				+    return function module(name, requires, configFn) {
			
 
				+      var assertNotHasOwnProperty = function(name, context) {
			
 
				+        if (name === 'hasOwnProperty') {
			
 
				+          throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
			
 
				+        }
			
 
				+      };
			
 
				+
			
 
				+      assertNotHasOwnProperty(name, 'module');
			
 
				+      if (requires && modules.hasOwnProperty(name)) {
			
 
				+        modules[name] = null;
			
 
				+      }
			
 
				+      return ensure(modules, name, function() {
			
 
				+        if (!requires) {
			
 
				+          throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
			
 
				+             "the module name or forgot to load it. If registering a module ensure that you " +
			
 
				+             "specify the dependencies as the second argument.", name);
			
 
				+        }
			
 
				+
			
 
				+        /** @type {!Array.<Array.<*>>} */
			
 
				+        var invokeQueue = [];
			
 
				+
			
 
				+        /** @type {!Array.<Function>} */
			
 
				+        var configBlocks = [];
			
 
				+
			
 
				+        /** @type {!Array.<Function>} */
			
 
				+        var runBlocks = [];
			
 
				+
			
 
				+        var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
			
 
				+
			
 
				+        /** @type {angular.Module} */
			
 
				+        var moduleInstance = {
			
 
				+          // Private state
			
 
				+          _invokeQueue: invokeQueue,
			
 
				+          _configBlocks: configBlocks,
			
 
				+          _runBlocks: runBlocks,
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc property
			
 
				+           * @name angular.Module#requires
			
 
				+           * @module ng
			
 
				+           *
			
 
				+           * @description
			
 
				+           * Holds the list of modules which the injector will load before the current module is
			
 
				+           * loaded.
			
 
				+           */
			
 
				+          requires: requires,
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc property
			
 
				+           * @name angular.Module#name
			
 
				+           * @module ng
			
 
				+           *
			
 
				+           * @description
			
 
				+           * Name of the module.
			
 
				+           */
			
 
				+          name: name,
			
 
				+
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#provider
			
 
				+           * @module ng
			
 
				+           * @param {string} name service name
			
 
				+           * @param {Function} providerType Construction function for creating new instance of the
			
 
				+           *                                service.
			
 
				+           * @description
			
 
				+           * See {@link auto.$provide#provider $provide.provider()}.
			
 
				+           */
			
 
				+          provider: invokeLater('$provide', 'provider'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#factory
			
 
				+           * @module ng
			
 
				+           * @param {string} name service name
			
 
				+           * @param {Function} providerFunction Function for creating new instance of the service.
			
 
				+           * @description
			
 
				+           * See {@link auto.$provide#factory $provide.factory()}.
			
 
				+           */
			
 
				+          factory: invokeLater('$provide', 'factory'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#service
			
 
				+           * @module ng
			
 
				+           * @param {string} name service name
			
 
				+           * @param {Function} constructor A constructor function that will be instantiated.
			
 
				+           * @description
			
 
				+           * See {@link auto.$provide#service $provide.service()}.
			
 
				+           */
			
 
				+          service: invokeLater('$provide', 'service'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#value
			
 
				+           * @module ng
			
 
				+           * @param {string} name service name
			
 
				+           * @param {*} object Service instance object.
			
 
				+           * @description
			
 
				+           * See {@link auto.$provide#value $provide.value()}.
			
 
				+           */
			
 
				+          value: invokeLater('$provide', 'value'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#constant
			
 
				+           * @module ng
			
 
				+           * @param {string} name constant name
			
 
				+           * @param {*} object Constant value.
			
 
				+           * @description
			
 
				+           * Because the constant are fixed, they get applied before other provide methods.
			
 
				+           * See {@link auto.$provide#constant $provide.constant()}.
			
 
				+           */
			
 
				+          constant: invokeLater('$provide', 'constant', 'unshift'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#animation
			
 
				+           * @module ng
			
 
				+           * @param {string} name animation name
			
 
				+           * @param {Function} animationFactory Factory function for creating new instance of an
			
 
				+           *                                    animation.
			
 
				+           * @description
			
 
				+           *
			
 
				+           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
			
 
				+           *
			
 
				+           *
			
 
				+           * Defines an animation hook that can be later used with
			
 
				+           * {@link ngAnimate.$animate $animate} service and directives that use this service.
			
 
				+           *
			
 
				+           * ```js
			
 
				+           * module.animation('.animation-name', function($inject1, $inject2) {
			
 
				+           *   return {
			
 
				+           *     eventName : function(element, done) {
			
 
				+           *       //code to run the animation
			
 
				+           *       //once complete, then run done()
			
 
				+           *       return function cancellationFunction(element) {
			
 
				+           *         //code to cancel the animation
			
 
				+           *       }
			
 
				+           *     }
			
 
				+           *   }
			
 
				+           * })
			
 
				+           * ```
			
 
				+           *
			
 
				+           * See {@link ng.$animateProvider#register $animateProvider.register()} and
			
 
				+           * {@link ngAnimate ngAnimate module} for more information.
			
 
				+           */
			
 
				+          animation: invokeLater('$animateProvider', 'register'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#filter
			
 
				+           * @module ng
			
 
				+           * @param {string} name Filter name.
			
 
				+           * @param {Function} filterFactory Factory function for creating new instance of filter.
			
 
				+           * @description
			
 
				+           * See {@link ng.$filterProvider#register $filterProvider.register()}.
			
 
				+           */
			
 
				+          filter: invokeLater('$filterProvider', 'register'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#controller
			
 
				+           * @module ng
			
 
				+           * @param {string|Object} name Controller name, or an object map of controllers where the
			
 
				+           *    keys are the names and the values are the constructors.
			
 
				+           * @param {Function} constructor Controller constructor function.
			
 
				+           * @description
			
 
				+           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
			
 
				+           */
			
 
				+          controller: invokeLater('$controllerProvider', 'register'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#directive
			
 
				+           * @module ng
			
 
				+           * @param {string|Object} name Directive name, or an object map of directives where the
			
 
				+           *    keys are the names and the values are the factories.
			
 
				+           * @param {Function} directiveFactory Factory function for creating new instance of
			
 
				+           * directives.
			
 
				+           * @description
			
 
				+           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
			
 
				+           */
			
 
				+          directive: invokeLater('$compileProvider', 'directive'),
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#config
			
 
				+           * @module ng
			
 
				+           * @param {Function} configFn Execute this function on module load. Useful for service
			
 
				+           *    configuration.
			
 
				+           * @description
			
 
				+           * Use this method to register work which needs to be performed on module loading.
			
 
				+           * For more about how to configure services, see
			
 
				+           * {@link providers#provider-recipe Provider Recipe}.
			
 
				+           */
			
 
				+          config: config,
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name angular.Module#run
			
 
				+           * @module ng
			
 
				+           * @param {Function} initializationFn Execute this function after injector creation.
			
 
				+           *    Useful for application initialization.
			
 
				+           * @description
			
 
				+           * Use this method to register work which should be performed when the injector is done
			
 
				+           * loading all modules.
			
 
				+           */
			
 
				+          run: function(block) {
			
 
				+            runBlocks.push(block);
			
 
				+            return this;
			
 
				+          }
			
 
				+        };
			
 
				+
			
 
				+        if (configFn) {
			
 
				+          config(configFn);
			
 
				+        }
			
 
				+
			
 
				+        return moduleInstance;
			
 
				+
			
 
				+        /**
			
 
				+         * @param {string} provider
			
 
				+         * @param {string} method
			
 
				+         * @param {String=} insertMethod
			
 
				+         * @returns {angular.Module}
			
 
				+         */
			
 
				+        function invokeLater(provider, method, insertMethod, queue) {
			
 
				+          if (!queue) queue = invokeQueue;
			
 
				+          return function() {
			
 
				+            queue[insertMethod || 'push']([provider, method, arguments]);
			
 
				+            return moduleInstance;
			
 
				+          };
			
 
				+        }
			
 
				+      });
			
 
				+    };
			
 
				+  });
			
 
				+
			
 
				+}
			
 
				+
			
 
				+setupModuleLoader(window);
			
 
				+})(window);
			
 
				+
			
 
				+/**
			
 
				+ * Closure compiler type information
			
 
				+ *
			
 
				+ * @typedef { {
			
 
				+ *   requires: !Array.<string>,
			
 
				+ *   invokeQueue: !Array.<Array.<*>>,
			
 
				+ *
			
 
				+ *   service: function(string, Function):angular.Module,
			
 
				+ *   factory: function(string, Function):angular.Module,
			
 
				+ *   value: function(string, *):angular.Module,
			
 
				+ *
			
 
				+ *   filter: function(string, Function):angular.Module,
			
 
				+ *
			
 
				+ *   init: function(Function):angular.Module
			
 
				+ * } }
			
 
				+ */
			
 
				+angular.Module;
			
 
				+
			
--- a/src/js/angularjs/angular-loader.min.js
+++ b/src/js/angularjs/angular-loader.min.js
--- a/src/js/angularjs/angular-loader.min.js.map
+++ b/src/js/angularjs/angular-loader.min.js.map
--- a/src/js/angularjs/angular-messages.js
+++ b/src/js/angularjs/angular-messages.js
@@ -0,0 +1,400 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngMessages
			
 
				+ * @description
			
 
				+ *
			
 
				+ * The `ngMessages` module provides enhanced support for displaying messages within templates
			
 
				+ * (typically within forms or when rendering message objects that return key/value data).
			
 
				+ * Instead of relying on JavaScript code and/or complex ng-if statements within your form template to
			
 
				+ * show and hide error messages specific to the state of an input field, the `ngMessages` and
			
 
				+ * `ngMessage` directives are designed to handle the complexity, inheritance and priority
			
 
				+ * sequencing based on the order of how the messages are defined in the template.
			
 
				+ *
			
 
				+ * Currently, the ngMessages module only contains the code for the `ngMessages`
			
 
				+ * and `ngMessage` directives.
			
 
				+ *
			
 
				+ * # Usage
			
 
				+ * The `ngMessages` directive listens on a key/value collection which is set on the ngMessages attribute.
			
 
				+ * Since the {@link ngModel ngModel} directive exposes an `$error` object, this error object can be
			
 
				+ * used with `ngMessages` to display control error messages in an easier way than with just regular angular
			
 
				+ * template directives.
			
 
				+ *
			
 
				+ * ```html
			
 
				+ * <form name="myForm">
			
 
				+ *   <input type="text" ng-model="field" name="myField" required minlength="5" />
			
 
				+ *   <div ng-messages="myForm.myField.$error">
			
 
				+ *     <div ng-message="required">You did not enter a field</div>
			
 
				+ *     <div ng-message="minlength">The value entered is too short</div>
			
 
				+ *   </div>
			
 
				+ * </form>
			
 
				+ * ```
			
 
				+ *
			
 
				+ * Now whatever key/value entries are present within the provided object (in this case `$error`) then
			
 
				+ * the ngMessages directive will render the inner first ngMessage directive (depending if the key values
			
 
				+ * match the attribute value present on each ngMessage directive). In other words, if your errors
			
 
				+ * object contains the following data:
			
 
				+ *
			
 
				+ * ```javascript
			
 
				+ * <!-- keep in mind that ngModel automatically sets these error flags -->
			
 
				+ * myField.$error = { minlength : true, required : false };
			
 
				+ * ```
			
 
				+ *
			
 
				+ * Then the `required` message will be displayed first. When required is false then the `minlength` message
			
 
				+ * will be displayed right after (since these messages are ordered this way in the template HTML code).
			
 
				+ * The prioritization of each message is determined by what order they're present in the DOM.
			
 
				+ * Therefore, instead of having custom JavaScript code determine the priority of what errors are
			
 
				+ * present before others, the presentation of the errors are handled within the template.
			
 
				+ *
			
 
				+ * By default, ngMessages will only display one error at a time. However, if you wish to display all
			
 
				+ * messages then the `ng-messages-multiple` attribute flag can be used on the element containing the
			
 
				+ * ngMessages directive to make this happen.
			
 
				+ *
			
 
				+ * ```html
			
 
				+ * <div ng-messages="myForm.myField.$error" ng-messages-multiple>...</div>
			
 
				+ * ```
			
 
				+ *
			
 
				+ * ## Reusing and Overriding Messages
			
 
				+ * In addition to prioritization, ngMessages also allows for including messages from a remote or an inline
			
 
				+ * template. This allows for generic collection of messages to be reused across multiple parts of an
			
 
				+ * application.
			
 
				+ *
			
 
				+ * ```html
			
 
				+ * <script type="text/ng-template" id="error-messages">
			
 
				+ *   <div ng-message="required">This field is required</div>
			
 
				+ *   <div ng-message="minlength">This field is too short</div>
			
 
				+ * </script>
			
 
				+ * <div ng-messages="myForm.myField.$error" ng-messages-include="error-messages"></div>
			
 
				+ * ```
			
 
				+ *
			
 
				+ * However, including generic messages may not be useful enough to match all input fields, therefore,
			
 
				+ * `ngMessages` provides the ability to override messages defined in the remote template by redefining
			
 
				+ * then within the directive container.
			
 
				+ *
			
 
				+ * ```html
			
 
				+ * <!-- a generic template of error messages known as "my-custom-messages" -->
			
 
				+ * <script type="text/ng-template" id="my-custom-messages">
			
 
				+ *   <div ng-message="required">This field is required</div>
			
 
				+ *   <div ng-message="minlength">This field is too short</div>
			
 
				+ * </script>
			
 
				+ *
			
 
				+ * <form name="myForm">
			
 
				+ *   <input type="email"
			
 
				+ *          id="email"
			
 
				+ *          name="myEmail"
			
 
				+ *          ng-model="email"
			
 
				+ *          minlength="5"
			
 
				+ *          required />
			
 
				+ *
			
 
				+ *   <div ng-messages="myForm.myEmail.$error" ng-messages-include="my-custom-messages">
			
 
				+ *     <!-- this required message has overridden the template message -->
			
 
				+ *     <div ng-message="required">You did not enter your email address</div>
			
 
				+ *
			
 
				+ *     <!-- this is a brand new message and will appear last in the prioritization -->
			
 
				+ *     <div ng-message="email">Your email address is invalid</div>
			
 
				+ *   </div>
			
 
				+ * </form>
			
 
				+ * ```
			
 
				+ *
			
 
				+ * In the example HTML code above the message that is set on required will override the corresponding
			
 
				+ * required message defined within the remote template. Therefore, with particular input fields (such
			
 
				+ * email addresses, date fields, autocomplete inputs, etc...), specialized error messages can be applied
			
 
				+ * while more generic messages can be used to handle other, more general input errors.
			
 
				+ *
			
 
				+ * ## Animations
			
 
				+ * If the `ngAnimate` module is active within the application then both the `ngMessages` and
			
 
				+ * `ngMessage` directives will trigger animations whenever any messages are added and removed
			
 
				+ * from the DOM by the `ngMessages` directive.
			
 
				+ *
			
 
				+ * Whenever the `ngMessages` directive contains one or more visible messages then the `.ng-active` CSS
			
 
				+ * class will be added to the element. The `.ng-inactive` CSS class will be applied when there are no
			
 
				+ * animations present. Therefore, CSS transitions and keyframes as well as JavaScript animations can
			
 
				+ * hook into the animations whenever these classes are added/removed.
			
 
				+ *
			
 
				+ * Let's say that our HTML code for our messages container looks like so:
			
 
				+ *
			
 
				+ * ```html
			
 
				+ * <div ng-messages="myMessages" class="my-messages">
			
 
				+ *   <div ng-message="alert" class="some-message">...</div>
			
 
				+ *   <div ng-message="fail" class="some-message">...</div>
			
 
				+ * </div>
			
 
				+ * ```
			
 
				+ *
			
 
				+ * Then the CSS animation code for the message container looks like so:
			
 
				+ *
			
 
				+ * ```css
			
 
				+ * .my-messages {
			
 
				+ *   transition:1s linear all;
			
 
				+ * }
			
 
				+ * .my-messages.ng-active {
			
 
				+ *   // messages are visible
			
 
				+ * }
			
 
				+ * .my-messages.ng-inactive {
			
 
				+ *   // messages are hidden
			
 
				+ * }
			
 
				+ * ```
			
 
				+ *
			
 
				+ * Whenever an inner message is attached (becomes visible) or removed (becomes hidden) then the enter
			
 
				+ * and leave animation is triggered for each particular element bound to the `ngMessage` directive.
			
 
				+ *
			
 
				+ * Therefore, the CSS code for the inner messages looks like so:
			
 
				+ *
			
 
				+ * ```css
			
 
				+ * .some-message {
			
 
				+ *   transition:1s linear all;
			
 
				+ * }
			
 
				+ *
			
 
				+ * .some-message.ng-enter {}
			
 
				+ * .some-message.ng-enter.ng-enter-active {}
			
 
				+ *
			
 
				+ * .some-message.ng-leave {}
			
 
				+ * .some-message.ng-leave.ng-leave-active {}
			
 
				+ * ```
			
 
				+ *
			
 
				+ * {@link ngAnimate Click here} to learn how to use JavaScript animations or to learn more about ngAnimate.
			
 
				+ */
			
 
				+angular.module('ngMessages', [])
			
 
				+
			
 
				+   /**
			
 
				+    * @ngdoc directive
			
 
				+    * @module ngMessages
			
 
				+    * @name ngMessages
			
 
				+    * @restrict AE
			
 
				+    *
			
 
				+    * @description
			
 
				+    * `ngMessages` is a directive that is designed to show and hide messages based on the state
			
 
				+    * of a key/value object that it listens on. The directive itself compliments error message
			
 
				+    * reporting with the `ngModel` $error object (which stores a key/value state of validation errors).
			
 
				+    *
			
 
				+    * `ngMessages` manages the state of internal messages within its container element. The internal
			
 
				+    * messages use the `ngMessage` directive and will be inserted/removed from the page depending
			
 
				+    * on if they're present within the key/value object. By default, only one message will be displayed
			
 
				+    * at a time and this depends on the prioritization of the messages within the template. (This can
			
 
				+    * be changed by using the ng-messages-multiple on the directive container.)
			
 
				+    *
			
 
				+    * A remote template can also be used to promote message reuseability and messages can also be
			
 
				+    * overridden.
			
 
				+    *
			
 
				+    * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`.
			
 
				+    *
			
 
				+    * @usage
			
 
				+    * ```html
			
 
				+    * <!-- using attribute directives -->
			
 
				+    * <ANY ng-messages="expression">
			
 
				+    *   <ANY ng-message="keyValue1">...</ANY>
			
 
				+    *   <ANY ng-message="keyValue2">...</ANY>
			
 
				+    *   <ANY ng-message="keyValue3">...</ANY>
			
 
				+    * </ANY>
			
 
				+    *
			
 
				+    * <!-- or by using element directives -->
			
 
				+    * <ng-messages for="expression">
			
 
				+    *   <ng-message when="keyValue1">...</ng-message>
			
 
				+    *   <ng-message when="keyValue2">...</ng-message>
			
 
				+    *   <ng-message when="keyValue3">...</ng-message>
			
 
				+    * </ng-messages>
			
 
				+    * ```
			
 
				+    *
			
 
				+    * @param {string} ngMessages an angular expression evaluating to a key/value object
			
 
				+    *                 (this is typically the $error object on an ngModel instance).
			
 
				+    * @param {string=} ngMessagesMultiple|multiple when set, all messages will be displayed with true
			
 
				+    * @param {string=} ngMessagesInclude|include when set, the specified template will be included into the ng-messages container
			
 
				+    *
			
 
				+    * @example
			
 
				+    * <example name="ngMessages-directive" module="ngMessagesExample"
			
 
				+    *          deps="angular-messages.js"
			
 
				+    *          animations="true" fixBase="true">
			
 
				+    *   <file name="index.html">
			
 
				+    *     <form name="myForm">
			
 
				+    *       <label>Enter your name:</label>
			
 
				+    *       <input type="text"
			
 
				+    *              name="myName"
			
 
				+    *              ng-model="name"
			
 
				+    *              ng-minlength="5"
			
 
				+    *              ng-maxlength="20"
			
 
				+    *              required />
			
 
				+    *
			
 
				+    *       <pre>myForm.myName.$error = {{ myForm.myName.$error | json }}</pre>
			
 
				+    *
			
 
				+    *       <div ng-messages="myForm.myName.$error" style="color:maroon">
			
 
				+    *         <div ng-message="required">You did not enter a field</div>
			
 
				+    *         <div ng-message="minlength">Your field is too short</div>
			
 
				+    *         <div ng-message="maxlength">Your field is too long</div>
			
 
				+    *       </div>
			
 
				+    *     </form>
			
 
				+    *   </file>
			
 
				+    *   <file name="script.js">
			
 
				+    *     angular.module('ngMessagesExample', ['ngMessages']);
			
 
				+    *   </file>
			
 
				+    * </example>
			
 
				+    */
			
 
				+  .directive('ngMessages', ['$compile', '$animate', '$templateRequest',
			
 
				+                   function($compile,    $animate,   $templateRequest) {
			
 
				+    var ACTIVE_CLASS = 'ng-active';
			
 
				+    var INACTIVE_CLASS = 'ng-inactive';
			
 
				+
			
 
				+    return {
			
 
				+      restrict: 'AE',
			
 
				+      controller: function() {
			
 
				+        this.$renderNgMessageClasses = angular.noop;
			
 
				+
			
 
				+        var messages = [];
			
 
				+        this.registerMessage = function(index, message) {
			
 
				+          for (var i = 0; i < messages.length; i++) {
			
 
				+            if (messages[i].type == message.type) {
			
 
				+              if (index != i) {
			
 
				+                var temp = messages[index];
			
 
				+                messages[index] = messages[i];
			
 
				+                if (index < messages.length) {
			
 
				+                  messages[i] = temp;
			
 
				+                } else {
			
 
				+                  messages.splice(0, i); //remove the old one (and shift left)
			
 
				+                }
			
 
				+              }
			
 
				+              return;
			
 
				+            }
			
 
				+          }
			
 
				+          messages.splice(index, 0, message); //add the new one (and shift right)
			
 
				+        };
			
 
				+
			
 
				+        this.renderMessages = function(values, multiple) {
			
 
				+          values = values || {};
			
 
				+
			
 
				+          var found;
			
 
				+          angular.forEach(messages, function(message) {
			
 
				+            if ((!found || multiple) && truthyVal(values[message.type])) {
			
 
				+              message.attach();
			
 
				+              found = true;
			
 
				+            } else {
			
 
				+              message.detach();
			
 
				+            }
			
 
				+          });
			
 
				+
			
 
				+          this.renderElementClasses(found);
			
 
				+
			
 
				+          function truthyVal(value) {
			
 
				+            return value !== null && value !== false && value;
			
 
				+          }
			
 
				+        };
			
 
				+      },
			
 
				+      require: 'ngMessages',
			
 
				+      link: function($scope, element, $attrs, ctrl) {
			
 
				+        ctrl.renderElementClasses = function(bool) {
			
 
				+          bool ? $animate.setClass(element, ACTIVE_CLASS, INACTIVE_CLASS)
			
 
				+               : $animate.setClass(element, INACTIVE_CLASS, ACTIVE_CLASS);
			
 
				+        };
			
 
				+
			
 
				+        //JavaScript treats empty strings as false, but ng-message-multiple by itself is an empty string
			
 
				+        var multiple = angular.isString($attrs.ngMessagesMultiple) ||
			
 
				+                       angular.isString($attrs.multiple);
			
 
				+
			
 
				+        var cachedValues, watchAttr = $attrs.ngMessages || $attrs['for']; //for is a reserved keyword
			
 
				+        $scope.$watchCollection(watchAttr, function(values) {
			
 
				+          cachedValues = values;
			
 
				+          ctrl.renderMessages(values, multiple);
			
 
				+        });
			
 
				+
			
 
				+        var tpl = $attrs.ngMessagesInclude || $attrs.include;
			
 
				+        if (tpl) {
			
 
				+          $templateRequest(tpl)
			
 
				+            .then(function processTemplate(html) {
			
 
				+              var after, container = angular.element('<div/>').html(html);
			
 
				+              angular.forEach(container.children(), function(elm) {
			
 
				+               elm = angular.element(elm);
			
 
				+               after ? after.after(elm)
			
 
				+                     : element.prepend(elm); //start of the container
			
 
				+               after = elm;
			
 
				+               $compile(elm)($scope);
			
 
				+              });
			
 
				+              ctrl.renderMessages(cachedValues, multiple);
			
 
				+            });
			
 
				+        }
			
 
				+      }
			
 
				+    };
			
 
				+  }])
			
 
				+
			
 
				+
			
 
				+   /**
			
 
				+    * @ngdoc directive
			
 
				+    * @name ngMessage
			
 
				+    * @restrict AE
			
 
				+    * @scope
			
 
				+    *
			
 
				+    * @description
			
 
				+    * `ngMessage` is a directive with the purpose to show and hide a particular message.
			
 
				+    * For `ngMessage` to operate, a parent `ngMessages` directive on a parent DOM element
			
 
				+    * must be situated since it determines which messages are visible based on the state
			
 
				+    * of the provided key/value map that `ngMessages` listens on.
			
 
				+    *
			
 
				+    * @usage
			
 
				+    * ```html
			
 
				+    * <!-- using attribute directives -->
			
 
				+    * <ANY ng-messages="expression">
			
 
				+    *   <ANY ng-message="keyValue1">...</ANY>
			
 
				+    *   <ANY ng-message="keyValue2">...</ANY>
			
 
				+    *   <ANY ng-message="keyValue3">...</ANY>
			
 
				+    * </ANY>
			
 
				+    *
			
 
				+    * <!-- or by using element directives -->
			
 
				+    * <ng-messages for="expression">
			
 
				+    *   <ng-message when="keyValue1">...</ng-message>
			
 
				+    *   <ng-message when="keyValue2">...</ng-message>
			
 
				+    *   <ng-message when="keyValue3">...</ng-message>
			
 
				+    * </ng-messages>
			
 
				+    * ```
			
 
				+    *
			
 
				+    * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`.
			
 
				+    *
			
 
				+    * @param {string} ngMessage a string value corresponding to the message key.
			
 
				+    */
			
 
				+  .directive('ngMessage', ['$animate', function($animate) {
			
 
				+    var COMMENT_NODE = 8;
			
 
				+    return {
			
 
				+      require: '^ngMessages',
			
 
				+      transclude: 'element',
			
 
				+      terminal: true,
			
 
				+      restrict: 'AE',
			
 
				+      link: function($scope, $element, $attrs, ngMessages, $transclude) {
			
 
				+        var index, element;
			
 
				+
			
 
				+        var commentNode = $element[0];
			
 
				+        var parentNode = commentNode.parentNode;
			
 
				+        for (var i = 0, j = 0; i < parentNode.childNodes.length; i++) {
			
 
				+          var node = parentNode.childNodes[i];
			
 
				+          if (node.nodeType == COMMENT_NODE && node.nodeValue.indexOf('ngMessage') >= 0) {
			
 
				+            if (node === commentNode) {
			
 
				+              index = j;
			
 
				+              break;
			
 
				+            }
			
 
				+            j++;
			
 
				+          }
			
 
				+        }
			
 
				+
			
 
				+        ngMessages.registerMessage(index, {
			
 
				+          type: $attrs.ngMessage || $attrs.when,
			
 
				+          attach: function() {
			
 
				+            if (!element) {
			
 
				+              $transclude($scope, function(clone) {
			
 
				+                $animate.enter(clone, null, $element);
			
 
				+                element = clone;
			
 
				+              });
			
 
				+            }
			
 
				+          },
			
 
				+          detach: function(now) {
			
 
				+            if (element) {
			
 
				+              $animate.leave(element);
			
 
				+              element = null;
			
 
				+            }
			
 
				+          }
			
 
				+        });
			
 
				+      }
			
 
				+    };
			
 
				+  }]);
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-messages.min.js
+++ b/src/js/angularjs/angular-messages.min.js
--- a/src/js/angularjs/angular-messages.min.js.map
+++ b/src/js/angularjs/angular-messages.min.js.map
--- a/src/js/angularjs/angular-mocks.js
+++ b/src/js/angularjs/angular-mocks.js
--- a/src/js/angularjs/angular-resource.js
+++ b/src/js/angularjs/angular-resource.js
@@ -0,0 +1,667 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+var $resourceMinErr = angular.$$minErr('$resource');
			
 
				+
			
 
				+// Helper functions and regex to lookup a dotted path on an object
			
 
				+// stopping at undefined/null.  The path must be composed of ASCII
			
 
				+// identifiers (just like $parse)
			
 
				+var MEMBER_NAME_REGEX = /^(\.[a-zA-Z_$][0-9a-zA-Z_$]*)+$/;
			
 
				+
			
 
				+function isValidDottedPath(path) {
			
 
				+  return (path != null && path !== '' && path !== 'hasOwnProperty' &&
			
 
				+      MEMBER_NAME_REGEX.test('.' + path));
			
 
				+}
			
 
				+
			
 
				+function lookupDottedPath(obj, path) {
			
 
				+  if (!isValidDottedPath(path)) {
			
 
				+    throw $resourceMinErr('badmember', 'Dotted member path "@{0}" is invalid.', path);
			
 
				+  }
			
 
				+  var keys = path.split('.');
			
 
				+  for (var i = 0, ii = keys.length; i < ii && obj !== undefined; i++) {
			
 
				+    var key = keys[i];
			
 
				+    obj = (obj !== null) ? obj[key] : undefined;
			
 
				+  }
			
 
				+  return obj;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Create a shallow copy of an object and clear other fields from the destination
			
 
				+ */
			
 
				+function shallowClearAndCopy(src, dst) {
			
 
				+  dst = dst || {};
			
 
				+
			
 
				+  angular.forEach(dst, function(value, key) {
			
 
				+    delete dst[key];
			
 
				+  });
			
 
				+
			
 
				+  for (var key in src) {
			
 
				+    if (src.hasOwnProperty(key) && !(key.charAt(0) === '$' && key.charAt(1) === '$')) {
			
 
				+      dst[key] = src[key];
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  return dst;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngResource
			
 
				+ * @description
			
 
				+ *
			
 
				+ * # ngResource
			
 
				+ *
			
 
				+ * The `ngResource` module provides interaction support with RESTful services
			
 
				+ * via the $resource service.
			
 
				+ *
			
 
				+ *
			
 
				+ * <div doc-module-components="ngResource"></div>
			
 
				+ *
			
 
				+ * See {@link ngResource.$resource `$resource`} for usage.
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc service
			
 
				+ * @name $resource
			
 
				+ * @requires $http
			
 
				+ *
			
 
				+ * @description
			
 
				+ * A factory which creates a resource object that lets you interact with
			
 
				+ * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
			
 
				+ *
			
 
				+ * The returned resource object has action methods which provide high-level behaviors without
			
 
				+ * the need to interact with the low level {@link ng.$http $http} service.
			
 
				+ *
			
 
				+ * Requires the {@link ngResource `ngResource`} module to be installed.
			
 
				+ *
			
 
				+ * By default, trailing slashes will be stripped from the calculated URLs,
			
 
				+ * which can pose problems with server backends that do not expect that
			
 
				+ * behavior.  This can be disabled by configuring the `$resourceProvider` like
			
 
				+ * this:
			
 
				+ *
			
 
				+ * ```js
			
 
				+     app.config(['$resourceProvider', function($resourceProvider) {
			
 
				+       // Don't strip trailing slashes from calculated URLs
			
 
				+       $resourceProvider.defaults.stripTrailingSlashes = false;
			
 
				+     }]);
			
 
				+ * ```
			
 
				+ *
			
 
				+ * @param {string} url A parametrized URL template with parameters prefixed by `:` as in
			
 
				+ *   `/user/:username`. If you are using a URL with a port number (e.g.
			
 
				+ *   `http://example.com:8080/api`), it will be respected.
			
 
				+ *
			
 
				+ *   If you are using a url with a suffix, just add the suffix, like this:
			
 
				+ *   `$resource('http://example.com/resource.json')` or `$resource('http://example.com/:id.json')`
			
 
				+ *   or even `$resource('http://example.com/resource/:resource_id.:format')`
			
 
				+ *   If the parameter before the suffix is empty, :resource_id in this case, then the `/.` will be
			
 
				+ *   collapsed down to a single `.`.  If you need this sequence to appear and not collapse then you
			
 
				+ *   can escape it with `/\.`.
			
 
				+ *
			
 
				+ * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
			
 
				+ *   `actions` methods. If any of the parameter value is a function, it will be executed every time
			
 
				+ *   when a param value needs to be obtained for a request (unless the param was overridden).
			
 
				+ *
			
 
				+ *   Each key value in the parameter object is first bound to url template if present and then any
			
 
				+ *   excess keys are appended to the url search query after the `?`.
			
 
				+ *
			
 
				+ *   Given a template `/path/:verb` and parameter `{verb:'greet', salutation:'Hello'}` results in
			
 
				+ *   URL `/path/greet?salutation=Hello`.
			
 
				+ *
			
 
				+ *   If the parameter value is prefixed with `@` then the value for that parameter will be extracted
			
 
				+ *   from the corresponding property on the `data` object (provided when calling an action method).  For
			
 
				+ *   example, if the `defaultParam` object is `{someParam: '@someProp'}` then the value of `someParam`
			
 
				+ *   will be `data.someProp`.
			
 
				+ *
			
 
				+ * @param {Object.<Object>=} actions Hash with declaration of custom action that should extend
			
 
				+ *   the default set of resource actions. The declaration should be created in the format of {@link
			
 
				+ *   ng.$http#usage $http.config}:
			
 
				+ *
			
 
				+ *       {action1: {method:?, params:?, isArray:?, headers:?, ...},
			
 
				+ *        action2: {method:?, params:?, isArray:?, headers:?, ...},
			
 
				+ *        ...}
			
 
				+ *
			
 
				+ *   Where:
			
 
				+ *
			
 
				+ *   - **`action`** – {string} – The name of action. This name becomes the name of the method on
			
 
				+ *     your resource object.
			
 
				+ *   - **`method`** – {string} – Case insensitive HTTP method (e.g. `GET`, `POST`, `PUT`,
			
 
				+ *     `DELETE`, `JSONP`, etc).
			
 
				+ *   - **`params`** – {Object=} – Optional set of pre-bound parameters for this action. If any of
			
 
				+ *     the parameter value is a function, it will be executed every time when a param value needs to
			
 
				+ *     be obtained for a request (unless the param was overridden).
			
 
				+ *   - **`url`** – {string} – action specific `url` override. The url templating is supported just
			
 
				+ *     like for the resource-level urls.
			
 
				+ *   - **`isArray`** – {boolean=} – If true then the returned object for this action is an array,
			
 
				+ *     see `returns` section.
			
 
				+ *   - **`transformRequest`** –
			
 
				+ *     `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
			
 
				+ *     transform function or an array of such functions. The transform function takes the http
			
 
				+ *     request body and headers and returns its transformed (typically serialized) version.
			
 
				+ *     By default, transformRequest will contain one function that checks if the request data is
			
 
				+ *     an object and serializes to using `angular.toJson`. To prevent this behavior, set
			
 
				+ *     `transformRequest` to an empty array: `transformRequest: []`
			
 
				+ *   - **`transformResponse`** –
			
 
				+ *     `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
			
 
				+ *     transform function or an array of such functions. The transform function takes the http
			
 
				+ *     response body and headers and returns its transformed (typically deserialized) version.
			
 
				+ *     By default, transformResponse will contain one function that checks if the response looks like
			
 
				+ *     a JSON string and deserializes it using `angular.fromJson`. To prevent this behavior, set
			
 
				+ *     `transformResponse` to an empty array: `transformResponse: []`
			
 
				+ *   - **`cache`** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
			
 
				+ *     GET request, otherwise if a cache instance built with
			
 
				+ *     {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
			
 
				+ *     caching.
			
 
				+ *   - **`timeout`** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise} that
			
 
				+ *     should abort the request when resolved.
			
 
				+ *   - **`withCredentials`** - `{boolean}` - whether to set the `withCredentials` flag on the
			
 
				+ *     XHR object. See
			
 
				+ *     [requests with credentials](https://developer.mozilla.org/en/http_access_control#section_5)
			
 
				+ *     for more information.
			
 
				+ *   - **`responseType`** - `{string}` - see
			
 
				+ *     [requestType](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType).
			
 
				+ *   - **`interceptor`** - `{Object=}` - The interceptor object has two optional methods -
			
 
				+ *     `response` and `responseError`. Both `response` and `responseError` interceptors get called
			
 
				+ *     with `http response` object. See {@link ng.$http $http interceptors}.
			
 
				+ *
			
 
				+ * @param {Object} options Hash with custom settings that should extend the
			
 
				+ *   default `$resourceProvider` behavior.  The only supported option is
			
 
				+ *
			
 
				+ *   Where:
			
 
				+ *
			
 
				+ *   - **`stripTrailingSlashes`** – {boolean} – If true then the trailing
			
 
				+ *   slashes from any calculated URL will be stripped. (Defaults to true.)
			
 
				+ *
			
 
				+ * @returns {Object} A resource "class" object with methods for the default set of resource actions
			
 
				+ *   optionally extended with custom `actions`. The default set contains these actions:
			
 
				+ *   ```js
			
 
				+ *   { 'get':    {method:'GET'},
			
 
				+ *     'save':   {method:'POST'},
			
 
				+ *     'query':  {method:'GET', isArray:true},
			
 
				+ *     'remove': {method:'DELETE'},
			
 
				+ *     'delete': {method:'DELETE'} };
			
 
				+ *   ```
			
 
				+ *
			
 
				+ *   Calling these methods invoke an {@link ng.$http} with the specified http method,
			
 
				+ *   destination and parameters. When the data is returned from the server then the object is an
			
 
				+ *   instance of the resource class. The actions `save`, `remove` and `delete` are available on it
			
 
				+ *   as  methods with the `$` prefix. This allows you to easily perform CRUD operations (create,
			
 
				+ *   read, update, delete) on server-side data like this:
			
 
				+ *   ```js
			
 
				+ *   var User = $resource('/user/:userId', {userId:'@id'});
			
 
				+ *   var user = User.get({userId:123}, function() {
			
 
				+ *     user.abc = true;
			
 
				+ *     user.$save();
			
 
				+ *   });
			
 
				+ *   ```
			
 
				+ *
			
 
				+ *   It is important to realize that invoking a $resource object method immediately returns an
			
 
				+ *   empty reference (object or array depending on `isArray`). Once the data is returned from the
			
 
				+ *   server the existing reference is populated with the actual data. This is a useful trick since
			
 
				+ *   usually the resource is assigned to a model which is then rendered by the view. Having an empty
			
 
				+ *   object results in no rendering, once the data arrives from the server then the object is
			
 
				+ *   populated with the data and the view automatically re-renders itself showing the new data. This
			
 
				+ *   means that in most cases one never has to write a callback function for the action methods.
			
 
				+ *
			
 
				+ *   The action methods on the class object or instance object can be invoked with the following
			
 
				+ *   parameters:
			
 
				+ *
			
 
				+ *   - HTTP GET "class" actions: `Resource.action([parameters], [success], [error])`
			
 
				+ *   - non-GET "class" actions: `Resource.action([parameters], postData, [success], [error])`
			
 
				+ *   - non-GET instance actions:  `instance.$action([parameters], [success], [error])`
			
 
				+ *
			
 
				+ *   Success callback is called with (value, responseHeaders) arguments. Error callback is called
			
 
				+ *   with (httpResponse) argument.
			
 
				+ *
			
 
				+ *   Class actions return empty instance (with additional properties below).
			
 
				+ *   Instance actions return promise of the action.
			
 
				+ *
			
 
				+ *   The Resource instances and collection have these additional properties:
			
 
				+ *
			
 
				+ *   - `$promise`: the {@link ng.$q promise} of the original server interaction that created this
			
 
				+ *     instance or collection.
			
 
				+ *
			
 
				+ *     On success, the promise is resolved with the same resource instance or collection object,
			
 
				+ *     updated with data from server. This makes it easy to use in
			
 
				+ *     {@link ngRoute.$routeProvider resolve section of $routeProvider.when()} to defer view
			
 
				+ *     rendering until the resource(s) are loaded.
			
 
				+ *
			
 
				+ *     On failure, the promise is resolved with the {@link ng.$http http response} object, without
			
 
				+ *     the `resource` property.
			
 
				+ *
			
 
				+ *     If an interceptor object was provided, the promise will instead be resolved with the value
			
 
				+ *     returned by the interceptor.
			
 
				+ *
			
 
				+ *   - `$resolved`: `true` after first server interaction is completed (either with success or
			
 
				+ *      rejection), `false` before that. Knowing if the Resource has been resolved is useful in
			
 
				+ *      data-binding.
			
 
				+ *
			
 
				+ * @example
			
 
				+ *
			
 
				+ * # Credit card resource
			
 
				+ *
			
 
				+ * ```js
			
 
				+     // Define CreditCard class
			
 
				+     var CreditCard = $resource('/user/:userId/card/:cardId',
			
 
				+      {userId:123, cardId:'@id'}, {
			
 
				+       charge: {method:'POST', params:{charge:true}}
			
 
				+      });
			
 
				+
			
 
				+     // We can retrieve a collection from the server
			
 
				+     var cards = CreditCard.query(function() {
			
 
				+       // GET: /user/123/card
			
 
				+       // server returns: [ {id:456, number:'1234', name:'Smith'} ];
			
 
				+
			
 
				+       var card = cards[0];
			
 
				+       // each item is an instance of CreditCard
			
 
				+       expect(card instanceof CreditCard).toEqual(true);
			
 
				+       card.name = "J. Smith";
			
 
				+       // non GET methods are mapped onto the instances
			
 
				+       card.$save();
			
 
				+       // POST: /user/123/card/456 {id:456, number:'1234', name:'J. Smith'}
			
 
				+       // server returns: {id:456, number:'1234', name: 'J. Smith'};
			
 
				+
			
 
				+       // our custom method is mapped as well.
			
 
				+       card.$charge({amount:9.99});
			
 
				+       // POST: /user/123/card/456?amount=9.99&charge=true {id:456, number:'1234', name:'J. Smith'}
			
 
				+     });
			
 
				+
			
 
				+     // we can create an instance as well
			
 
				+     var newCard = new CreditCard({number:'0123'});
			
 
				+     newCard.name = "Mike Smith";
			
 
				+     newCard.$save();
			
 
				+     // POST: /user/123/card {number:'0123', name:'Mike Smith'}
			
 
				+     // server returns: {id:789, number:'0123', name: 'Mike Smith'};
			
 
				+     expect(newCard.id).toEqual(789);
			
 
				+ * ```
			
 
				+ *
			
 
				+ * The object returned from this function execution is a resource "class" which has "static" method
			
 
				+ * for each action in the definition.
			
 
				+ *
			
 
				+ * Calling these methods invoke `$http` on the `url` template with the given `method`, `params` and
			
 
				+ * `headers`.
			
 
				+ * When the data is returned from the server then the object is an instance of the resource type and
			
 
				+ * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
			
 
				+ * operations (create, read, update, delete) on server-side data.
			
 
				+
			
 
				+   ```js
			
 
				+     var User = $resource('/user/:userId', {userId:'@id'});
			
 
				+     User.get({userId:123}, function(user) {
			
 
				+       user.abc = true;
			
 
				+       user.$save();
			
 
				+     });
			
 
				+   ```
			
 
				+ *
			
 
				+ * It's worth noting that the success callback for `get`, `query` and other methods gets passed
			
 
				+ * in the response that came from the server as well as $http header getter function, so one
			
 
				+ * could rewrite the above example and get access to http headers as:
			
 
				+ *
			
 
				+   ```js
			
 
				+     var User = $resource('/user/:userId', {userId:'@id'});
			
 
				+     User.get({userId:123}, function(u, getResponseHeaders){
			
 
				+       u.abc = true;
			
 
				+       u.$save(function(u, putResponseHeaders) {
			
 
				+         //u => saved user object
			
 
				+         //putResponseHeaders => $http header getter
			
 
				+       });
			
 
				+     });
			
 
				+   ```
			
 
				+ *
			
 
				+ * You can also access the raw `$http` promise via the `$promise` property on the object returned
			
 
				+ *
			
 
				+   ```
			
 
				+     var User = $resource('/user/:userId', {userId:'@id'});
			
 
				+     User.get({userId:123})
			
 
				+         .$promise.then(function(user) {
			
 
				+           $scope.user = user;
			
 
				+         });
			
 
				+   ```
			
 
				+
			
 
				+ * # Creating a custom 'PUT' request
			
 
				+ * In this example we create a custom method on our resource to make a PUT request
			
 
				+ * ```js
			
 
				+ *    var app = angular.module('app', ['ngResource', 'ngRoute']);
			
 
				+ *
			
 
				+ *    // Some APIs expect a PUT request in the format URL/object/ID
			
 
				+ *    // Here we are creating an 'update' method
			
 
				+ *    app.factory('Notes', ['$resource', function($resource) {
			
 
				+ *    return $resource('/notes/:id', null,
			
 
				+ *        {
			
 
				+ *            'update': { method:'PUT' }
			
 
				+ *        });
			
 
				+ *    }]);
			
 
				+ *
			
 
				+ *    // In our controller we get the ID from the URL using ngRoute and $routeParams
			
 
				+ *    // We pass in $routeParams and our Notes factory along with $scope
			
 
				+ *    app.controller('NotesCtrl', ['$scope', '$routeParams', 'Notes',
			
 
				+                                      function($scope, $routeParams, Notes) {
			
 
				+ *    // First get a note object from the factory
			
 
				+ *    var note = Notes.get({ id:$routeParams.id });
			
 
				+ *    $id = note.id;
			
 
				+ *
			
 
				+ *    // Now call update passing in the ID first then the object you are updating
			
 
				+ *    Notes.update({ id:$id }, note);
			
 
				+ *
			
 
				+ *    // This will PUT /notes/ID with the note object in the request payload
			
 
				+ *    }]);
			
 
				+ * ```
			
 
				+ */
			
 
				+angular.module('ngResource', ['ng']).
			
 
				+  provider('$resource', function() {
			
 
				+    var provider = this;
			
 
				+
			
 
				+    this.defaults = {
			
 
				+      // Strip slashes by default
			
 
				+      stripTrailingSlashes: true,
			
 
				+
			
 
				+      // Default actions configuration
			
 
				+      actions: {
			
 
				+        'get': {method: 'GET'},
			
 
				+        'save': {method: 'POST'},
			
 
				+        'query': {method: 'GET', isArray: true},
			
 
				+        'remove': {method: 'DELETE'},
			
 
				+        'delete': {method: 'DELETE'}
			
 
				+      }
			
 
				+    };
			
 
				+
			
 
				+    this.$get = ['$http', '$q', function($http, $q) {
			
 
				+
			
 
				+      var noop = angular.noop,
			
 
				+        forEach = angular.forEach,
			
 
				+        extend = angular.extend,
			
 
				+        copy = angular.copy,
			
 
				+        isFunction = angular.isFunction;
			
 
				+
			
 
				+      /**
			
 
				+       * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
			
 
				+       * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set
			
 
				+       * (pchar) allowed in path segments:
			
 
				+       *    segment       = *pchar
			
 
				+       *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
			
 
				+       *    pct-encoded   = "%" HEXDIG HEXDIG
			
 
				+       *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
			
 
				+       *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
			
 
				+       *                     / "*" / "+" / "," / ";" / "="
			
 
				+       */
			
 
				+      function encodeUriSegment(val) {
			
 
				+        return encodeUriQuery(val, true).
			
 
				+          replace(/%26/gi, '&').
			
 
				+          replace(/%3D/gi, '=').
			
 
				+          replace(/%2B/gi, '+');
			
 
				+      }
			
 
				+
			
 
				+
			
 
				+      /**
			
 
				+       * This method is intended for encoding *key* or *value* parts of query component. We need a
			
 
				+       * custom method because encodeURIComponent is too aggressive and encodes stuff that doesn't
			
 
				+       * have to be encoded per http://tools.ietf.org/html/rfc3986:
			
 
				+       *    query       = *( pchar / "/" / "?" )
			
 
				+       *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
			
 
				+       *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
			
 
				+       *    pct-encoded   = "%" HEXDIG HEXDIG
			
 
				+       *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
			
 
				+       *                     / "*" / "+" / "," / ";" / "="
			
 
				+       */
			
 
				+      function encodeUriQuery(val, pctEncodeSpaces) {
			
 
				+        return encodeURIComponent(val).
			
 
				+          replace(/%40/gi, '@').
			
 
				+          replace(/%3A/gi, ':').
			
 
				+          replace(/%24/g, '$').
			
 
				+          replace(/%2C/gi, ',').
			
 
				+          replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
			
 
				+      }
			
 
				+
			
 
				+      function Route(template, defaults) {
			
 
				+        this.template = template;
			
 
				+        this.defaults = extend({}, provider.defaults, defaults);
			
 
				+        this.urlParams = {};
			
 
				+      }
			
 
				+
			
 
				+      Route.prototype = {
			
 
				+        setUrlParams: function(config, params, actionUrl) {
			
 
				+          var self = this,
			
 
				+            url = actionUrl || self.template,
			
 
				+            val,
			
 
				+            encodedVal;
			
 
				+
			
 
				+          var urlParams = self.urlParams = {};
			
 
				+          forEach(url.split(/\W/), function(param) {
			
 
				+            if (param === 'hasOwnProperty') {
			
 
				+              throw $resourceMinErr('badname', "hasOwnProperty is not a valid parameter name.");
			
 
				+            }
			
 
				+            if (!(new RegExp("^\\d+$").test(param)) && param &&
			
 
				+              (new RegExp("(^|[^\\\\]):" + param + "(\\W|$)").test(url))) {
			
 
				+              urlParams[param] = true;
			
 
				+            }
			
 
				+          });
			
 
				+          url = url.replace(/\\:/g, ':');
			
 
				+
			
 
				+          params = params || {};
			
 
				+          forEach(self.urlParams, function(_, urlParam) {
			
 
				+            val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam];
			
 
				+            if (angular.isDefined(val) && val !== null) {
			
 
				+              encodedVal = encodeUriSegment(val);
			
 
				+              url = url.replace(new RegExp(":" + urlParam + "(\\W|$)", "g"), function(match, p1) {
			
 
				+                return encodedVal + p1;
			
 
				+              });
			
 
				+            } else {
			
 
				+              url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W|$)", "g"), function(match,
			
 
				+                  leadingSlashes, tail) {
			
 
				+                if (tail.charAt(0) == '/') {
			
 
				+                  return tail;
			
 
				+                } else {
			
 
				+                  return leadingSlashes + tail;
			
 
				+                }
			
 
				+              });
			
 
				+            }
			
 
				+          });
			
 
				+
			
 
				+          // strip trailing slashes and set the url (unless this behavior is specifically disabled)
			
 
				+          if (self.defaults.stripTrailingSlashes) {
			
 
				+            url = url.replace(/\/+$/, '') || '/';
			
 
				+          }
			
 
				+
			
 
				+          // then replace collapse `/.` if found in the last URL path segment before the query
			
 
				+          // E.g. `http://url.com/id./format?q=x` becomes `http://url.com/id.format?q=x`
			
 
				+          url = url.replace(/\/\.(?=\w+($|\?))/, '.');
			
 
				+          // replace escaped `/\.` with `/.`
			
 
				+          config.url = url.replace(/\/\\\./, '/.');
			
 
				+
			
 
				+
			
 
				+          // set params - delegate param encoding to $http
			
 
				+          forEach(params, function(value, key) {
			
 
				+            if (!self.urlParams[key]) {
			
 
				+              config.params = config.params || {};
			
 
				+              config.params[key] = value;
			
 
				+            }
			
 
				+          });
			
 
				+        }
			
 
				+      };
			
 
				+
			
 
				+
			
 
				+      function resourceFactory(url, paramDefaults, actions, options) {
			
 
				+        var route = new Route(url, options);
			
 
				+
			
 
				+        actions = extend({}, provider.defaults.actions, actions);
			
 
				+
			
 
				+        function extractParams(data, actionParams) {
			
 
				+          var ids = {};
			
 
				+          actionParams = extend({}, paramDefaults, actionParams);
			
 
				+          forEach(actionParams, function(value, key) {
			
 
				+            if (isFunction(value)) { value = value(); }
			
 
				+            ids[key] = value && value.charAt && value.charAt(0) == '@' ?
			
 
				+              lookupDottedPath(data, value.substr(1)) : value;
			
 
				+          });
			
 
				+          return ids;
			
 
				+        }
			
 
				+
			
 
				+        function defaultResponseInterceptor(response) {
			
 
				+          return response.resource;
			
 
				+        }
			
 
				+
			
 
				+        function Resource(value) {
			
 
				+          shallowClearAndCopy(value || {}, this);
			
 
				+        }
			
 
				+
			
 
				+        Resource.prototype.toJSON = function() {
			
 
				+          var data = extend({}, this);
			
 
				+          delete data.$promise;
			
 
				+          delete data.$resolved;
			
 
				+          return data;
			
 
				+        };
			
 
				+
			
 
				+        forEach(actions, function(action, name) {
			
 
				+          var hasBody = /^(POST|PUT|PATCH)$/i.test(action.method);
			
 
				+
			
 
				+          Resource[name] = function(a1, a2, a3, a4) {
			
 
				+            var params = {}, data, success, error;
			
 
				+
			
 
				+            /* jshint -W086 */ /* (purposefully fall through case statements) */
			
 
				+            switch (arguments.length) {
			
 
				+              case 4:
			
 
				+                error = a4;
			
 
				+                success = a3;
			
 
				+              //fallthrough
			
 
				+              case 3:
			
 
				+              case 2:
			
 
				+                if (isFunction(a2)) {
			
 
				+                  if (isFunction(a1)) {
			
 
				+                    success = a1;
			
 
				+                    error = a2;
			
 
				+                    break;
			
 
				+                  }
			
 
				+
			
 
				+                  success = a2;
			
 
				+                  error = a3;
			
 
				+                  //fallthrough
			
 
				+                } else {
			
 
				+                  params = a1;
			
 
				+                  data = a2;
			
 
				+                  success = a3;
			
 
				+                  break;
			
 
				+                }
			
 
				+              case 1:
			
 
				+                if (isFunction(a1)) success = a1;
			
 
				+                else if (hasBody) data = a1;
			
 
				+                else params = a1;
			
 
				+                break;
			
 
				+              case 0: break;
			
 
				+              default:
			
 
				+                throw $resourceMinErr('badargs',
			
 
				+                  "Expected up to 4 arguments [params, data, success, error], got {0} arguments",
			
 
				+                  arguments.length);
			
 
				+            }
			
 
				+            /* jshint +W086 */ /* (purposefully fall through case statements) */
			
 
				+
			
 
				+            var isInstanceCall = this instanceof Resource;
			
 
				+            var value = isInstanceCall ? data : (action.isArray ? [] : new Resource(data));
			
 
				+            var httpConfig = {};
			
 
				+            var responseInterceptor = action.interceptor && action.interceptor.response ||
			
 
				+              defaultResponseInterceptor;
			
 
				+            var responseErrorInterceptor = action.interceptor && action.interceptor.responseError ||
			
 
				+              undefined;
			
 
				+
			
 
				+            forEach(action, function(value, key) {
			
 
				+              if (key != 'params' && key != 'isArray' && key != 'interceptor') {
			
 
				+                httpConfig[key] = copy(value);
			
 
				+              }
			
 
				+            });
			
 
				+
			
 
				+            if (hasBody) httpConfig.data = data;
			
 
				+            route.setUrlParams(httpConfig,
			
 
				+              extend({}, extractParams(data, action.params || {}), params),
			
 
				+              action.url);
			
 
				+
			
 
				+            var promise = $http(httpConfig).then(function(response) {
			
 
				+              var data = response.data,
			
 
				+                promise = value.$promise;
			
 
				+
			
 
				+              if (data) {
			
 
				+                // Need to convert action.isArray to boolean in case it is undefined
			
 
				+                // jshint -W018
			
 
				+                if (angular.isArray(data) !== (!!action.isArray)) {
			
 
				+                  throw $resourceMinErr('badcfg',
			
 
				+                      'Error in resource configuration for action `{0}`. Expected response to ' +
			
 
				+                      'contain an {1} but got an {2}', name, action.isArray ? 'array' : 'object',
			
 
				+                    angular.isArray(data) ? 'array' : 'object');
			
 
				+                }
			
 
				+                // jshint +W018
			
 
				+                if (action.isArray) {
			
 
				+                  value.length = 0;
			
 
				+                  forEach(data, function(item) {
			
 
				+                    if (typeof item === "object") {
			
 
				+                      value.push(new Resource(item));
			
 
				+                    } else {
			
 
				+                      // Valid JSON values may be string literals, and these should not be converted
			
 
				+                      // into objects. These items will not have access to the Resource prototype
			
 
				+                      // methods, but unfortunately there
			
 
				+                      value.push(item);
			
 
				+                    }
			
 
				+                  });
			
 
				+                } else {
			
 
				+                  shallowClearAndCopy(data, value);
			
 
				+                  value.$promise = promise;
			
 
				+                }
			
 
				+              }
			
 
				+
			
 
				+              value.$resolved = true;
			
 
				+
			
 
				+              response.resource = value;
			
 
				+
			
 
				+              return response;
			
 
				+            }, function(response) {
			
 
				+              value.$resolved = true;
			
 
				+
			
 
				+              (error || noop)(response);
			
 
				+
			
 
				+              return $q.reject(response);
			
 
				+            });
			
 
				+
			
 
				+            promise = promise.then(
			
 
				+              function(response) {
			
 
				+                var value = responseInterceptor(response);
			
 
				+                (success || noop)(value, response.headers);
			
 
				+                return value;
			
 
				+              },
			
 
				+              responseErrorInterceptor);
			
 
				+
			
 
				+            if (!isInstanceCall) {
			
 
				+              // we are creating instance / collection
			
 
				+              // - set the initial promise
			
 
				+              // - return the instance / collection
			
 
				+              value.$promise = promise;
			
 
				+              value.$resolved = false;
			
 
				+
			
 
				+              return value;
			
 
				+            }
			
 
				+
			
 
				+            // instance call
			
 
				+            return promise;
			
 
				+          };
			
 
				+
			
 
				+
			
 
				+          Resource.prototype['$' + name] = function(params, success, error) {
			
 
				+            if (isFunction(params)) {
			
 
				+              error = success; success = params; params = {};
			
 
				+            }
			
 
				+            var result = Resource[name].call(this, params, this, success, error);
			
 
				+            return result.$promise || result;
			
 
				+          };
			
 
				+        });
			
 
				+
			
 
				+        Resource.bind = function(additionalParamDefaults) {
			
 
				+          return resourceFactory(url, extend({}, paramDefaults, additionalParamDefaults), actions);
			
 
				+        };
			
 
				+
			
 
				+        return Resource;
			
 
				+      }
			
 
				+
			
 
				+      return resourceFactory;
			
 
				+    }];
			
 
				+  });
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-resource.min.js
+++ b/src/js/angularjs/angular-resource.min.js
--- a/src/js/angularjs/angular-resource.min.js.map
+++ b/src/js/angularjs/angular-resource.min.js.map
--- a/src/js/angularjs/angular-route.js
+++ b/src/js/angularjs/angular-route.js
@@ -0,0 +1,996 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngRoute
			
 
				+ * @description
			
 
				+ *
			
 
				+ * # ngRoute
			
 
				+ *
			
 
				+ * The `ngRoute` module provides routing and deeplinking services and directives for angular apps.
			
 
				+ *
			
 
				+ * ## Example
			
 
				+ * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`.
			
 
				+ *
			
 
				+ *
			
 
				+ * <div doc-module-components="ngRoute"></div>
			
 
				+ */
			
 
				+ /* global -ngRouteModule */
			
 
				+var ngRouteModule = angular.module('ngRoute', ['ng']).
			
 
				+                        provider('$route', $RouteProvider),
			
 
				+    $routeMinErr = angular.$$minErr('ngRoute');
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc provider
			
 
				+ * @name $routeProvider
			
 
				+ *
			
 
				+ * @description
			
 
				+ *
			
 
				+ * Used for configuring routes.
			
 
				+ *
			
 
				+ * ## Example
			
 
				+ * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`.
			
 
				+ *
			
 
				+ * ## Dependencies
			
 
				+ * Requires the {@link ngRoute `ngRoute`} module to be installed.
			
 
				+ */
			
 
				+function $RouteProvider() {
			
 
				+  function inherit(parent, extra) {
			
 
				+    return angular.extend(Object.create(parent), extra);
			
 
				+  }
			
 
				+
			
 
				+  var routes = {};
			
 
				+
			
 
				+  /**
			
 
				+   * @ngdoc method
			
 
				+   * @name $routeProvider#when
			
 
				+   *
			
 
				+   * @param {string} path Route path (matched against `$location.path`). If `$location.path`
			
 
				+   *    contains redundant trailing slash or is missing one, the route will still match and the
			
 
				+   *    `$location.path` will be updated to add or drop the trailing slash to exactly match the
			
 
				+   *    route definition.
			
 
				+   *
			
 
				+   *    * `path` can contain named groups starting with a colon: e.g. `:name`. All characters up
			
 
				+   *        to the next slash are matched and stored in `$routeParams` under the given `name`
			
 
				+   *        when the route matches.
			
 
				+   *    * `path` can contain named groups starting with a colon and ending with a star:
			
 
				+   *        e.g.`:name*`. All characters are eagerly stored in `$routeParams` under the given `name`
			
 
				+   *        when the route matches.
			
 
				+   *    * `path` can contain optional named groups with a question mark: e.g.`:name?`.
			
 
				+   *
			
 
				+   *    For example, routes like `/color/:color/largecode/:largecode*\/edit` will match
			
 
				+   *    `/color/brown/largecode/code/with/slashes/edit` and extract:
			
 
				+   *
			
 
				+   *    * `color: brown`
			
 
				+   *    * `largecode: code/with/slashes`.
			
 
				+   *
			
 
				+   *
			
 
				+   * @param {Object} route Mapping information to be assigned to `$route.current` on route
			
 
				+   *    match.
			
 
				+   *
			
 
				+   *    Object properties:
			
 
				+   *
			
 
				+   *    - `controller` – `{(string|function()=}` – Controller fn that should be associated with
			
 
				+   *      newly created scope or the name of a {@link angular.Module#controller registered
			
 
				+   *      controller} if passed as a string.
			
 
				+   *    - `controllerAs` – `{string=}` – A controller alias name. If present the controller will be
			
 
				+   *      published to scope under the `controllerAs` name.
			
 
				+   *    - `template` – `{string=|function()=}` – html template as a string or a function that
			
 
				+   *      returns an html template as a string which should be used by {@link
			
 
				+   *      ngRoute.directive:ngView ngView} or {@link ng.directive:ngInclude ngInclude} directives.
			
 
				+   *      This property takes precedence over `templateUrl`.
			
 
				+   *
			
 
				+   *      If `template` is a function, it will be called with the following parameters:
			
 
				+   *
			
 
				+   *      - `{Array.<Object>}` - route parameters extracted from the current
			
 
				+   *        `$location.path()` by applying the current route
			
 
				+   *
			
 
				+   *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
			
 
				+   *      template that should be used by {@link ngRoute.directive:ngView ngView}.
			
 
				+   *
			
 
				+   *      If `templateUrl` is a function, it will be called with the following parameters:
			
 
				+   *
			
 
				+   *      - `{Array.<Object>}` - route parameters extracted from the current
			
 
				+   *        `$location.path()` by applying the current route
			
 
				+   *
			
 
				+   *    - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should
			
 
				+   *      be injected into the controller. If any of these dependencies are promises, the router
			
 
				+   *      will wait for them all to be resolved or one to be rejected before the controller is
			
 
				+   *      instantiated.
			
 
				+   *      If all the promises are resolved successfully, the values of the resolved promises are
			
 
				+   *      injected and {@link ngRoute.$route#$routeChangeSuccess $routeChangeSuccess} event is
			
 
				+   *      fired. If any of the promises are rejected the
			
 
				+   *      {@link ngRoute.$route#$routeChangeError $routeChangeError} event is fired. The map object
			
 
				+   *      is:
			
 
				+   *
			
 
				+   *      - `key` – `{string}`: a name of a dependency to be injected into the controller.
			
 
				+   *      - `factory` - `{string|function}`: If `string` then it is an alias for a service.
			
 
				+   *        Otherwise if function, then it is {@link auto.$injector#invoke injected}
			
 
				+   *        and the return value is treated as the dependency. If the result is a promise, it is
			
 
				+   *        resolved before its value is injected into the controller. Be aware that
			
 
				+   *        `ngRoute.$routeParams` will still refer to the previous route within these resolve
			
 
				+   *        functions.  Use `$route.current.params` to access the new route parameters, instead.
			
 
				+   *
			
 
				+   *    - `redirectTo` – {(string|function())=} – value to update
			
 
				+   *      {@link ng.$location $location} path with and trigger route redirection.
			
 
				+   *
			
 
				+   *      If `redirectTo` is a function, it will be called with the following parameters:
			
 
				+   *
			
 
				+   *      - `{Object.<string>}` - route parameters extracted from the current
			
 
				+   *        `$location.path()` by applying the current route templateUrl.
			
 
				+   *      - `{string}` - current `$location.path()`
			
 
				+   *      - `{Object}` - current `$location.search()`
			
 
				+   *
			
 
				+   *      The custom `redirectTo` function is expected to return a string which will be used
			
 
				+   *      to update `$location.path()` and `$location.search()`.
			
 
				+   *
			
 
				+   *    - `[reloadOnSearch=true]` - {boolean=} - reload route when only `$location.search()`
			
 
				+   *      or `$location.hash()` changes.
			
 
				+   *
			
 
				+   *      If the option is set to `false` and url in the browser changes, then
			
 
				+   *      `$routeUpdate` event is broadcasted on the root scope.
			
 
				+   *
			
 
				+   *    - `[caseInsensitiveMatch=false]` - {boolean=} - match routes without being case sensitive
			
 
				+   *
			
 
				+   *      If the option is set to `true`, then the particular route can be matched without being
			
 
				+   *      case sensitive
			
 
				+   *
			
 
				+   * @returns {Object} self
			
 
				+   *
			
 
				+   * @description
			
 
				+   * Adds a new route definition to the `$route` service.
			
 
				+   */
			
 
				+  this.when = function(path, route) {
			
 
				+    //copy original route object to preserve params inherited from proto chain
			
 
				+    var routeCopy = angular.copy(route);
			
 
				+    if (angular.isUndefined(routeCopy.reloadOnSearch)) {
			
 
				+      routeCopy.reloadOnSearch = true;
			
 
				+    }
			
 
				+    if (angular.isUndefined(routeCopy.caseInsensitiveMatch)) {
			
 
				+      routeCopy.caseInsensitiveMatch = this.caseInsensitiveMatch;
			
 
				+    }
			
 
				+    routes[path] = angular.extend(
			
 
				+      routeCopy,
			
 
				+      path && pathRegExp(path, routeCopy)
			
 
				+    );
			
 
				+
			
 
				+    // create redirection for trailing slashes
			
 
				+    if (path) {
			
 
				+      var redirectPath = (path[path.length - 1] == '/')
			
 
				+            ? path.substr(0, path.length - 1)
			
 
				+            : path + '/';
			
 
				+
			
 
				+      routes[redirectPath] = angular.extend(
			
 
				+        {redirectTo: path},
			
 
				+        pathRegExp(redirectPath, routeCopy)
			
 
				+      );
			
 
				+    }
			
 
				+
			
 
				+    return this;
			
 
				+  };
			
 
				+
			
 
				+  /**
			
 
				+   * @ngdoc property
			
 
				+   * @name $routeProvider#caseInsensitiveMatch
			
 
				+   * @description
			
 
				+   *
			
 
				+   * A boolean property indicating if routes defined
			
 
				+   * using this provider should be matched using a case insensitive
			
 
				+   * algorithm. Defaults to `false`.
			
 
				+   */
			
 
				+  this.caseInsensitiveMatch = false;
			
 
				+
			
 
				+   /**
			
 
				+    * @param path {string} path
			
 
				+    * @param opts {Object} options
			
 
				+    * @return {?Object}
			
 
				+    *
			
 
				+    * @description
			
 
				+    * Normalizes the given path, returning a regular expression
			
 
				+    * and the original path.
			
 
				+    *
			
 
				+    * Inspired by pathRexp in visionmedia/express/lib/utils.js.
			
 
				+    */
			
 
				+  function pathRegExp(path, opts) {
			
 
				+    var insensitive = opts.caseInsensitiveMatch,
			
 
				+        ret = {
			
 
				+          originalPath: path,
			
 
				+          regexp: path
			
 
				+        },
			
 
				+        keys = ret.keys = [];
			
 
				+
			
 
				+    path = path
			
 
				+      .replace(/([().])/g, '\\$1')
			
 
				+      .replace(/(\/)?:(\w+)([\?\*])?/g, function(_, slash, key, option) {
			
 
				+        var optional = option === '?' ? option : null;
			
 
				+        var star = option === '*' ? option : null;
			
 
				+        keys.push({ name: key, optional: !!optional });
			
 
				+        slash = slash || '';
			
 
				+        return ''
			
 
				+          + (optional ? '' : slash)
			
 
				+          + '(?:'
			
 
				+          + (optional ? slash : '')
			
 
				+          + (star && '(.+?)' || '([^/]+)')
			
 
				+          + (optional || '')
			
 
				+          + ')'
			
 
				+          + (optional || '');
			
 
				+      })
			
 
				+      .replace(/([\/$\*])/g, '\\$1');
			
 
				+
			
 
				+    ret.regexp = new RegExp('^' + path + '$', insensitive ? 'i' : '');
			
 
				+    return ret;
			
 
				+  }
			
 
				+
			
 
				+  /**
			
 
				+   * @ngdoc method
			
 
				+   * @name $routeProvider#otherwise
			
 
				+   *
			
 
				+   * @description
			
 
				+   * Sets route definition that will be used on route change when no other route definition
			
 
				+   * is matched.
			
 
				+   *
			
 
				+   * @param {Object|string} params Mapping information to be assigned to `$route.current`.
			
 
				+   * If called with a string, the value maps to `redirectTo`.
			
 
				+   * @returns {Object} self
			
 
				+   */
			
 
				+  this.otherwise = function(params) {
			
 
				+    if (typeof params === 'string') {
			
 
				+      params = {redirectTo: params};
			
 
				+    }
			
 
				+    this.when(null, params);
			
 
				+    return this;
			
 
				+  };
			
 
				+
			
 
				+
			
 
				+  this.$get = ['$rootScope',
			
 
				+               '$location',
			
 
				+               '$routeParams',
			
 
				+               '$q',
			
 
				+               '$injector',
			
 
				+               '$templateRequest',
			
 
				+               '$sce',
			
 
				+      function($rootScope, $location, $routeParams, $q, $injector, $templateRequest, $sce) {
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc service
			
 
				+     * @name $route
			
 
				+     * @requires $location
			
 
				+     * @requires $routeParams
			
 
				+     *
			
 
				+     * @property {Object} current Reference to the current route definition.
			
 
				+     * The route definition contains:
			
 
				+     *
			
 
				+     *   - `controller`: The controller constructor as define in route definition.
			
 
				+     *   - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for
			
 
				+     *     controller instantiation. The `locals` contain
			
 
				+     *     the resolved values of the `resolve` map. Additionally the `locals` also contain:
			
 
				+     *
			
 
				+     *     - `$scope` - The current route scope.
			
 
				+     *     - `$template` - The current route template HTML.
			
 
				+     *
			
 
				+     * @property {Object} routes Object with all route configuration Objects as its properties.
			
 
				+     *
			
 
				+     * @description
			
 
				+     * `$route` is used for deep-linking URLs to controllers and views (HTML partials).
			
 
				+     * It watches `$location.url()` and tries to map the path to an existing route definition.
			
 
				+     *
			
 
				+     * Requires the {@link ngRoute `ngRoute`} module to be installed.
			
 
				+     *
			
 
				+     * You can define routes through {@link ngRoute.$routeProvider $routeProvider}'s API.
			
 
				+     *
			
 
				+     * The `$route` service is typically used in conjunction with the
			
 
				+     * {@link ngRoute.directive:ngView `ngView`} directive and the
			
 
				+     * {@link ngRoute.$routeParams `$routeParams`} service.
			
 
				+     *
			
 
				+     * @example
			
 
				+     * This example shows how changing the URL hash causes the `$route` to match a route against the
			
 
				+     * URL, and the `ngView` pulls in the partial.
			
 
				+     *
			
 
				+     * <example name="$route-service" module="ngRouteExample"
			
 
				+     *          deps="angular-route.js" fixBase="true">
			
 
				+     *   <file name="index.html">
			
 
				+     *     <div ng-controller="MainController">
			
 
				+     *       Choose:
			
 
				+     *       <a href="Book/Moby">Moby</a> |
			
 
				+     *       <a href="Book/Moby/ch/1">Moby: Ch1</a> |
			
 
				+     *       <a href="Book/Gatsby">Gatsby</a> |
			
 
				+     *       <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
			
 
				+     *       <a href="Book/Scarlet">Scarlet Letter</a><br/>
			
 
				+     *
			
 
				+     *       <div ng-view></div>
			
 
				+     *
			
 
				+     *       <hr />
			
 
				+     *
			
 
				+     *       <pre>$location.path() = {{$location.path()}}</pre>
			
 
				+     *       <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre>
			
 
				+     *       <pre>$route.current.params = {{$route.current.params}}</pre>
			
 
				+     *       <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
			
 
				+     *       <pre>$routeParams = {{$routeParams}}</pre>
			
 
				+     *     </div>
			
 
				+     *   </file>
			
 
				+     *
			
 
				+     *   <file name="book.html">
			
 
				+     *     controller: {{name}}<br />
			
 
				+     *     Book Id: {{params.bookId}}<br />
			
 
				+     *   </file>
			
 
				+     *
			
 
				+     *   <file name="chapter.html">
			
 
				+     *     controller: {{name}}<br />
			
 
				+     *     Book Id: {{params.bookId}}<br />
			
 
				+     *     Chapter Id: {{params.chapterId}}
			
 
				+     *   </file>
			
 
				+     *
			
 
				+     *   <file name="script.js">
			
 
				+     *     angular.module('ngRouteExample', ['ngRoute'])
			
 
				+     *
			
 
				+     *      .controller('MainController', function($scope, $route, $routeParams, $location) {
			
 
				+     *          $scope.$route = $route;
			
 
				+     *          $scope.$location = $location;
			
 
				+     *          $scope.$routeParams = $routeParams;
			
 
				+     *      })
			
 
				+     *
			
 
				+     *      .controller('BookController', function($scope, $routeParams) {
			
 
				+     *          $scope.name = "BookController";
			
 
				+     *          $scope.params = $routeParams;
			
 
				+     *      })
			
 
				+     *
			
 
				+     *      .controller('ChapterController', function($scope, $routeParams) {
			
 
				+     *          $scope.name = "ChapterController";
			
 
				+     *          $scope.params = $routeParams;
			
 
				+     *      })
			
 
				+     *
			
 
				+     *     .config(function($routeProvider, $locationProvider) {
			
 
				+     *       $routeProvider
			
 
				+     *        .when('/Book/:bookId', {
			
 
				+     *         templateUrl: 'book.html',
			
 
				+     *         controller: 'BookController',
			
 
				+     *         resolve: {
			
 
				+     *           // I will cause a 1 second delay
			
 
				+     *           delay: function($q, $timeout) {
			
 
				+     *             var delay = $q.defer();
			
 
				+     *             $timeout(delay.resolve, 1000);
			
 
				+     *             return delay.promise;
			
 
				+     *           }
			
 
				+     *         }
			
 
				+     *       })
			
 
				+     *       .when('/Book/:bookId/ch/:chapterId', {
			
 
				+     *         templateUrl: 'chapter.html',
			
 
				+     *         controller: 'ChapterController'
			
 
				+     *       });
			
 
				+     *
			
 
				+     *       // configure html5 to get links working on jsfiddle
			
 
				+     *       $locationProvider.html5Mode(true);
			
 
				+     *     });
			
 
				+     *
			
 
				+     *   </file>
			
 
				+     *
			
 
				+     *   <file name="protractor.js" type="protractor">
			
 
				+     *     it('should load and compile correct template', function() {
			
 
				+     *       element(by.linkText('Moby: Ch1')).click();
			
 
				+     *       var content = element(by.css('[ng-view]')).getText();
			
 
				+     *       expect(content).toMatch(/controller\: ChapterController/);
			
 
				+     *       expect(content).toMatch(/Book Id\: Moby/);
			
 
				+     *       expect(content).toMatch(/Chapter Id\: 1/);
			
 
				+     *
			
 
				+     *       element(by.partialLinkText('Scarlet')).click();
			
 
				+     *
			
 
				+     *       content = element(by.css('[ng-view]')).getText();
			
 
				+     *       expect(content).toMatch(/controller\: BookController/);
			
 
				+     *       expect(content).toMatch(/Book Id\: Scarlet/);
			
 
				+     *     });
			
 
				+     *   </file>
			
 
				+     * </example>
			
 
				+     */
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc event
			
 
				+     * @name $route#$routeChangeStart
			
 
				+     * @eventType broadcast on root scope
			
 
				+     * @description
			
 
				+     * Broadcasted before a route change. At this  point the route services starts
			
 
				+     * resolving all of the dependencies needed for the route change to occur.
			
 
				+     * Typically this involves fetching the view template as well as any dependencies
			
 
				+     * defined in `resolve` route property. Once  all of the dependencies are resolved
			
 
				+     * `$routeChangeSuccess` is fired.
			
 
				+     *
			
 
				+     * The route change (and the `$location` change that triggered it) can be prevented
			
 
				+     * by calling `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on}
			
 
				+     * for more details about event object.
			
 
				+     *
			
 
				+     * @param {Object} angularEvent Synthetic event object.
			
 
				+     * @param {Route} next Future route information.
			
 
				+     * @param {Route} current Current route information.
			
 
				+     */
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc event
			
 
				+     * @name $route#$routeChangeSuccess
			
 
				+     * @eventType broadcast on root scope
			
 
				+     * @description
			
 
				+     * Broadcasted after a route dependencies are resolved.
			
 
				+     * {@link ngRoute.directive:ngView ngView} listens for the directive
			
 
				+     * to instantiate the controller and render the view.
			
 
				+     *
			
 
				+     * @param {Object} angularEvent Synthetic event object.
			
 
				+     * @param {Route} current Current route information.
			
 
				+     * @param {Route|Undefined} previous Previous route information, or undefined if current is
			
 
				+     * first route entered.
			
 
				+     */
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc event
			
 
				+     * @name $route#$routeChangeError
			
 
				+     * @eventType broadcast on root scope
			
 
				+     * @description
			
 
				+     * Broadcasted if any of the resolve promises are rejected.
			
 
				+     *
			
 
				+     * @param {Object} angularEvent Synthetic event object
			
 
				+     * @param {Route} current Current route information.
			
 
				+     * @param {Route} previous Previous route information.
			
 
				+     * @param {Route} rejection Rejection of the promise. Usually the error of the failed promise.
			
 
				+     */
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc event
			
 
				+     * @name $route#$routeUpdate
			
 
				+     * @eventType broadcast on root scope
			
 
				+     * @description
			
 
				+     *
			
 
				+     * The `reloadOnSearch` property has been set to false, and we are reusing the same
			
 
				+     * instance of the Controller.
			
 
				+     */
			
 
				+
			
 
				+    var forceReload = false,
			
 
				+        preparedRoute,
			
 
				+        preparedRouteIsUpdateOnly,
			
 
				+        $route = {
			
 
				+          routes: routes,
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name $route#reload
			
 
				+           *
			
 
				+           * @description
			
 
				+           * Causes `$route` service to reload the current route even if
			
 
				+           * {@link ng.$location $location} hasn't changed.
			
 
				+           *
			
 
				+           * As a result of that, {@link ngRoute.directive:ngView ngView}
			
 
				+           * creates new scope and reinstantiates the controller.
			
 
				+           */
			
 
				+          reload: function() {
			
 
				+            forceReload = true;
			
 
				+            $rootScope.$evalAsync(function() {
			
 
				+              // Don't support cancellation of a reload for now...
			
 
				+              prepareRoute();
			
 
				+              commitRoute();
			
 
				+            });
			
 
				+          },
			
 
				+
			
 
				+          /**
			
 
				+           * @ngdoc method
			
 
				+           * @name $route#updateParams
			
 
				+           *
			
 
				+           * @description
			
 
				+           * Causes `$route` service to update the current URL, replacing
			
 
				+           * current route parameters with those specified in `newParams`.
			
 
				+           * Provided property names that match the route's path segment
			
 
				+           * definitions will be interpolated into the location's path, while
			
 
				+           * remaining properties will be treated as query params.
			
 
				+           *
			
 
				+           * @param {Object} newParams mapping of URL parameter names to values
			
 
				+           */
			
 
				+          updateParams: function(newParams) {
			
 
				+            if (this.current && this.current.$$route) {
			
 
				+              var searchParams = {}, self=this;
			
 
				+
			
 
				+              angular.forEach(Object.keys(newParams), function(key) {
			
 
				+                if (!self.current.pathParams[key]) searchParams[key] = newParams[key];
			
 
				+              });
			
 
				+
			
 
				+              newParams = angular.extend({}, this.current.params, newParams);
			
 
				+              $location.path(interpolate(this.current.$$route.originalPath, newParams));
			
 
				+              $location.search(angular.extend({}, $location.search(), searchParams));
			
 
				+            }
			
 
				+            else {
			
 
				+              throw $routeMinErr('norout', 'Tried updating route when with no current route');
			
 
				+            }
			
 
				+          }
			
 
				+        };
			
 
				+
			
 
				+    $rootScope.$on('$locationChangeStart', prepareRoute);
			
 
				+    $rootScope.$on('$locationChangeSuccess', commitRoute);
			
 
				+
			
 
				+    return $route;
			
 
				+
			
 
				+    /////////////////////////////////////////////////////
			
 
				+
			
 
				+    /**
			
 
				+     * @param on {string} current url
			
 
				+     * @param route {Object} route regexp to match the url against
			
 
				+     * @return {?Object}
			
 
				+     *
			
 
				+     * @description
			
 
				+     * Check if the route matches the current url.
			
 
				+     *
			
 
				+     * Inspired by match in
			
 
				+     * visionmedia/express/lib/router/router.js.
			
 
				+     */
			
 
				+    function switchRouteMatcher(on, route) {
			
 
				+      var keys = route.keys,
			
 
				+          params = {};
			
 
				+
			
 
				+      if (!route.regexp) return null;
			
 
				+
			
 
				+      var m = route.regexp.exec(on);
			
 
				+      if (!m) return null;
			
 
				+
			
 
				+      for (var i = 1, len = m.length; i < len; ++i) {
			
 
				+        var key = keys[i - 1];
			
 
				+
			
 
				+        var val = m[i];
			
 
				+
			
 
				+        if (key && val) {
			
 
				+          params[key.name] = val;
			
 
				+        }
			
 
				+      }
			
 
				+      return params;
			
 
				+    }
			
 
				+
			
 
				+    function prepareRoute($locationEvent) {
			
 
				+      var lastRoute = $route.current;
			
 
				+
			
 
				+      preparedRoute = parseRoute();
			
 
				+      preparedRouteIsUpdateOnly = preparedRoute && lastRoute && preparedRoute.$$route === lastRoute.$$route
			
 
				+          && angular.equals(preparedRoute.pathParams, lastRoute.pathParams)
			
 
				+          && !preparedRoute.reloadOnSearch && !forceReload;
			
 
				+
			
 
				+      if (!preparedRouteIsUpdateOnly && (lastRoute || preparedRoute)) {
			
 
				+        if ($rootScope.$broadcast('$routeChangeStart', preparedRoute, lastRoute).defaultPrevented) {
			
 
				+          if ($locationEvent) {
			
 
				+            $locationEvent.preventDefault();
			
 
				+          }
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    function commitRoute() {
			
 
				+      var lastRoute = $route.current;
			
 
				+      var nextRoute = preparedRoute;
			
 
				+
			
 
				+      if (preparedRouteIsUpdateOnly) {
			
 
				+        lastRoute.params = nextRoute.params;
			
 
				+        angular.copy(lastRoute.params, $routeParams);
			
 
				+        $rootScope.$broadcast('$routeUpdate', lastRoute);
			
 
				+      } else if (nextRoute || lastRoute) {
			
 
				+        forceReload = false;
			
 
				+        $route.current = nextRoute;
			
 
				+        if (nextRoute) {
			
 
				+          if (nextRoute.redirectTo) {
			
 
				+            if (angular.isString(nextRoute.redirectTo)) {
			
 
				+              $location.path(interpolate(nextRoute.redirectTo, nextRoute.params)).search(nextRoute.params)
			
 
				+                       .replace();
			
 
				+            } else {
			
 
				+              $location.url(nextRoute.redirectTo(nextRoute.pathParams, $location.path(), $location.search()))
			
 
				+                       .replace();
			
 
				+            }
			
 
				+          }
			
 
				+        }
			
 
				+
			
 
				+        $q.when(nextRoute).
			
 
				+          then(function() {
			
 
				+            if (nextRoute) {
			
 
				+              var locals = angular.extend({}, nextRoute.resolve),
			
 
				+                  template, templateUrl;
			
 
				+
			
 
				+              angular.forEach(locals, function(value, key) {
			
 
				+                locals[key] = angular.isString(value) ?
			
 
				+                    $injector.get(value) : $injector.invoke(value, null, null, key);
			
 
				+              });
			
 
				+
			
 
				+              if (angular.isDefined(template = nextRoute.template)) {
			
 
				+                if (angular.isFunction(template)) {
			
 
				+                  template = template(nextRoute.params);
			
 
				+                }
			
 
				+              } else if (angular.isDefined(templateUrl = nextRoute.templateUrl)) {
			
 
				+                if (angular.isFunction(templateUrl)) {
			
 
				+                  templateUrl = templateUrl(nextRoute.params);
			
 
				+                }
			
 
				+                templateUrl = $sce.getTrustedResourceUrl(templateUrl);
			
 
				+                if (angular.isDefined(templateUrl)) {
			
 
				+                  nextRoute.loadedTemplateUrl = templateUrl;
			
 
				+                  template = $templateRequest(templateUrl);
			
 
				+                }
			
 
				+              }
			
 
				+              if (angular.isDefined(template)) {
			
 
				+                locals['$template'] = template;
			
 
				+              }
			
 
				+              return $q.all(locals);
			
 
				+            }
			
 
				+          }).
			
 
				+          // after route change
			
 
				+          then(function(locals) {
			
 
				+            if (nextRoute == $route.current) {
			
 
				+              if (nextRoute) {
			
 
				+                nextRoute.locals = locals;
			
 
				+                angular.copy(nextRoute.params, $routeParams);
			
 
				+              }
			
 
				+              $rootScope.$broadcast('$routeChangeSuccess', nextRoute, lastRoute);
			
 
				+            }
			
 
				+          }, function(error) {
			
 
				+            if (nextRoute == $route.current) {
			
 
				+              $rootScope.$broadcast('$routeChangeError', nextRoute, lastRoute, error);
			
 
				+            }
			
 
				+          });
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+
			
 
				+    /**
			
 
				+     * @returns {Object} the current active route, by matching it against the URL
			
 
				+     */
			
 
				+    function parseRoute() {
			
 
				+      // Match a route
			
 
				+      var params, match;
			
 
				+      angular.forEach(routes, function(route, path) {
			
 
				+        if (!match && (params = switchRouteMatcher($location.path(), route))) {
			
 
				+          match = inherit(route, {
			
 
				+            params: angular.extend({}, $location.search(), params),
			
 
				+            pathParams: params});
			
 
				+          match.$$route = route;
			
 
				+        }
			
 
				+      });
			
 
				+      // No route matched; fallback to "otherwise" route
			
 
				+      return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}});
			
 
				+    }
			
 
				+
			
 
				+    /**
			
 
				+     * @returns {string} interpolation of the redirect path with the parameters
			
 
				+     */
			
 
				+    function interpolate(string, params) {
			
 
				+      var result = [];
			
 
				+      angular.forEach((string || '').split(':'), function(segment, i) {
			
 
				+        if (i === 0) {
			
 
				+          result.push(segment);
			
 
				+        } else {
			
 
				+          var segmentMatch = segment.match(/(\w+)(?:[?*])?(.*)/);
			
 
				+          var key = segmentMatch[1];
			
 
				+          result.push(params[key]);
			
 
				+          result.push(segmentMatch[2] || '');
			
 
				+          delete params[key];
			
 
				+        }
			
 
				+      });
			
 
				+      return result.join('');
			
 
				+    }
			
 
				+  }];
			
 
				+}
			
 
				+
			
 
				+ngRouteModule.provider('$routeParams', $RouteParamsProvider);
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc service
			
 
				+ * @name $routeParams
			
 
				+ * @requires $route
			
 
				+ *
			
 
				+ * @description
			
 
				+ * The `$routeParams` service allows you to retrieve the current set of route parameters.
			
 
				+ *
			
 
				+ * Requires the {@link ngRoute `ngRoute`} module to be installed.
			
 
				+ *
			
 
				+ * The route parameters are a combination of {@link ng.$location `$location`}'s
			
 
				+ * {@link ng.$location#search `search()`} and {@link ng.$location#path `path()`}.
			
 
				+ * The `path` parameters are extracted when the {@link ngRoute.$route `$route`} path is matched.
			
 
				+ *
			
 
				+ * In case of parameter name collision, `path` params take precedence over `search` params.
			
 
				+ *
			
 
				+ * The service guarantees that the identity of the `$routeParams` object will remain unchanged
			
 
				+ * (but its properties will likely change) even when a route change occurs.
			
 
				+ *
			
 
				+ * Note that the `$routeParams` are only updated *after* a route change completes successfully.
			
 
				+ * This means that you cannot rely on `$routeParams` being correct in route resolve functions.
			
 
				+ * Instead you can use `$route.current.params` to access the new route's parameters.
			
 
				+ *
			
 
				+ * @example
			
 
				+ * ```js
			
 
				+ *  // Given:
			
 
				+ *  // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby
			
 
				+ *  // Route: /Chapter/:chapterId/Section/:sectionId
			
 
				+ *  //
			
 
				+ *  // Then
			
 
				+ *  $routeParams ==> {chapterId:'1', sectionId:'2', search:'moby'}
			
 
				+ * ```
			
 
				+ */
			
 
				+function $RouteParamsProvider() {
			
 
				+  this.$get = function() { return {}; };
			
 
				+}
			
 
				+
			
 
				+ngRouteModule.directive('ngView', ngViewFactory);
			
 
				+ngRouteModule.directive('ngView', ngViewFillContentFactory);
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc directive
			
 
				+ * @name ngView
			
 
				+ * @restrict ECA
			
 
				+ *
			
 
				+ * @description
			
 
				+ * # Overview
			
 
				+ * `ngView` is a directive that complements the {@link ngRoute.$route $route} service by
			
 
				+ * including the rendered template of the current route into the main layout (`index.html`) file.
			
 
				+ * Every time the current route changes, the included view changes with it according to the
			
 
				+ * configuration of the `$route` service.
			
 
				+ *
			
 
				+ * Requires the {@link ngRoute `ngRoute`} module to be installed.
			
 
				+ *
			
 
				+ * @animations
			
 
				+ * enter - animation is used to bring new content into the browser.
			
 
				+ * leave - animation is used to animate existing content away.
			
 
				+ *
			
 
				+ * The enter and leave animation occur concurrently.
			
 
				+ *
			
 
				+ * @scope
			
 
				+ * @priority 400
			
 
				+ * @param {string=} onload Expression to evaluate whenever the view updates.
			
 
				+ *
			
 
				+ * @param {string=} autoscroll Whether `ngView` should call {@link ng.$anchorScroll
			
 
				+ *                  $anchorScroll} to scroll the viewport after the view is updated.
			
 
				+ *
			
 
				+ *                  - If the attribute is not set, disable scrolling.
			
 
				+ *                  - If the attribute is set without value, enable scrolling.
			
 
				+ *                  - Otherwise enable scrolling only if the `autoscroll` attribute value evaluated
			
 
				+ *                    as an expression yields a truthy value.
			
 
				+ * @example
			
 
				+    <example name="ngView-directive" module="ngViewExample"
			
 
				+             deps="angular-route.js;angular-animate.js"
			
 
				+             animations="true" fixBase="true">
			
 
				+      <file name="index.html">
			
 
				+        <div ng-controller="MainCtrl as main">
			
 
				+          Choose:
			
 
				+          <a href="Book/Moby">Moby</a> |
			
 
				+          <a href="Book/Moby/ch/1">Moby: Ch1</a> |
			
 
				+          <a href="Book/Gatsby">Gatsby</a> |
			
 
				+          <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
			
 
				+          <a href="Book/Scarlet">Scarlet Letter</a><br/>
			
 
				+
			
 
				+          <div class="view-animate-container">
			
 
				+            <div ng-view class="view-animate"></div>
			
 
				+          </div>
			
 
				+          <hr />
			
 
				+
			
 
				+          <pre>$location.path() = {{main.$location.path()}}</pre>
			
 
				+          <pre>$route.current.templateUrl = {{main.$route.current.templateUrl}}</pre>
			
 
				+          <pre>$route.current.params = {{main.$route.current.params}}</pre>
			
 
				+          <pre>$routeParams = {{main.$routeParams}}</pre>
			
 
				+        </div>
			
 
				+      </file>
			
 
				+
			
 
				+      <file name="book.html">
			
 
				+        <div>
			
 
				+          controller: {{book.name}}<br />
			
 
				+          Book Id: {{book.params.bookId}}<br />
			
 
				+        </div>
			
 
				+      </file>
			
 
				+
			
 
				+      <file name="chapter.html">
			
 
				+        <div>
			
 
				+          controller: {{chapter.name}}<br />
			
 
				+          Book Id: {{chapter.params.bookId}}<br />
			
 
				+          Chapter Id: {{chapter.params.chapterId}}
			
 
				+        </div>
			
 
				+      </file>
			
 
				+
			
 
				+      <file name="animations.css">
			
 
				+        .view-animate-container {
			
 
				+          position:relative;
			
 
				+          height:100px!important;
			
 
				+          position:relative;
			
 
				+          background:white;
			
 
				+          border:1px solid black;
			
 
				+          height:40px;
			
 
				+          overflow:hidden;
			
 
				+        }
			
 
				+
			
 
				+        .view-animate {
			
 
				+          padding:10px;
			
 
				+        }
			
 
				+
			
 
				+        .view-animate.ng-enter, .view-animate.ng-leave {
			
 
				+          -webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
			
 
				+          transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
			
 
				+
			
 
				+          display:block;
			
 
				+          width:100%;
			
 
				+          border-left:1px solid black;
			
 
				+
			
 
				+          position:absolute;
			
 
				+          top:0;
			
 
				+          left:0;
			
 
				+          right:0;
			
 
				+          bottom:0;
			
 
				+          padding:10px;
			
 
				+        }
			
 
				+
			
 
				+        .view-animate.ng-enter {
			
 
				+          left:100%;
			
 
				+        }
			
 
				+        .view-animate.ng-enter.ng-enter-active {
			
 
				+          left:0;
			
 
				+        }
			
 
				+        .view-animate.ng-leave.ng-leave-active {
			
 
				+          left:-100%;
			
 
				+        }
			
 
				+      </file>
			
 
				+
			
 
				+      <file name="script.js">
			
 
				+        angular.module('ngViewExample', ['ngRoute', 'ngAnimate'])
			
 
				+          .config(['$routeProvider', '$locationProvider',
			
 
				+            function($routeProvider, $locationProvider) {
			
 
				+              $routeProvider
			
 
				+                .when('/Book/:bookId', {
			
 
				+                  templateUrl: 'book.html',
			
 
				+                  controller: 'BookCtrl',
			
 
				+                  controllerAs: 'book'
			
 
				+                })
			
 
				+                .when('/Book/:bookId/ch/:chapterId', {
			
 
				+                  templateUrl: 'chapter.html',
			
 
				+                  controller: 'ChapterCtrl',
			
 
				+                  controllerAs: 'chapter'
			
 
				+                });
			
 
				+
			
 
				+              $locationProvider.html5Mode(true);
			
 
				+          }])
			
 
				+          .controller('MainCtrl', ['$route', '$routeParams', '$location',
			
 
				+            function($route, $routeParams, $location) {
			
 
				+              this.$route = $route;
			
 
				+              this.$location = $location;
			
 
				+              this.$routeParams = $routeParams;
			
 
				+          }])
			
 
				+          .controller('BookCtrl', ['$routeParams', function($routeParams) {
			
 
				+            this.name = "BookCtrl";
			
 
				+            this.params = $routeParams;
			
 
				+          }])
			
 
				+          .controller('ChapterCtrl', ['$routeParams', function($routeParams) {
			
 
				+            this.name = "ChapterCtrl";
			
 
				+            this.params = $routeParams;
			
 
				+          }]);
			
 
				+
			
 
				+      </file>
			
 
				+
			
 
				+      <file name="protractor.js" type="protractor">
			
 
				+        it('should load and compile correct template', function() {
			
 
				+          element(by.linkText('Moby: Ch1')).click();
			
 
				+          var content = element(by.css('[ng-view]')).getText();
			
 
				+          expect(content).toMatch(/controller\: ChapterCtrl/);
			
 
				+          expect(content).toMatch(/Book Id\: Moby/);
			
 
				+          expect(content).toMatch(/Chapter Id\: 1/);
			
 
				+
			
 
				+          element(by.partialLinkText('Scarlet')).click();
			
 
				+
			
 
				+          content = element(by.css('[ng-view]')).getText();
			
 
				+          expect(content).toMatch(/controller\: BookCtrl/);
			
 
				+          expect(content).toMatch(/Book Id\: Scarlet/);
			
 
				+        });
			
 
				+      </file>
			
 
				+    </example>
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc event
			
 
				+ * @name ngView#$viewContentLoaded
			
 
				+ * @eventType emit on the current ngView scope
			
 
				+ * @description
			
 
				+ * Emitted every time the ngView content is reloaded.
			
 
				+ */
			
 
				+ngViewFactory.$inject = ['$route', '$anchorScroll', '$animate'];
			
 
				+function ngViewFactory($route, $anchorScroll, $animate) {
			
 
				+  return {
			
 
				+    restrict: 'ECA',
			
 
				+    terminal: true,
			
 
				+    priority: 400,
			
 
				+    transclude: 'element',
			
 
				+    link: function(scope, $element, attr, ctrl, $transclude) {
			
 
				+        var currentScope,
			
 
				+            currentElement,
			
 
				+            previousLeaveAnimation,
			
 
				+            autoScrollExp = attr.autoscroll,
			
 
				+            onloadExp = attr.onload || '';
			
 
				+
			
 
				+        scope.$on('$routeChangeSuccess', update);
			
 
				+        update();
			
 
				+
			
 
				+        function cleanupLastView() {
			
 
				+          if (previousLeaveAnimation) {
			
 
				+            $animate.cancel(previousLeaveAnimation);
			
 
				+            previousLeaveAnimation = null;
			
 
				+          }
			
 
				+
			
 
				+          if (currentScope) {
			
 
				+            currentScope.$destroy();
			
 
				+            currentScope = null;
			
 
				+          }
			
 
				+          if (currentElement) {
			
 
				+            previousLeaveAnimation = $animate.leave(currentElement);
			
 
				+            previousLeaveAnimation.then(function() {
			
 
				+              previousLeaveAnimation = null;
			
 
				+            });
			
 
				+            currentElement = null;
			
 
				+          }
			
 
				+        }
			
 
				+
			
 
				+        function update() {
			
 
				+          var locals = $route.current && $route.current.locals,
			
 
				+              template = locals && locals.$template;
			
 
				+
			
 
				+          if (angular.isDefined(template)) {
			
 
				+            var newScope = scope.$new();
			
 
				+            var current = $route.current;
			
 
				+
			
 
				+            // Note: This will also link all children of ng-view that were contained in the original
			
 
				+            // html. If that content contains controllers, ... they could pollute/change the scope.
			
 
				+            // However, using ng-view on an element with additional content does not make sense...
			
 
				+            // Note: We can't remove them in the cloneAttchFn of $transclude as that
			
 
				+            // function is called before linking the content, which would apply child
			
 
				+            // directives to non existing elements.
			
 
				+            var clone = $transclude(newScope, function(clone) {
			
 
				+              $animate.enter(clone, null, currentElement || $element).then(function onNgViewEnter() {
			
 
				+                if (angular.isDefined(autoScrollExp)
			
 
				+                  && (!autoScrollExp || scope.$eval(autoScrollExp))) {
			
 
				+                  $anchorScroll();
			
 
				+                }
			
 
				+              });
			
 
				+              cleanupLastView();
			
 
				+            });
			
 
				+
			
 
				+            currentElement = clone;
			
 
				+            currentScope = current.scope = newScope;
			
 
				+            currentScope.$emit('$viewContentLoaded');
			
 
				+            currentScope.$eval(onloadExp);
			
 
				+          } else {
			
 
				+            cleanupLastView();
			
 
				+          }
			
 
				+        }
			
 
				+    }
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+// This directive is called during the $transclude call of the first `ngView` directive.
			
 
				+// It will replace and compile the content of the element with the loaded template.
			
 
				+// We need this directive so that the element content is already filled when
			
 
				+// the link function of another directive on the same element as ngView
			
 
				+// is called.
			
 
				+ngViewFillContentFactory.$inject = ['$compile', '$controller', '$route'];
			
 
				+function ngViewFillContentFactory($compile, $controller, $route) {
			
 
				+  return {
			
 
				+    restrict: 'ECA',
			
 
				+    priority: -400,
			
 
				+    link: function(scope, $element) {
			
 
				+      var current = $route.current,
			
 
				+          locals = current.locals;
			
 
				+
			
 
				+      $element.html(locals.$template);
			
 
				+
			
 
				+      var link = $compile($element.contents());
			
 
				+
			
 
				+      if (current.controller) {
			
 
				+        locals.$scope = scope;
			
 
				+        var controller = $controller(current.controller, locals);
			
 
				+        if (current.controllerAs) {
			
 
				+          scope[current.controllerAs] = controller;
			
 
				+        }
			
 
				+        $element.data('$ngControllerController', controller);
			
 
				+        $element.children().data('$ngControllerController', controller);
			
 
				+      }
			
 
				+
			
 
				+      link(scope);
			
 
				+    }
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-route.min.js
+++ b/src/js/angularjs/angular-route.min.js
--- a/src/js/angularjs/angular-route.min.js.map
+++ b/src/js/angularjs/angular-route.min.js.map
--- a/src/js/angularjs/angular-sanitize.js
+++ b/src/js/angularjs/angular-sanitize.js
@@ -0,0 +1,678 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+var $sanitizeMinErr = angular.$$minErr('$sanitize');
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngSanitize
			
 
				+ * @description
			
 
				+ *
			
 
				+ * # ngSanitize
			
 
				+ *
			
 
				+ * The `ngSanitize` module provides functionality to sanitize HTML.
			
 
				+ *
			
 
				+ *
			
 
				+ * <div doc-module-components="ngSanitize"></div>
			
 
				+ *
			
 
				+ * See {@link ngSanitize.$sanitize `$sanitize`} for usage.
			
 
				+ */
			
 
				+
			
 
				+/*
			
 
				+ * HTML Parser By Misko Hevery (misko@hevery.com)
			
 
				+ * based on:  HTML Parser By John Resig (ejohn.org)
			
 
				+ * Original code by Erik Arvidsson, Mozilla Public License
			
 
				+ * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
			
 
				+ *
			
 
				+ * // Use like so:
			
 
				+ * htmlParser(htmlString, {
			
 
				+ *     start: function(tag, attrs, unary) {},
			
 
				+ *     end: function(tag) {},
			
 
				+ *     chars: function(text) {},
			
 
				+ *     comment: function(text) {}
			
 
				+ * });
			
 
				+ *
			
 
				+ */
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc service
			
 
				+ * @name $sanitize
			
 
				+ * @kind function
			
 
				+ *
			
 
				+ * @description
			
 
				+ *   The input is sanitized by parsing the HTML into tokens. All safe tokens (from a whitelist) are
			
 
				+ *   then serialized back to properly escaped html string. This means that no unsafe input can make
			
 
				+ *   it into the returned string, however, since our parser is more strict than a typical browser
			
 
				+ *   parser, it's possible that some obscure input, which would be recognized as valid HTML by a
			
 
				+ *   browser, won't make it through the sanitizer. The input may also contain SVG markup.
			
 
				+ *   The whitelist is configured using the functions `aHrefSanitizationWhitelist` and
			
 
				+ *   `imgSrcSanitizationWhitelist` of {@link ng.$compileProvider `$compileProvider`}.
			
 
				+ *
			
 
				+ * @param {string} html HTML input.
			
 
				+ * @returns {string} Sanitized HTML.
			
 
				+ *
			
 
				+ * @example
			
 
				+   <example module="sanitizeExample" deps="angular-sanitize.js">
			
 
				+   <file name="index.html">
			
 
				+     <script>
			
 
				+         angular.module('sanitizeExample', ['ngSanitize'])
			
 
				+           .controller('ExampleController', ['$scope', '$sce', function($scope, $sce) {
			
 
				+             $scope.snippet =
			
 
				+               '<p style="color:blue">an html\n' +
			
 
				+               '<em onmouseover="this.textContent=\'PWN3D!\'">click here</em>\n' +
			
 
				+               'snippet</p>';
			
 
				+             $scope.deliberatelyTrustDangerousSnippet = function() {
			
 
				+               return $sce.trustAsHtml($scope.snippet);
			
 
				+             };
			
 
				+           }]);
			
 
				+     </script>
			
 
				+     <div ng-controller="ExampleController">
			
 
				+        Snippet: <textarea ng-model="snippet" cols="60" rows="3"></textarea>
			
 
				+       <table>
			
 
				+         <tr>
			
 
				+           <td>Directive</td>
			
 
				+           <td>How</td>
			
 
				+           <td>Source</td>
			
 
				+           <td>Rendered</td>
			
 
				+         </tr>
			
 
				+         <tr id="bind-html-with-sanitize">
			
 
				+           <td>ng-bind-html</td>
			
 
				+           <td>Automatically uses $sanitize</td>
			
 
				+           <td><pre>&lt;div ng-bind-html="snippet"&gt;<br/>&lt;/div&gt;</pre></td>
			
 
				+           <td><div ng-bind-html="snippet"></div></td>
			
 
				+         </tr>
			
 
				+         <tr id="bind-html-with-trust">
			
 
				+           <td>ng-bind-html</td>
			
 
				+           <td>Bypass $sanitize by explicitly trusting the dangerous value</td>
			
 
				+           <td>
			
 
				+           <pre>&lt;div ng-bind-html="deliberatelyTrustDangerousSnippet()"&gt;
			
 
				+&lt;/div&gt;</pre>
			
 
				+           </td>
			
 
				+           <td><div ng-bind-html="deliberatelyTrustDangerousSnippet()"></div></td>
			
 
				+         </tr>
			
 
				+         <tr id="bind-default">
			
 
				+           <td>ng-bind</td>
			
 
				+           <td>Automatically escapes</td>
			
 
				+           <td><pre>&lt;div ng-bind="snippet"&gt;<br/>&lt;/div&gt;</pre></td>
			
 
				+           <td><div ng-bind="snippet"></div></td>
			
 
				+         </tr>
			
 
				+       </table>
			
 
				+       </div>
			
 
				+   </file>
			
 
				+   <file name="protractor.js" type="protractor">
			
 
				+     it('should sanitize the html snippet by default', function() {
			
 
				+       expect(element(by.css('#bind-html-with-sanitize div')).getInnerHtml()).
			
 
				+         toBe('<p>an html\n<em>click here</em>\nsnippet</p>');
			
 
				+     });
			
 
				+
			
 
				+     it('should inline raw snippet if bound to a trusted value', function() {
			
 
				+       expect(element(by.css('#bind-html-with-trust div')).getInnerHtml()).
			
 
				+         toBe("<p style=\"color:blue\">an html\n" +
			
 
				+              "<em onmouseover=\"this.textContent='PWN3D!'\">click here</em>\n" +
			
 
				+              "snippet</p>");
			
 
				+     });
			
 
				+
			
 
				+     it('should escape snippet without any filter', function() {
			
 
				+       expect(element(by.css('#bind-default div')).getInnerHtml()).
			
 
				+         toBe("&lt;p style=\"color:blue\"&gt;an html\n" +
			
 
				+              "&lt;em onmouseover=\"this.textContent='PWN3D!'\"&gt;click here&lt;/em&gt;\n" +
			
 
				+              "snippet&lt;/p&gt;");
			
 
				+     });
			
 
				+
			
 
				+     it('should update', function() {
			
 
				+       element(by.model('snippet')).clear();
			
 
				+       element(by.model('snippet')).sendKeys('new <b onclick="alert(1)">text</b>');
			
 
				+       expect(element(by.css('#bind-html-with-sanitize div')).getInnerHtml()).
			
 
				+         toBe('new <b>text</b>');
			
 
				+       expect(element(by.css('#bind-html-with-trust div')).getInnerHtml()).toBe(
			
 
				+         'new <b onclick="alert(1)">text</b>');
			
 
				+       expect(element(by.css('#bind-default div')).getInnerHtml()).toBe(
			
 
				+         "new &lt;b onclick=\"alert(1)\"&gt;text&lt;/b&gt;");
			
 
				+     });
			
 
				+   </file>
			
 
				+   </example>
			
 
				+ */
			
 
				+function $SanitizeProvider() {
			
 
				+  this.$get = ['$$sanitizeUri', function($$sanitizeUri) {
			
 
				+    return function(html) {
			
 
				+      var buf = [];
			
 
				+      htmlParser(html, htmlSanitizeWriter(buf, function(uri, isImage) {
			
 
				+        return !/^unsafe/.test($$sanitizeUri(uri, isImage));
			
 
				+      }));
			
 
				+      return buf.join('');
			
 
				+    };
			
 
				+  }];
			
 
				+}
			
 
				+
			
 
				+function sanitizeText(chars) {
			
 
				+  var buf = [];
			
 
				+  var writer = htmlSanitizeWriter(buf, angular.noop);
			
 
				+  writer.chars(chars);
			
 
				+  return buf.join('');
			
 
				+}
			
 
				+
			
 
				+
			
 
				+// Regular Expressions for parsing tags and attributes
			
 
				+var START_TAG_REGEXP =
			
 
				+       /^<((?:[a-zA-Z])[\w:-]*)((?:\s+[\w:-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)\s*(>?)/,
			
 
				+  END_TAG_REGEXP = /^<\/\s*([\w:-]+)[^>]*>/,
			
 
				+  ATTR_REGEXP = /([\w:-]+)(?:\s*=\s*(?:(?:"((?:[^"])*)")|(?:'((?:[^'])*)')|([^>\s]+)))?/g,
			
 
				+  BEGIN_TAG_REGEXP = /^</,
			
 
				+  BEGING_END_TAGE_REGEXP = /^<\//,
			
 
				+  COMMENT_REGEXP = /<!--(.*?)-->/g,
			
 
				+  DOCTYPE_REGEXP = /<!DOCTYPE([^>]*?)>/i,
			
 
				+  CDATA_REGEXP = /<!\[CDATA\[(.*?)]]>/g,
			
 
				+  SURROGATE_PAIR_REGEXP = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g,
			
 
				+  // Match everything outside of normal chars and " (quote character)
			
 
				+  NON_ALPHANUMERIC_REGEXP = /([^\#-~| |!])/g;
			
 
				+
			
 
				+
			
 
				+// Good source of info about elements and attributes
			
 
				+// http://dev.w3.org/html5/spec/Overview.html#semantics
			
 
				+// http://simon.html5.org/html-elements
			
 
				+
			
 
				+// Safe Void Elements - HTML5
			
 
				+// http://dev.w3.org/html5/spec/Overview.html#void-elements
			
 
				+var voidElements = makeMap("area,br,col,hr,img,wbr");
			
 
				+
			
 
				+// Elements that you can, intentionally, leave open (and which close themselves)
			
 
				+// http://dev.w3.org/html5/spec/Overview.html#optional-tags
			
 
				+var optionalEndTagBlockElements = makeMap("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),
			
 
				+    optionalEndTagInlineElements = makeMap("rp,rt"),
			
 
				+    optionalEndTagElements = angular.extend({},
			
 
				+                                            optionalEndTagInlineElements,
			
 
				+                                            optionalEndTagBlockElements);
			
 
				+
			
 
				+// Safe Block Elements - HTML5
			
 
				+var blockElements = angular.extend({}, optionalEndTagBlockElements, makeMap("address,article," +
			
 
				+        "aside,blockquote,caption,center,del,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5," +
			
 
				+        "h6,header,hgroup,hr,ins,map,menu,nav,ol,pre,script,section,table,ul"));
			
 
				+
			
 
				+// Inline Elements - HTML5
			
 
				+var inlineElements = angular.extend({}, optionalEndTagInlineElements, makeMap("a,abbr,acronym,b," +
			
 
				+        "bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,q,ruby,rp,rt,s," +
			
 
				+        "samp,small,span,strike,strong,sub,sup,time,tt,u,var"));
			
 
				+
			
 
				+// SVG Elements
			
 
				+// https://wiki.whatwg.org/wiki/Sanitization_rules#svg_Elements
			
 
				+var svgElements = makeMap("animate,animateColor,animateMotion,animateTransform,circle,defs," +
			
 
				+        "desc,ellipse,font-face,font-face-name,font-face-src,g,glyph,hkern,image,linearGradient," +
			
 
				+        "line,marker,metadata,missing-glyph,mpath,path,polygon,polyline,radialGradient,rect,set," +
			
 
				+        "stop,svg,switch,text,title,tspan,use");
			
 
				+
			
 
				+// Special Elements (can contain anything)
			
 
				+var specialElements = makeMap("script,style");
			
 
				+
			
 
				+var validElements = angular.extend({},
			
 
				+                                   voidElements,
			
 
				+                                   blockElements,
			
 
				+                                   inlineElements,
			
 
				+                                   optionalEndTagElements,
			
 
				+                                   svgElements);
			
 
				+
			
 
				+//Attributes that have href and hence need to be sanitized
			
 
				+var uriAttrs = makeMap("background,cite,href,longdesc,src,usemap,xlink:href");
			
 
				+
			
 
				+var htmlAttrs = makeMap('abbr,align,alt,axis,bgcolor,border,cellpadding,cellspacing,class,clear,' +
			
 
				+    'color,cols,colspan,compact,coords,dir,face,headers,height,hreflang,hspace,' +
			
 
				+    'ismap,lang,language,nohref,nowrap,rel,rev,rows,rowspan,rules,' +
			
 
				+    'scope,scrolling,shape,size,span,start,summary,target,title,type,' +
			
 
				+    'valign,value,vspace,width');
			
 
				+
			
 
				+// SVG attributes (without "id" and "name" attributes)
			
 
				+// https://wiki.whatwg.org/wiki/Sanitization_rules#svg_Attributes
			
 
				+var svgAttrs = makeMap('accent-height,accumulate,additive,alphabetic,arabic-form,ascent,' +
			
 
				+    'attributeName,attributeType,baseProfile,bbox,begin,by,calcMode,cap-height,class,color,' +
			
 
				+    'color-rendering,content,cx,cy,d,dx,dy,descent,display,dur,end,fill,fill-rule,font-family,' +
			
 
				+    'font-size,font-stretch,font-style,font-variant,font-weight,from,fx,fy,g1,g2,glyph-name,' +
			
 
				+    'gradientUnits,hanging,height,horiz-adv-x,horiz-origin-x,ideographic,k,keyPoints,' +
			
 
				+    'keySplines,keyTimes,lang,marker-end,marker-mid,marker-start,markerHeight,markerUnits,' +
			
 
				+    'markerWidth,mathematical,max,min,offset,opacity,orient,origin,overline-position,' +
			
 
				+    'overline-thickness,panose-1,path,pathLength,points,preserveAspectRatio,r,refX,refY,' +
			
 
				+    'repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,rotate,rx,ry,slope,stemh,' +
			
 
				+    'stemv,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,stroke,' +
			
 
				+    'stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,' +
			
 
				+    'stroke-opacity,stroke-width,systemLanguage,target,text-anchor,to,transform,type,u1,u2,' +
			
 
				+    'underline-position,underline-thickness,unicode,unicode-range,units-per-em,values,version,' +
			
 
				+    'viewBox,visibility,width,widths,x,x-height,x1,x2,xlink:actuate,xlink:arcrole,xlink:role,' +
			
 
				+    'xlink:show,xlink:title,xlink:type,xml:base,xml:lang,xml:space,xmlns,xmlns:xlink,y,y1,y2,' +
			
 
				+    'zoomAndPan');
			
 
				+
			
 
				+var validAttrs = angular.extend({},
			
 
				+                                uriAttrs,
			
 
				+                                svgAttrs,
			
 
				+                                htmlAttrs);
			
 
				+
			
 
				+function makeMap(str) {
			
 
				+  var obj = {}, items = str.split(','), i;
			
 
				+  for (i = 0; i < items.length; i++) obj[items[i]] = true;
			
 
				+  return obj;
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @example
			
 
				+ * htmlParser(htmlString, {
			
 
				+ *     start: function(tag, attrs, unary) {},
			
 
				+ *     end: function(tag) {},
			
 
				+ *     chars: function(text) {},
			
 
				+ *     comment: function(text) {}
			
 
				+ * });
			
 
				+ *
			
 
				+ * @param {string} html string
			
 
				+ * @param {object} handler
			
 
				+ */
			
 
				+function htmlParser(html, handler) {
			
 
				+  if (typeof html !== 'string') {
			
 
				+    if (html === null || typeof html === 'undefined') {
			
 
				+      html = '';
			
 
				+    } else {
			
 
				+      html = '' + html;
			
 
				+    }
			
 
				+  }
			
 
				+  var index, chars, match, stack = [], last = html, text;
			
 
				+  stack.last = function() { return stack[ stack.length - 1 ]; };
			
 
				+
			
 
				+  while (html) {
			
 
				+    text = '';
			
 
				+    chars = true;
			
 
				+
			
 
				+    // Make sure we're not in a script or style element
			
 
				+    if (!stack.last() || !specialElements[ stack.last() ]) {
			
 
				+
			
 
				+      // Comment
			
 
				+      if (html.indexOf("<!--") === 0) {
			
 
				+        // comments containing -- are not allowed unless they terminate the comment
			
 
				+        index = html.indexOf("--", 4);
			
 
				+
			
 
				+        if (index >= 0 && html.lastIndexOf("-->", index) === index) {
			
 
				+          if (handler.comment) handler.comment(html.substring(4, index));
			
 
				+          html = html.substring(index + 3);
			
 
				+          chars = false;
			
 
				+        }
			
 
				+      // DOCTYPE
			
 
				+      } else if (DOCTYPE_REGEXP.test(html)) {
			
 
				+        match = html.match(DOCTYPE_REGEXP);
			
 
				+
			
 
				+        if (match) {
			
 
				+          html = html.replace(match[0], '');
			
 
				+          chars = false;
			
 
				+        }
			
 
				+      // end tag
			
 
				+      } else if (BEGING_END_TAGE_REGEXP.test(html)) {
			
 
				+        match = html.match(END_TAG_REGEXP);
			
 
				+
			
 
				+        if (match) {
			
 
				+          html = html.substring(match[0].length);
			
 
				+          match[0].replace(END_TAG_REGEXP, parseEndTag);
			
 
				+          chars = false;
			
 
				+        }
			
 
				+
			
 
				+      // start tag
			
 
				+      } else if (BEGIN_TAG_REGEXP.test(html)) {
			
 
				+        match = html.match(START_TAG_REGEXP);
			
 
				+
			
 
				+        if (match) {
			
 
				+          // We only have a valid start-tag if there is a '>'.
			
 
				+          if (match[4]) {
			
 
				+            html = html.substring(match[0].length);
			
 
				+            match[0].replace(START_TAG_REGEXP, parseStartTag);
			
 
				+          }
			
 
				+          chars = false;
			
 
				+        } else {
			
 
				+          // no ending tag found --- this piece should be encoded as an entity.
			
 
				+          text += '<';
			
 
				+          html = html.substring(1);
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      if (chars) {
			
 
				+        index = html.indexOf("<");
			
 
				+
			
 
				+        text += index < 0 ? html : html.substring(0, index);
			
 
				+        html = index < 0 ? "" : html.substring(index);
			
 
				+
			
 
				+        if (handler.chars) handler.chars(decodeEntities(text));
			
 
				+      }
			
 
				+
			
 
				+    } else {
			
 
				+      html = html.replace(new RegExp("(.*)<\\s*\\/\\s*" + stack.last() + "[^>]*>", 'i'),
			
 
				+        function(all, text) {
			
 
				+          text = text.replace(COMMENT_REGEXP, "$1").replace(CDATA_REGEXP, "$1");
			
 
				+
			
 
				+          if (handler.chars) handler.chars(decodeEntities(text));
			
 
				+
			
 
				+          return "";
			
 
				+      });
			
 
				+
			
 
				+      parseEndTag("", stack.last());
			
 
				+    }
			
 
				+
			
 
				+    if (html == last) {
			
 
				+      throw $sanitizeMinErr('badparse', "The sanitizer was unable to parse the following block " +
			
 
				+                                        "of html: {0}", html);
			
 
				+    }
			
 
				+    last = html;
			
 
				+  }
			
 
				+
			
 
				+  // Clean up any remaining tags
			
 
				+  parseEndTag();
			
 
				+
			
 
				+  function parseStartTag(tag, tagName, rest, unary) {
			
 
				+    tagName = angular.lowercase(tagName);
			
 
				+    if (blockElements[ tagName ]) {
			
 
				+      while (stack.last() && inlineElements[ stack.last() ]) {
			
 
				+        parseEndTag("", stack.last());
			
 
				+      }
			
 
				+    }
			
 
				+
			
 
				+    if (optionalEndTagElements[ tagName ] && stack.last() == tagName) {
			
 
				+      parseEndTag("", tagName);
			
 
				+    }
			
 
				+
			
 
				+    unary = voidElements[ tagName ] || !!unary;
			
 
				+
			
 
				+    if (!unary)
			
 
				+      stack.push(tagName);
			
 
				+
			
 
				+    var attrs = {};
			
 
				+
			
 
				+    rest.replace(ATTR_REGEXP,
			
 
				+      function(match, name, doubleQuotedValue, singleQuotedValue, unquotedValue) {
			
 
				+        var value = doubleQuotedValue
			
 
				+          || singleQuotedValue
			
 
				+          || unquotedValue
			
 
				+          || '';
			
 
				+
			
 
				+        attrs[name] = decodeEntities(value);
			
 
				+    });
			
 
				+    if (handler.start) handler.start(tagName, attrs, unary);
			
 
				+  }
			
 
				+
			
 
				+  function parseEndTag(tag, tagName) {
			
 
				+    var pos = 0, i;
			
 
				+    tagName = angular.lowercase(tagName);
			
 
				+    if (tagName)
			
 
				+      // Find the closest opened tag of the same type
			
 
				+      for (pos = stack.length - 1; pos >= 0; pos--)
			
 
				+        if (stack[ pos ] == tagName)
			
 
				+          break;
			
 
				+
			
 
				+    if (pos >= 0) {
			
 
				+      // Close all the open elements, up the stack
			
 
				+      for (i = stack.length - 1; i >= pos; i--)
			
 
				+        if (handler.end) handler.end(stack[ i ]);
			
 
				+
			
 
				+      // Remove the open elements from the stack
			
 
				+      stack.length = pos;
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+var hiddenPre=document.createElement("pre");
			
 
				+var spaceRe = /^(\s*)([\s\S]*?)(\s*)$/;
			
 
				+/**
			
 
				+ * decodes all entities into regular string
			
 
				+ * @param value
			
 
				+ * @returns {string} A string with decoded entities.
			
 
				+ */
			
 
				+function decodeEntities(value) {
			
 
				+  if (!value) { return ''; }
			
 
				+
			
 
				+  // Note: IE8 does not preserve spaces at the start/end of innerHTML
			
 
				+  // so we must capture them and reattach them afterward
			
 
				+  var parts = spaceRe.exec(value);
			
 
				+  var spaceBefore = parts[1];
			
 
				+  var spaceAfter = parts[3];
			
 
				+  var content = parts[2];
			
 
				+  if (content) {
			
 
				+    hiddenPre.innerHTML=content.replace(/</g,"&lt;");
			
 
				+    // innerText depends on styling as it doesn't display hidden elements.
			
 
				+    // Therefore, it's better to use textContent not to cause unnecessary
			
 
				+    // reflows. However, IE<9 don't support textContent so the innerText
			
 
				+    // fallback is necessary.
			
 
				+    content = 'textContent' in hiddenPre ?
			
 
				+      hiddenPre.textContent : hiddenPre.innerText;
			
 
				+  }
			
 
				+  return spaceBefore + content + spaceAfter;
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Escapes all potentially dangerous characters, so that the
			
 
				+ * resulting string can be safely inserted into attribute or
			
 
				+ * element text.
			
 
				+ * @param value
			
 
				+ * @returns {string} escaped text
			
 
				+ */
			
 
				+function encodeEntities(value) {
			
 
				+  return value.
			
 
				+    replace(/&/g, '&amp;').
			
 
				+    replace(SURROGATE_PAIR_REGEXP, function(value) {
			
 
				+      var hi = value.charCodeAt(0);
			
 
				+      var low = value.charCodeAt(1);
			
 
				+      return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
			
 
				+    }).
			
 
				+    replace(NON_ALPHANUMERIC_REGEXP, function(value) {
			
 
				+      return '&#' + value.charCodeAt(0) + ';';
			
 
				+    }).
			
 
				+    replace(/</g, '&lt;').
			
 
				+    replace(/>/g, '&gt;');
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * create an HTML/XML writer which writes to buffer
			
 
				+ * @param {Array} buf use buf.jain('') to get out sanitized html string
			
 
				+ * @returns {object} in the form of {
			
 
				+ *     start: function(tag, attrs, unary) {},
			
 
				+ *     end: function(tag) {},
			
 
				+ *     chars: function(text) {},
			
 
				+ *     comment: function(text) {}
			
 
				+ * }
			
 
				+ */
			
 
				+function htmlSanitizeWriter(buf, uriValidator) {
			
 
				+  var ignore = false;
			
 
				+  var out = angular.bind(buf, buf.push);
			
 
				+  return {
			
 
				+    start: function(tag, attrs, unary) {
			
 
				+      tag = angular.lowercase(tag);
			
 
				+      if (!ignore && specialElements[tag]) {
			
 
				+        ignore = tag;
			
 
				+      }
			
 
				+      if (!ignore && validElements[tag] === true) {
			
 
				+        out('<');
			
 
				+        out(tag);
			
 
				+        angular.forEach(attrs, function(value, key) {
			
 
				+          var lkey=angular.lowercase(key);
			
 
				+          var isImage = (tag === 'img' && lkey === 'src') || (lkey === 'background');
			
 
				+          if (validAttrs[lkey] === true &&
			
 
				+            (uriAttrs[lkey] !== true || uriValidator(value, isImage))) {
			
 
				+            out(' ');
			
 
				+            out(key);
			
 
				+            out('="');
			
 
				+            out(encodeEntities(value));
			
 
				+            out('"');
			
 
				+          }
			
 
				+        });
			
 
				+        out(unary ? '/>' : '>');
			
 
				+      }
			
 
				+    },
			
 
				+    end: function(tag) {
			
 
				+        tag = angular.lowercase(tag);
			
 
				+        if (!ignore && validElements[tag] === true) {
			
 
				+          out('</');
			
 
				+          out(tag);
			
 
				+          out('>');
			
 
				+        }
			
 
				+        if (tag == ignore) {
			
 
				+          ignore = false;
			
 
				+        }
			
 
				+      },
			
 
				+    chars: function(chars) {
			
 
				+        if (!ignore) {
			
 
				+          out(encodeEntities(chars));
			
 
				+        }
			
 
				+      }
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+
			
 
				+// define ngSanitize module and register $sanitize service
			
 
				+angular.module('ngSanitize', []).provider('$sanitize', $SanitizeProvider);
			
 
				+
			
 
				+/* global sanitizeText: false */
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc filter
			
 
				+ * @name linky
			
 
				+ * @kind function
			
 
				+ *
			
 
				+ * @description
			
 
				+ * Finds links in text input and turns them into html links. Supports http/https/ftp/mailto and
			
 
				+ * plain email address links.
			
 
				+ *
			
 
				+ * Requires the {@link ngSanitize `ngSanitize`} module to be installed.
			
 
				+ *
			
 
				+ * @param {string} text Input text.
			
 
				+ * @param {string} target Window (_blank|_self|_parent|_top) or named frame to open links in.
			
 
				+ * @returns {string} Html-linkified text.
			
 
				+ *
			
 
				+ * @usage
			
 
				+   <span ng-bind-html="linky_expression | linky"></span>
			
 
				+ *
			
 
				+ * @example
			
 
				+   <example module="linkyExample" deps="angular-sanitize.js">
			
 
				+     <file name="index.html">
			
 
				+       <script>
			
 
				+         angular.module('linkyExample', ['ngSanitize'])
			
 
				+           .controller('ExampleController', ['$scope', function($scope) {
			
 
				+             $scope.snippet =
			
 
				+               'Pretty text with some links:\n'+
			
 
				+               'http://angularjs.org/,\n'+
			
 
				+               'mailto:us@somewhere.org,\n'+
			
 
				+               'another@somewhere.org,\n'+
			
 
				+               'and one more: ftp://127.0.0.1/.';
			
 
				+             $scope.snippetWithTarget = 'http://angularjs.org/';
			
 
				+           }]);
			
 
				+       </script>
			
 
				+       <div ng-controller="ExampleController">
			
 
				+       Snippet: <textarea ng-model="snippet" cols="60" rows="3"></textarea>
			
 
				+       <table>
			
 
				+         <tr>
			
 
				+           <td>Filter</td>
			
 
				+           <td>Source</td>
			
 
				+           <td>Rendered</td>
			
 
				+         </tr>
			
 
				+         <tr id="linky-filter">
			
 
				+           <td>linky filter</td>
			
 
				+           <td>
			
 
				+             <pre>&lt;div ng-bind-html="snippet | linky"&gt;<br>&lt;/div&gt;</pre>
			
 
				+           </td>
			
 
				+           <td>
			
 
				+             <div ng-bind-html="snippet | linky"></div>
			
 
				+           </td>
			
 
				+         </tr>
			
 
				+         <tr id="linky-target">
			
 
				+          <td>linky target</td>
			
 
				+          <td>
			
 
				+            <pre>&lt;div ng-bind-html="snippetWithTarget | linky:'_blank'"&gt;<br>&lt;/div&gt;</pre>
			
 
				+          </td>
			
 
				+          <td>
			
 
				+            <div ng-bind-html="snippetWithTarget | linky:'_blank'"></div>
			
 
				+          </td>
			
 
				+         </tr>
			
 
				+         <tr id="escaped-html">
			
 
				+           <td>no filter</td>
			
 
				+           <td><pre>&lt;div ng-bind="snippet"&gt;<br>&lt;/div&gt;</pre></td>
			
 
				+           <td><div ng-bind="snippet"></div></td>
			
 
				+         </tr>
			
 
				+       </table>
			
 
				+     </file>
			
 
				+     <file name="protractor.js" type="protractor">
			
 
				+       it('should linkify the snippet with urls', function() {
			
 
				+         expect(element(by.id('linky-filter')).element(by.binding('snippet | linky')).getText()).
			
 
				+             toBe('Pretty text with some links: http://angularjs.org/, us@somewhere.org, ' +
			
 
				+                  'another@somewhere.org, and one more: ftp://127.0.0.1/.');
			
 
				+         expect(element.all(by.css('#linky-filter a')).count()).toEqual(4);
			
 
				+       });
			
 
				+
			
 
				+       it('should not linkify snippet without the linky filter', function() {
			
 
				+         expect(element(by.id('escaped-html')).element(by.binding('snippet')).getText()).
			
 
				+             toBe('Pretty text with some links: http://angularjs.org/, mailto:us@somewhere.org, ' +
			
 
				+                  'another@somewhere.org, and one more: ftp://127.0.0.1/.');
			
 
				+         expect(element.all(by.css('#escaped-html a')).count()).toEqual(0);
			
 
				+       });
			
 
				+
			
 
				+       it('should update', function() {
			
 
				+         element(by.model('snippet')).clear();
			
 
				+         element(by.model('snippet')).sendKeys('new http://link.');
			
 
				+         expect(element(by.id('linky-filter')).element(by.binding('snippet | linky')).getText()).
			
 
				+             toBe('new http://link.');
			
 
				+         expect(element.all(by.css('#linky-filter a')).count()).toEqual(1);
			
 
				+         expect(element(by.id('escaped-html')).element(by.binding('snippet')).getText())
			
 
				+             .toBe('new http://link.');
			
 
				+       });
			
 
				+
			
 
				+       it('should work with the target property', function() {
			
 
				+        expect(element(by.id('linky-target')).
			
 
				+            element(by.binding("snippetWithTarget | linky:'_blank'")).getText()).
			
 
				+            toBe('http://angularjs.org/');
			
 
				+        expect(element(by.css('#linky-target a')).getAttribute('target')).toEqual('_blank');
			
 
				+       });
			
 
				+     </file>
			
 
				+   </example>
			
 
				+ */
			
 
				+angular.module('ngSanitize').filter('linky', ['$sanitize', function($sanitize) {
			
 
				+  var LINKY_URL_REGEXP =
			
 
				+        /((ftp|https?):\/\/|(mailto:)?[A-Za-z0-9._%+-]+@)\S*[^\s.;,(){}<>"]/,
			
 
				+      MAILTO_REGEXP = /^mailto:/;
			
 
				+
			
 
				+  return function(text, target) {
			
 
				+    if (!text) return text;
			
 
				+    var match;
			
 
				+    var raw = text;
			
 
				+    var html = [];
			
 
				+    var url;
			
 
				+    var i;
			
 
				+    while ((match = raw.match(LINKY_URL_REGEXP))) {
			
 
				+      // We can not end in these as they are sometimes found at the end of the sentence
			
 
				+      url = match[0];
			
 
				+      // if we did not match ftp/http/mailto then assume mailto
			
 
				+      if (match[2] == match[3]) url = 'mailto:' + url;
			
 
				+      i = match.index;
			
 
				+      addText(raw.substr(0, i));
			
 
				+      addLink(url, match[0].replace(MAILTO_REGEXP, ''));
			
 
				+      raw = raw.substring(i + match[0].length);
			
 
				+    }
			
 
				+    addText(raw);
			
 
				+    return $sanitize(html.join(''));
			
 
				+
			
 
				+    function addText(text) {
			
 
				+      if (!text) {
			
 
				+        return;
			
 
				+      }
			
 
				+      html.push(sanitizeText(text));
			
 
				+    }
			
 
				+
			
 
				+    function addLink(url, text) {
			
 
				+      html.push('<a ');
			
 
				+      if (angular.isDefined(target)) {
			
 
				+        html.push('target="',
			
 
				+                  target,
			
 
				+                  '" ');
			
 
				+      }
			
 
				+      html.push('href="',
			
 
				+                url.replace(/"/g, '&quot;'),
			
 
				+                '">');
			
 
				+      addText(text);
			
 
				+      html.push('</a>');
			
 
				+    }
			
 
				+  };
			
 
				+}]);
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-sanitize.min.js
+++ b/src/js/angularjs/angular-sanitize.min.js
--- a/src/js/angularjs/angular-sanitize.min.js.map
+++ b/src/js/angularjs/angular-sanitize.min.js.map
--- a/src/js/angularjs/angular-scenario.js
+++ b/src/js/angularjs/angular-scenario.js
--- a/src/js/angularjs/angular-touch.js
+++ b/src/js/angularjs/angular-touch.js
@@ -0,0 +1,622 @@
 
				+/**
			
 
				+ * @license AngularJS v1.3.5
			
 
				+ * (c) 2010-2014 Google, Inc. http://angularjs.org
			
 
				+ * License: MIT
			
 
				+ */
			
 
				+(function(window, angular, undefined) {'use strict';
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc module
			
 
				+ * @name ngTouch
			
 
				+ * @description
			
 
				+ *
			
 
				+ * # ngTouch
			
 
				+ *
			
 
				+ * The `ngTouch` module provides touch events and other helpers for touch-enabled devices.
			
 
				+ * The implementation is based on jQuery Mobile touch event handling
			
 
				+ * ([jquerymobile.com](http://jquerymobile.com/)).
			
 
				+ *
			
 
				+ *
			
 
				+ * See {@link ngTouch.$swipe `$swipe`} for usage.
			
 
				+ *
			
 
				+ * <div doc-module-components="ngTouch"></div>
			
 
				+ *
			
 
				+ */
			
 
				+
			
 
				+// define ngTouch module
			
 
				+/* global -ngTouch */
			
 
				+var ngTouch = angular.module('ngTouch', []);
			
 
				+
			
 
				+/* global ngTouch: false */
			
 
				+
			
 
				+    /**
			
 
				+     * @ngdoc service
			
 
				+     * @name $swipe
			
 
				+     *
			
 
				+     * @description
			
 
				+     * The `$swipe` service is a service that abstracts the messier details of hold-and-drag swipe
			
 
				+     * behavior, to make implementing swipe-related directives more convenient.
			
 
				+     *
			
 
				+     * Requires the {@link ngTouch `ngTouch`} module to be installed.
			
 
				+     *
			
 
				+     * `$swipe` is used by the `ngSwipeLeft` and `ngSwipeRight` directives in `ngTouch`, and by
			
 
				+     * `ngCarousel` in a separate component.
			
 
				+     *
			
 
				+     * # Usage
			
 
				+     * The `$swipe` service is an object with a single method: `bind`. `bind` takes an element
			
 
				+     * which is to be watched for swipes, and an object with four handler functions. See the
			
 
				+     * documentation for `bind` below.
			
 
				+     */
			
 
				+
			
 
				+ngTouch.factory('$swipe', [function() {
			
 
				+  // The total distance in any direction before we make the call on swipe vs. scroll.
			
 
				+  var MOVE_BUFFER_RADIUS = 10;
			
 
				+
			
 
				+  var POINTER_EVENTS = {
			
 
				+    'mouse': {
			
 
				+      start: 'mousedown',
			
 
				+      move: 'mousemove',
			
 
				+      end: 'mouseup'
			
 
				+    },
			
 
				+    'touch': {
			
 
				+      start: 'touchstart',
			
 
				+      move: 'touchmove',
			
 
				+      end: 'touchend',
			
 
				+      cancel: 'touchcancel'
			
 
				+    }
			
 
				+  };
			
 
				+
			
 
				+  function getCoordinates(event) {
			
 
				+    var touches = event.touches && event.touches.length ? event.touches : [event];
			
 
				+    var e = (event.changedTouches && event.changedTouches[0]) ||
			
 
				+        (event.originalEvent && event.originalEvent.changedTouches &&
			
 
				+            event.originalEvent.changedTouches[0]) ||
			
 
				+        touches[0].originalEvent || touches[0];
			
 
				+
			
 
				+    return {
			
 
				+      x: e.clientX,
			
 
				+      y: e.clientY
			
 
				+    };
			
 
				+  }
			
 
				+
			
 
				+  function getEvents(pointerTypes, eventType) {
			
 
				+    var res = [];
			
 
				+    angular.forEach(pointerTypes, function(pointerType) {
			
 
				+      var eventName = POINTER_EVENTS[pointerType][eventType];
			
 
				+      if (eventName) {
			
 
				+        res.push(eventName);
			
 
				+      }
			
 
				+    });
			
 
				+    return res.join(' ');
			
 
				+  }
			
 
				+
			
 
				+  return {
			
 
				+    /**
			
 
				+     * @ngdoc method
			
 
				+     * @name $swipe#bind
			
 
				+     *
			
 
				+     * @description
			
 
				+     * The main method of `$swipe`. It takes an element to be watched for swipe motions, and an
			
 
				+     * object containing event handlers.
			
 
				+     * The pointer types that should be used can be specified via the optional
			
 
				+     * third argument, which is an array of strings `'mouse'` and `'touch'`. By default,
			
 
				+     * `$swipe` will listen for `mouse` and `touch` events.
			
 
				+     *
			
 
				+     * The four events are `start`, `move`, `end`, and `cancel`. `start`, `move`, and `end`
			
 
				+     * receive as a parameter a coordinates object of the form `{ x: 150, y: 310 }`.
			
 
				+     *
			
 
				+     * `start` is called on either `mousedown` or `touchstart`. After this event, `$swipe` is
			
 
				+     * watching for `touchmove` or `mousemove` events. These events are ignored until the total
			
 
				+     * distance moved in either dimension exceeds a small threshold.
			
 
				+     *
			
 
				+     * Once this threshold is exceeded, either the horizontal or vertical delta is greater.
			
 
				+     * - If the horizontal distance is greater, this is a swipe and `move` and `end` events follow.
			
 
				+     * - If the vertical distance is greater, this is a scroll, and we let the browser take over.
			
 
				+     *   A `cancel` event is sent.
			
 
				+     *
			
 
				+     * `move` is called on `mousemove` and `touchmove` after the above logic has determined that
			
 
				+     * a swipe is in progress.
			
 
				+     *
			
 
				+     * `end` is called when a swipe is successfully completed with a `touchend` or `mouseup`.
			
 
				+     *
			
 
				+     * `cancel` is called either on a `touchcancel` from the browser, or when we begin scrolling
			
 
				+     * as described above.
			
 
				+     *
			
 
				+     */
			
 
				+    bind: function(element, eventHandlers, pointerTypes) {
			
 
				+      // Absolute total movement, used to control swipe vs. scroll.
			
 
				+      var totalX, totalY;
			
 
				+      // Coordinates of the start position.
			
 
				+      var startCoords;
			
 
				+      // Last event's position.
			
 
				+      var lastPos;
			
 
				+      // Whether a swipe is active.
			
 
				+      var active = false;
			
 
				+
			
 
				+      pointerTypes = pointerTypes || ['mouse', 'touch'];
			
 
				+      element.on(getEvents(pointerTypes, 'start'), function(event) {
			
 
				+        startCoords = getCoordinates(event);
			
 
				+        active = true;
			
 
				+        totalX = 0;
			
 
				+        totalY = 0;
			
 
				+        lastPos = startCoords;
			
 
				+        eventHandlers['start'] && eventHandlers['start'](startCoords, event);
			
 
				+      });
			
 
				+      var events = getEvents(pointerTypes, 'cancel');
			
 
				+      if (events) {
			
 
				+        element.on(events, function(event) {
			
 
				+          active = false;
			
 
				+          eventHandlers['cancel'] && eventHandlers['cancel'](event);
			
 
				+        });
			
 
				+      }
			
 
				+
			
 
				+      element.on(getEvents(pointerTypes, 'move'), function(event) {
			
 
				+        if (!active) return;
			
 
				+
			
 
				+        // Android will send a touchcancel if it thinks we're starting to scroll.
			
 
				+        // So when the total distance (+ or - or both) exceeds 10px in either direction,
			
 
				+        // we either:
			
 
				+        // - On totalX > totalY, we send preventDefault() and treat this as a swipe.
			
 
				+        // - On totalY > totalX, we let the browser handle it as a scroll.
			
 
				+
			
 
				+        if (!startCoords) return;
			
 
				+        var coords = getCoordinates(event);
			
 
				+
			
 
				+        totalX += Math.abs(coords.x - lastPos.x);
			
 
				+        totalY += Math.abs(coords.y - lastPos.y);
			
 
				+
			
 
				+        lastPos = coords;
			
 
				+
			
 
				+        if (totalX < MOVE_BUFFER_RADIUS && totalY < MOVE_BUFFER_RADIUS) {
			
 
				+          return;
			
 
				+        }
			
 
				+
			
 
				+        // One of totalX or totalY has exceeded the buffer, so decide on swipe vs. scroll.
			
 
				+        if (totalY > totalX) {
			
 
				+          // Allow native scrolling to take over.
			
 
				+          active = false;
			
 
				+          eventHandlers['cancel'] && eventHandlers['cancel'](event);
			
 
				+          return;
			
 
				+        } else {
			
 
				+          // Prevent the browser from scrolling.
			
 
				+          event.preventDefault();
			
 
				+          eventHandlers['move'] && eventHandlers['move'](coords, event);
			
 
				+        }
			
 
				+      });
			
 
				+
			
 
				+      element.on(getEvents(pointerTypes, 'end'), function(event) {
			
 
				+        if (!active) return;
			
 
				+        active = false;
			
 
				+        eventHandlers['end'] && eventHandlers['end'](getCoordinates(event), event);
			
 
				+      });
			
 
				+    }
			
 
				+  };
			
 
				+}]);
			
 
				+
			
 
				+/* global ngTouch: false */
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc directive
			
 
				+ * @name ngClick
			
 
				+ *
			
 
				+ * @description
			
 
				+ * A more powerful replacement for the default ngClick designed to be used on touchscreen
			
 
				+ * devices. Most mobile browsers wait about 300ms after a tap-and-release before sending
			
 
				+ * the click event. This version handles them immediately, and then prevents the
			
 
				+ * following click event from propagating.
			
 
				+ *
			
 
				+ * Requires the {@link ngTouch `ngTouch`} module to be installed.
			
 
				+ *
			
 
				+ * This directive can fall back to using an ordinary click event, and so works on desktop
			
 
				+ * browsers as well as mobile.
			
 
				+ *
			
 
				+ * This directive also sets the CSS class `ng-click-active` while the element is being held
			
 
				+ * down (by a mouse click or touch) so you can restyle the depressed element if you wish.
			
 
				+ *
			
 
				+ * @element ANY
			
 
				+ * @param {expression} ngClick {@link guide/expression Expression} to evaluate
			
 
				+ * upon tap. (Event object is available as `$event`)
			
 
				+ *
			
 
				+ * @example
			
 
				+    <example module="ngClickExample" deps="angular-touch.js">
			
 
				+      <file name="index.html">
			
 
				+        <button ng-click="count = count + 1" ng-init="count=0">
			
 
				+          Increment
			
 
				+        </button>
			
 
				+        count: {{ count }}
			
 
				+      </file>
			
 
				+      <file name="script.js">
			
 
				+        angular.module('ngClickExample', ['ngTouch']);
			
 
				+      </file>
			
 
				+    </example>
			
 
				+ */
			
 
				+
			
 
				+ngTouch.config(['$provide', function($provide) {
			
 
				+  $provide.decorator('ngClickDirective', ['$delegate', function($delegate) {
			
 
				+    // drop the default ngClick directive
			
 
				+    $delegate.shift();
			
 
				+    return $delegate;
			
 
				+  }]);
			
 
				+}]);
			
 
				+
			
 
				+ngTouch.directive('ngClick', ['$parse', '$timeout', '$rootElement',
			
 
				+    function($parse, $timeout, $rootElement) {
			
 
				+  var TAP_DURATION = 750; // Shorter than 750ms is a tap, longer is a taphold or drag.
			
 
				+  var MOVE_TOLERANCE = 12; // 12px seems to work in most mobile browsers.
			
 
				+  var PREVENT_DURATION = 2500; // 2.5 seconds maximum from preventGhostClick call to click
			
 
				+  var CLICKBUSTER_THRESHOLD = 25; // 25 pixels in any dimension is the limit for busting clicks.
			
 
				+
			
 
				+  var ACTIVE_CLASS_NAME = 'ng-click-active';
			
 
				+  var lastPreventedTime;
			
 
				+  var touchCoordinates;
			
 
				+  var lastLabelClickCoordinates;
			
 
				+
			
 
				+
			
 
				+  // TAP EVENTS AND GHOST CLICKS
			
 
				+  //
			
 
				+  // Why tap events?
			
 
				+  // Mobile browsers detect a tap, then wait a moment (usually ~300ms) to see if you're
			
 
				+  // double-tapping, and then fire a click event.
			
 
				+  //
			
 
				+  // This delay sucks and makes mobile apps feel unresponsive.
			
 
				+  // So we detect touchstart, touchmove, touchcancel and touchend ourselves and determine when
			
 
				+  // the user has tapped on something.
			
 
				+  //
			
 
				+  // What happens when the browser then generates a click event?
			
 
				+  // The browser, of course, also detects the tap and fires a click after a delay. This results in
			
 
				+  // tapping/clicking twice. We do "clickbusting" to prevent it.
			
 
				+  //
			
 
				+  // How does it work?
			
 
				+  // We attach global touchstart and click handlers, that run during the capture (early) phase.
			
 
				+  // So the sequence for a tap is:
			
 
				+  // - global touchstart: Sets an "allowable region" at the point touched.
			
 
				+  // - element's touchstart: Starts a touch
			
 
				+  // (- touchmove or touchcancel ends the touch, no click follows)
			
 
				+  // - element's touchend: Determines if the tap is valid (didn't move too far away, didn't hold
			
 
				+  //   too long) and fires the user's tap handler. The touchend also calls preventGhostClick().
			
 
				+  // - preventGhostClick() removes the allowable region the global touchstart created.
			
 
				+  // - The browser generates a click event.
			
 
				+  // - The global click handler catches the click, and checks whether it was in an allowable region.
			
 
				+  //     - If preventGhostClick was called, the region will have been removed, the click is busted.
			
 
				+  //     - If the region is still there, the click proceeds normally. Therefore clicks on links and
			
 
				+  //       other elements without ngTap on them work normally.
			
 
				+  //
			
 
				+  // This is an ugly, terrible hack!
			
 
				+  // Yeah, tell me about it. The alternatives are using the slow click events, or making our users
			
 
				+  // deal with the ghost clicks, so I consider this the least of evils. Fortunately Angular
			
 
				+  // encapsulates this ugly logic away from the user.
			
 
				+  //
			
 
				+  // Why not just put click handlers on the element?
			
 
				+  // We do that too, just to be sure. If the tap event caused the DOM to change,
			
 
				+  // it is possible another element is now in that position. To take account for these possibly
			
 
				+  // distinct elements, the handlers are global and care only about coordinates.
			
 
				+
			
 
				+  // Checks if the coordinates are close enough to be within the region.
			
 
				+  function hit(x1, y1, x2, y2) {
			
 
				+    return Math.abs(x1 - x2) < CLICKBUSTER_THRESHOLD && Math.abs(y1 - y2) < CLICKBUSTER_THRESHOLD;
			
 
				+  }
			
 
				+
			
 
				+  // Checks a list of allowable regions against a click location.
			
 
				+  // Returns true if the click should be allowed.
			
 
				+  // Splices out the allowable region from the list after it has been used.
			
 
				+  function checkAllowableRegions(touchCoordinates, x, y) {
			
 
				+    for (var i = 0; i < touchCoordinates.length; i += 2) {
			
 
				+      if (hit(touchCoordinates[i], touchCoordinates[i + 1], x, y)) {
			
 
				+        touchCoordinates.splice(i, i + 2);
			
 
				+        return true; // allowable region
			
 
				+      }
			
 
				+    }
			
 
				+    return false; // No allowable region; bust it.
			
 
				+  }
			
 
				+
			
 
				+  // Global click handler that prevents the click if it's in a bustable zone and preventGhostClick
			
 
				+  // was called recently.
			
 
				+  function onClick(event) {
			
 
				+    if (Date.now() - lastPreventedTime > PREVENT_DURATION) {
			
 
				+      return; // Too old.
			
 
				+    }
			
 
				+
			
 
				+    var touches = event.touches && event.touches.length ? event.touches : [event];
			
 
				+    var x = touches[0].clientX;
			
 
				+    var y = touches[0].clientY;
			
 
				+    // Work around desktop Webkit quirk where clicking a label will fire two clicks (on the label
			
 
				+    // and on the input element). Depending on the exact browser, this second click we don't want
			
 
				+    // to bust has either (0,0), negative coordinates, or coordinates equal to triggering label
			
 
				+    // click event
			
 
				+    if (x < 1 && y < 1) {
			
 
				+      return; // offscreen
			
 
				+    }
			
 
				+    if (lastLabelClickCoordinates &&
			
 
				+        lastLabelClickCoordinates[0] === x && lastLabelClickCoordinates[1] === y) {
			
 
				+      return; // input click triggered by label click
			
 
				+    }
			
 
				+    // reset label click coordinates on first subsequent click
			
 
				+    if (lastLabelClickCoordinates) {
			
 
				+      lastLabelClickCoordinates = null;
			
 
				+    }
			
 
				+    // remember label click coordinates to prevent click busting of trigger click event on input
			
 
				+    if (event.target.tagName.toLowerCase() === 'label') {
			
 
				+      lastLabelClickCoordinates = [x, y];
			
 
				+    }
			
 
				+
			
 
				+    // Look for an allowable region containing this click.
			
 
				+    // If we find one, that means it was created by touchstart and not removed by
			
 
				+    // preventGhostClick, so we don't bust it.
			
 
				+    if (checkAllowableRegions(touchCoordinates, x, y)) {
			
 
				+      return;
			
 
				+    }
			
 
				+
			
 
				+    // If we didn't find an allowable region, bust the click.
			
 
				+    event.stopPropagation();
			
 
				+    event.preventDefault();
			
 
				+
			
 
				+    // Blur focused form elements
			
 
				+    event.target && event.target.blur();
			
 
				+  }
			
 
				+
			
 
				+
			
 
				+  // Global touchstart handler that creates an allowable region for a click event.
			
 
				+  // This allowable region can be removed by preventGhostClick if we want to bust it.
			
 
				+  function onTouchStart(event) {
			
 
				+    var touches = event.touches && event.touches.length ? event.touches : [event];
			
 
				+    var x = touches[0].clientX;
			
 
				+    var y = touches[0].clientY;
			
 
				+    touchCoordinates.push(x, y);
			
 
				+
			
 
				+    $timeout(function() {
			
 
				+      // Remove the allowable region.
			
 
				+      for (var i = 0; i < touchCoordinates.length; i += 2) {
			
 
				+        if (touchCoordinates[i] == x && touchCoordinates[i + 1] == y) {
			
 
				+          touchCoordinates.splice(i, i + 2);
			
 
				+          return;
			
 
				+        }
			
 
				+      }
			
 
				+    }, PREVENT_DURATION, false);
			
 
				+  }
			
 
				+
			
 
				+  // On the first call, attaches some event handlers. Then whenever it gets called, it creates a
			
 
				+  // zone around the touchstart where clicks will get busted.
			
 
				+  function preventGhostClick(x, y) {
			
 
				+    if (!touchCoordinates) {
			
 
				+      $rootElement[0].addEventListener('click', onClick, true);
			
 
				+      $rootElement[0].addEventListener('touchstart', onTouchStart, true);
			
 
				+      touchCoordinates = [];
			
 
				+    }
			
 
				+
			
 
				+    lastPreventedTime = Date.now();
			
 
				+
			
 
				+    checkAllowableRegions(touchCoordinates, x, y);
			
 
				+  }
			
 
				+
			
 
				+  // Actual linking function.
			
 
				+  return function(scope, element, attr) {
			
 
				+    var clickHandler = $parse(attr.ngClick),
			
 
				+        tapping = false,
			
 
				+        tapElement,  // Used to blur the element after a tap.
			
 
				+        startTime,   // Used to check if the tap was held too long.
			
 
				+        touchStartX,
			
 
				+        touchStartY;
			
 
				+
			
 
				+    function resetState() {
			
 
				+      tapping = false;
			
 
				+      element.removeClass(ACTIVE_CLASS_NAME);
			
 
				+    }
			
 
				+
			
 
				+    element.on('touchstart', function(event) {
			
 
				+      tapping = true;
			
 
				+      tapElement = event.target ? event.target : event.srcElement; // IE uses srcElement.
			
 
				+      // Hack for Safari, which can target text nodes instead of containers.
			
 
				+      if (tapElement.nodeType == 3) {
			
 
				+        tapElement = tapElement.parentNode;
			
 
				+      }
			
 
				+
			
 
				+      element.addClass(ACTIVE_CLASS_NAME);
			
 
				+
			
 
				+      startTime = Date.now();
			
 
				+
			
 
				+      var touches = event.touches && event.touches.length ? event.touches : [event];
			
 
				+      var e = touches[0].originalEvent || touches[0];
			
 
				+      touchStartX = e.clientX;
			
 
				+      touchStartY = e.clientY;
			
 
				+    });
			
 
				+
			
 
				+    element.on('touchmove', function(event) {
			
 
				+      resetState();
			
 
				+    });
			
 
				+
			
 
				+    element.on('touchcancel', function(event) {
			
 
				+      resetState();
			
 
				+    });
			
 
				+
			
 
				+    element.on('touchend', function(event) {
			
 
				+      var diff = Date.now() - startTime;
			
 
				+
			
 
				+      var touches = (event.changedTouches && event.changedTouches.length) ? event.changedTouches :
			
 
				+          ((event.touches && event.touches.length) ? event.touches : [event]);
			
 
				+      var e = touches[0].originalEvent || touches[0];
			
 
				+      var x = e.clientX;
			
 
				+      var y = e.clientY;
			
 
				+      var dist = Math.sqrt(Math.pow(x - touchStartX, 2) + Math.pow(y - touchStartY, 2));
			
 
				+
			
 
				+      if (tapping && diff < TAP_DURATION && dist < MOVE_TOLERANCE) {
			
 
				+        // Call preventGhostClick so the clickbuster will catch the corresponding click.
			
 
				+        preventGhostClick(x, y);
			
 
				+
			
 
				+        // Blur the focused element (the button, probably) before firing the callback.
			
 
				+        // This doesn't work perfectly on Android Chrome, but seems to work elsewhere.
			
 
				+        // I couldn't get anything to work reliably on Android Chrome.
			
 
				+        if (tapElement) {
			
 
				+          tapElement.blur();
			
 
				+        }
			
 
				+
			
 
				+        if (!angular.isDefined(attr.disabled) || attr.disabled === false) {
			
 
				+          element.triggerHandler('click', [event]);
			
 
				+        }
			
 
				+      }
			
 
				+
			
 
				+      resetState();
			
 
				+    });
			
 
				+
			
 
				+    // Hack for iOS Safari's benefit. It goes searching for onclick handlers and is liable to click
			
 
				+    // something else nearby.
			
 
				+    element.onclick = function(event) { };
			
 
				+
			
 
				+    // Actual click handler.
			
 
				+    // There are three different kinds of clicks, only two of which reach this point.
			
 
				+    // - On desktop browsers without touch events, their clicks will always come here.
			
 
				+    // - On mobile browsers, the simulated "fast" click will call this.
			
 
				+    // - But the browser's follow-up slow click will be "busted" before it reaches this handler.
			
 
				+    // Therefore it's safe to use this directive on both mobile and desktop.
			
 
				+    element.on('click', function(event, touchend) {
			
 
				+      scope.$apply(function() {
			
 
				+        clickHandler(scope, {$event: (touchend || event)});
			
 
				+      });
			
 
				+    });
			
 
				+
			
 
				+    element.on('mousedown', function(event) {
			
 
				+      element.addClass(ACTIVE_CLASS_NAME);
			
 
				+    });
			
 
				+
			
 
				+    element.on('mousemove mouseup', function(event) {
			
 
				+      element.removeClass(ACTIVE_CLASS_NAME);
			
 
				+    });
			
 
				+
			
 
				+  };
			
 
				+}]);
			
 
				+
			
 
				+/* global ngTouch: false */
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc directive
			
 
				+ * @name ngSwipeLeft
			
 
				+ *
			
 
				+ * @description
			
 
				+ * Specify custom behavior when an element is swiped to the left on a touchscreen device.
			
 
				+ * A leftward swipe is a quick, right-to-left slide of the finger.
			
 
				+ * Though ngSwipeLeft is designed for touch-based devices, it will work with a mouse click and drag
			
 
				+ * too.
			
 
				+ *
			
 
				+ * To disable the mouse click and drag functionality, add `ng-swipe-disable-mouse` to
			
 
				+ * the `ng-swipe-left` or `ng-swipe-right` DOM Element.
			
 
				+ *
			
 
				+ * Requires the {@link ngTouch `ngTouch`} module to be installed.
			
 
				+ *
			
 
				+ * @element ANY
			
 
				+ * @param {expression} ngSwipeLeft {@link guide/expression Expression} to evaluate
			
 
				+ * upon left swipe. (Event object is available as `$event`)
			
 
				+ *
			
 
				+ * @example
			
 
				+    <example module="ngSwipeLeftExample" deps="angular-touch.js">
			
 
				+      <file name="index.html">
			
 
				+        <div ng-show="!showActions" ng-swipe-left="showActions = true">
			
 
				+          Some list content, like an email in the inbox
			
 
				+        </div>
			
 
				+        <div ng-show="showActions" ng-swipe-right="showActions = false">
			
 
				+          <button ng-click="reply()">Reply</button>
			
 
				+          <button ng-click="delete()">Delete</button>
			
 
				+        </div>
			
 
				+      </file>
			
 
				+      <file name="script.js">
			
 
				+        angular.module('ngSwipeLeftExample', ['ngTouch']);
			
 
				+      </file>
			
 
				+    </example>
			
 
				+ */
			
 
				+
			
 
				+/**
			
 
				+ * @ngdoc directive
			
 
				+ * @name ngSwipeRight
			
 
				+ *
			
 
				+ * @description
			
 
				+ * Specify custom behavior when an element is swiped to the right on a touchscreen device.
			
 
				+ * A rightward swipe is a quick, left-to-right slide of the finger.
			
 
				+ * Though ngSwipeRight is designed for touch-based devices, it will work with a mouse click and drag
			
 
				+ * too.
			
 
				+ *
			
 
				+ * Requires the {@link ngTouch `ngTouch`} module to be installed.
			
 
				+ *
			
 
				+ * @element ANY
			
 
				+ * @param {expression} ngSwipeRight {@link guide/expression Expression} to evaluate
			
 
				+ * upon right swipe. (Event object is available as `$event`)
			
 
				+ *
			
 
				+ * @example
			
 
				+    <example module="ngSwipeRightExample" deps="angular-touch.js">
			
 
				+      <file name="index.html">
			
 
				+        <div ng-show="!showActions" ng-swipe-left="showActions = true">
			
 
				+          Some list content, like an email in the inbox
			
 
				+        </div>
			
 
				+        <div ng-show="showActions" ng-swipe-right="showActions = false">
			
 
				+          <button ng-click="reply()">Reply</button>
			
 
				+          <button ng-click="delete()">Delete</button>
			
 
				+        </div>
			
 
				+      </file>
			
 
				+      <file name="script.js">
			
 
				+        angular.module('ngSwipeRightExample', ['ngTouch']);
			
 
				+      </file>
			
 
				+    </example>
			
 
				+ */
			
 
				+
			
 
				+function makeSwipeDirective(directiveName, direction, eventName) {
			
 
				+  ngTouch.directive(directiveName, ['$parse', '$swipe', function($parse, $swipe) {
			
 
				+    // The maximum vertical delta for a swipe should be less than 75px.
			
 
				+    var MAX_VERTICAL_DISTANCE = 75;
			
 
				+    // Vertical distance should not be more than a fraction of the horizontal distance.
			
 
				+    var MAX_VERTICAL_RATIO = 0.3;
			
 
				+    // At least a 30px lateral motion is necessary for a swipe.
			
 
				+    var MIN_HORIZONTAL_DISTANCE = 30;
			
 
				+
			
 
				+    return function(scope, element, attr) {
			
 
				+      var swipeHandler = $parse(attr[directiveName]);
			
 
				+
			
 
				+      var startCoords, valid;
			
 
				+
			
 
				+      function validSwipe(coords) {
			
 
				+        // Check that it's within the coordinates.
			
 
				+        // Absolute vertical distance must be within tolerances.
			
 
				+        // Horizontal distance, we take the current X - the starting X.
			
 
				+        // This is negative for leftward swipes and positive for rightward swipes.
			
 
				+        // After multiplying by the direction (-1 for left, +1 for right), legal swipes
			
 
				+        // (ie. same direction as the directive wants) will have a positive delta and
			
 
				+        // illegal ones a negative delta.
			
 
				+        // Therefore this delta must be positive, and larger than the minimum.
			
 
				+        if (!startCoords) return false;
			
 
				+        var deltaY = Math.abs(coords.y - startCoords.y);
			
 
				+        var deltaX = (coords.x - startCoords.x) * direction;
			
 
				+        return valid && // Short circuit for already-invalidated swipes.
			
 
				+            deltaY < MAX_VERTICAL_DISTANCE &&
			
 
				+            deltaX > 0 &&
			
 
				+            deltaX > MIN_HORIZONTAL_DISTANCE &&
			
 
				+            deltaY / deltaX < MAX_VERTICAL_RATIO;
			
 
				+      }
			
 
				+
			
 
				+      var pointerTypes = ['touch'];
			
 
				+      if (!angular.isDefined(attr['ngSwipeDisableMouse'])) {
			
 
				+        pointerTypes.push('mouse');
			
 
				+      }
			
 
				+      $swipe.bind(element, {
			
 
				+        'start': function(coords, event) {
			
 
				+          startCoords = coords;
			
 
				+          valid = true;
			
 
				+        },
			
 
				+        'cancel': function(event) {
			
 
				+          valid = false;
			
 
				+        },
			
 
				+        'end': function(coords, event) {
			
 
				+          if (validSwipe(coords)) {
			
 
				+            scope.$apply(function() {
			
 
				+              element.triggerHandler(eventName);
			
 
				+              swipeHandler(scope, {$event: event});
			
 
				+            });
			
 
				+          }
			
 
				+        }
			
 
				+      }, pointerTypes);
			
 
				+    };
			
 
				+  }]);
			
 
				+}
			
 
				+
			
 
				+// Left is negative X-coordinate, right is positive.
			
 
				+makeSwipeDirective('ngSwipeLeft', -1, 'swipeleft');
			
 
				+makeSwipeDirective('ngSwipeRight', 1, 'swiperight');
			
 
				+
			
 
				+
			
 
				+
			
 
				+})(window, window.angular);
			
--- a/src/js/angularjs/angular-touch.min.js
+++ b/src/js/angularjs/angular-touch.min.js
--- a/src/js/angularjs/angular-touch.min.js.map
+++ b/src/js/angularjs/angular-touch.min.js.map
--- a/src/js/angularjs/angular.js
+++ b/src/js/angularjs/angular.js
--- a/src/js/angularjs/angular.min.js
+++ b/src/js/angularjs/angular.min.js
--- a/src/js/angularjs/angular.min.js.map
+++ b/src/js/angularjs/angular.min.js.map
--- a/src/js/angularjs/docs/Error404.html
+++ b/src/js/angularjs/docs/Error404.html
@@ -0,0 +1,11 @@
 
				+<h1>Oops!</h1>
			
 
				+
			
 
				+<p>The page you requested does not exist. Perhaps you were looking for something else...</p>
			
 
				+
			
 
				+<div ng-controller="Error404SearchCtrl">
			
 
				+
			
 
				+  <dl ng-repeat="(key, value) in results" ng-show="value.length" style="float: left; margin-right:20px">
			
 
				+    <dt>{{ key }}</dt>
			
 
				+    <dd ng-repeat="item in value"><a ng-href="{{ item.path }}">{{ item.name }}</a></dd>
			
 
				+  </dl>
			
 
				+</div>
			
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap-theme.css
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap-theme.css
@@ -0,0 +1,347 @@
 
				+/*!
			
 
				+ * Bootstrap v3.1.1 (http://getbootstrap.com)
			
 
				+ * Copyright 2011-2014 Twitter, Inc.
			
 
				+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
			
 
				+ */
			
 
				+
			
 
				+.btn-default,
			
 
				+.btn-primary,
			
 
				+.btn-success,
			
 
				+.btn-info,
			
 
				+.btn-warning,
			
 
				+.btn-danger {
			
 
				+  text-shadow: 0 -1px 0 rgba(0, 0, 0, .2);
			
 
				+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);
			
 
				+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);
			
 
				+}
			
 
				+.btn-default:active,
			
 
				+.btn-primary:active,
			
 
				+.btn-success:active,
			
 
				+.btn-info:active,
			
 
				+.btn-warning:active,
			
 
				+.btn-danger:active,
			
 
				+.btn-default.active,
			
 
				+.btn-primary.active,
			
 
				+.btn-success.active,
			
 
				+.btn-info.active,
			
 
				+.btn-warning.active,
			
 
				+.btn-danger.active {
			
 
				+  -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
			
 
				+          box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
			
 
				+}
			
 
				+.btn:active,
			
 
				+.btn.active {
			
 
				+  background-image: none;
			
 
				+}
			
 
				+.btn-default {
			
 
				+  text-shadow: 0 1px 0 #fff;
			
 
				+  background-image: -webkit-linear-gradient(top, #fff 0%, #e0e0e0 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #fff 0%, #e0e0e0 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe0e0e0', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #dbdbdb;
			
 
				+  border-color: #ccc;
			
 
				+}
			
 
				+.btn-default:hover,
			
 
				+.btn-default:focus {
			
 
				+  background-color: #e0e0e0;
			
 
				+  background-position: 0 -15px;
			
 
				+}
			
 
				+.btn-default:active,
			
 
				+.btn-default.active {
			
 
				+  background-color: #e0e0e0;
			
 
				+  border-color: #dbdbdb;
			
 
				+}
			
 
				+.btn-primary {
			
 
				+  background-image: -webkit-linear-gradient(top, #428bca 0%, #2d6ca2 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #428bca 0%, #2d6ca2 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff2d6ca2', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #2b669a;
			
 
				+}
			
 
				+.btn-primary:hover,
			
 
				+.btn-primary:focus {
			
 
				+  background-color: #2d6ca2;
			
 
				+  background-position: 0 -15px;
			
 
				+}
			
 
				+.btn-primary:active,
			
 
				+.btn-primary.active {
			
 
				+  background-color: #2d6ca2;
			
 
				+  border-color: #2b669a;
			
 
				+}
			
 
				+.btn-success {
			
 
				+  background-image: -webkit-linear-gradient(top, #5cb85c 0%, #419641 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #5cb85c 0%, #419641 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff419641', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #3e8f3e;
			
 
				+}
			
 
				+.btn-success:hover,
			
 
				+.btn-success:focus {
			
 
				+  background-color: #419641;
			
 
				+  background-position: 0 -15px;
			
 
				+}
			
 
				+.btn-success:active,
			
 
				+.btn-success.active {
			
 
				+  background-color: #419641;
			
 
				+  border-color: #3e8f3e;
			
 
				+}
			
 
				+.btn-info {
			
 
				+  background-image: -webkit-linear-gradient(top, #5bc0de 0%, #2aabd2 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #5bc0de 0%, #2aabd2 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2aabd2', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #28a4c9;
			
 
				+}
			
 
				+.btn-info:hover,
			
 
				+.btn-info:focus {
			
 
				+  background-color: #2aabd2;
			
 
				+  background-position: 0 -15px;
			
 
				+}
			
 
				+.btn-info:active,
			
 
				+.btn-info.active {
			
 
				+  background-color: #2aabd2;
			
 
				+  border-color: #28a4c9;
			
 
				+}
			
 
				+.btn-warning {
			
 
				+  background-image: -webkit-linear-gradient(top, #f0ad4e 0%, #eb9316 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #f0ad4e 0%, #eb9316 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffeb9316', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #e38d13;
			
 
				+}
			
 
				+.btn-warning:hover,
			
 
				+.btn-warning:focus {
			
 
				+  background-color: #eb9316;
			
 
				+  background-position: 0 -15px;
			
 
				+}
			
 
				+.btn-warning:active,
			
 
				+.btn-warning.active {
			
 
				+  background-color: #eb9316;
			
 
				+  border-color: #e38d13;
			
 
				+}
			
 
				+.btn-danger {
			
 
				+  background-image: -webkit-linear-gradient(top, #d9534f 0%, #c12e2a 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #d9534f 0%, #c12e2a 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc12e2a', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #b92c28;
			
 
				+}
			
 
				+.btn-danger:hover,
			
 
				+.btn-danger:focus {
			
 
				+  background-color: #c12e2a;
			
 
				+  background-position: 0 -15px;
			
 
				+}
			
 
				+.btn-danger:active,
			
 
				+.btn-danger.active {
			
 
				+  background-color: #c12e2a;
			
 
				+  border-color: #b92c28;
			
 
				+}
			
 
				+.thumbnail,
			
 
				+.img-thumbnail {
			
 
				+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
			
 
				+          box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
			
 
				+}
			
 
				+.dropdown-menu > li > a:hover,
			
 
				+.dropdown-menu > li > a:focus {
			
 
				+  background-color: #e8e8e8;
			
 
				+  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #f5f5f5 0%, #e8e8e8 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.dropdown-menu > .active > a,
			
 
				+.dropdown-menu > .active > a:hover,
			
 
				+.dropdown-menu > .active > a:focus {
			
 
				+  background-color: #357ebd;
			
 
				+  background-image: -webkit-linear-gradient(top, #428bca 0%, #357ebd 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #428bca 0%, #357ebd 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff357ebd', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.navbar-default {
			
 
				+  background-image: -webkit-linear-gradient(top, #fff 0%, #f8f8f8 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #fff 0%, #f8f8f8 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff8f8f8', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-radius: 4px;
			
 
				+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 5px rgba(0, 0, 0, .075);
			
 
				+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 5px rgba(0, 0, 0, .075);
			
 
				+}
			
 
				+.navbar-default .navbar-nav > .active > a {
			
 
				+  background-image: -webkit-linear-gradient(top, #ebebeb 0%, #f3f3f3 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #ebebeb 0%, #f3f3f3 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffebebeb', endColorstr='#fff3f3f3', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  -webkit-box-shadow: inset 0 3px 9px rgba(0, 0, 0, .075);
			
 
				+          box-shadow: inset 0 3px 9px rgba(0, 0, 0, .075);
			
 
				+}
			
 
				+.navbar-brand,
			
 
				+.navbar-nav > li > a {
			
 
				+  text-shadow: 0 1px 0 rgba(255, 255, 255, .25);
			
 
				+}
			
 
				+.navbar-inverse {
			
 
				+  background-image: -webkit-linear-gradient(top, #3c3c3c 0%, #222 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #3c3c3c 0%, #222 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff3c3c3c', endColorstr='#ff222222', GradientType=0);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.navbar-inverse .navbar-nav > .active > a {
			
 
				+  background-image: -webkit-linear-gradient(top, #222 0%, #282828 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #222 0%, #282828 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff222222', endColorstr='#ff282828', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  -webkit-box-shadow: inset 0 3px 9px rgba(0, 0, 0, .25);
			
 
				+          box-shadow: inset 0 3px 9px rgba(0, 0, 0, .25);
			
 
				+}
			
 
				+.navbar-inverse .navbar-brand,
			
 
				+.navbar-inverse .navbar-nav > li > a {
			
 
				+  text-shadow: 0 -1px 0 rgba(0, 0, 0, .25);
			
 
				+}
			
 
				+.navbar-static-top,
			
 
				+.navbar-fixed-top,
			
 
				+.navbar-fixed-bottom {
			
 
				+  border-radius: 0;
			
 
				+}
			
 
				+.alert {
			
 
				+  text-shadow: 0 1px 0 rgba(255, 255, 255, .2);
			
 
				+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .25), 0 1px 2px rgba(0, 0, 0, .05);
			
 
				+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .25), 0 1px 2px rgba(0, 0, 0, .05);
			
 
				+}
			
 
				+.alert-success {
			
 
				+  background-image: -webkit-linear-gradient(top, #dff0d8 0%, #c8e5bc 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #dff0d8 0%, #c8e5bc 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffc8e5bc', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #b2dba1;
			
 
				+}
			
 
				+.alert-info {
			
 
				+  background-image: -webkit-linear-gradient(top, #d9edf7 0%, #b9def0 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #d9edf7 0%, #b9def0 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffb9def0', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #9acfea;
			
 
				+}
			
 
				+.alert-warning {
			
 
				+  background-image: -webkit-linear-gradient(top, #fcf8e3 0%, #f8efc0 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #fcf8e3 0%, #f8efc0 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fff8efc0', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #f5e79e;
			
 
				+}
			
 
				+.alert-danger {
			
 
				+  background-image: -webkit-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #f2dede 0%, #e7c3c3 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffe7c3c3', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #dca7a7;
			
 
				+}
			
 
				+.progress {
			
 
				+  background-image: -webkit-linear-gradient(top, #ebebeb 0%, #f5f5f5 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #ebebeb 0%, #f5f5f5 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffebebeb', endColorstr='#fff5f5f5', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.progress-bar {
			
 
				+  background-image: -webkit-linear-gradient(top, #428bca 0%, #3071a9 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #428bca 0%, #3071a9 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff3071a9', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.progress-bar-success {
			
 
				+  background-image: -webkit-linear-gradient(top, #5cb85c 0%, #449d44 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #5cb85c 0%, #449d44 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff449d44', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.progress-bar-info {
			
 
				+  background-image: -webkit-linear-gradient(top, #5bc0de 0%, #31b0d5 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #5bc0de 0%, #31b0d5 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff31b0d5', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.progress-bar-warning {
			
 
				+  background-image: -webkit-linear-gradient(top, #f0ad4e 0%, #ec971f 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #f0ad4e 0%, #ec971f 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffec971f', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.progress-bar-danger {
			
 
				+  background-image: -webkit-linear-gradient(top, #d9534f 0%, #c9302c 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #d9534f 0%, #c9302c 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc9302c', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.list-group {
			
 
				+  border-radius: 4px;
			
 
				+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
			
 
				+          box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
			
 
				+}
			
 
				+.list-group-item.active,
			
 
				+.list-group-item.active:hover,
			
 
				+.list-group-item.active:focus {
			
 
				+  text-shadow: 0 -1px 0 #3071a9;
			
 
				+  background-image: -webkit-linear-gradient(top, #428bca 0%, #3278b3 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #428bca 0%, #3278b3 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff3278b3', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #3278b3;
			
 
				+}
			
 
				+.panel {
			
 
				+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
			
 
				+          box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
			
 
				+}
			
 
				+.panel-default > .panel-heading {
			
 
				+  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #f5f5f5 0%, #e8e8e8 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.panel-primary > .panel-heading {
			
 
				+  background-image: -webkit-linear-gradient(top, #428bca 0%, #357ebd 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #428bca 0%, #357ebd 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff428bca', endColorstr='#ff357ebd', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.panel-success > .panel-heading {
			
 
				+  background-image: -webkit-linear-gradient(top, #dff0d8 0%, #d0e9c6 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #dff0d8 0%, #d0e9c6 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffd0e9c6', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.panel-info > .panel-heading {
			
 
				+  background-image: -webkit-linear-gradient(top, #d9edf7 0%, #c4e3f3 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #d9edf7 0%, #c4e3f3 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffc4e3f3', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.panel-warning > .panel-heading {
			
 
				+  background-image: -webkit-linear-gradient(top, #fcf8e3 0%, #faf2cc 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #fcf8e3 0%, #faf2cc 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fffaf2cc', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.panel-danger > .panel-heading {
			
 
				+  background-image: -webkit-linear-gradient(top, #f2dede 0%, #ebcccc 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #f2dede 0%, #ebcccc 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffebcccc', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+}
			
 
				+.well {
			
 
				+  background-image: -webkit-linear-gradient(top, #e8e8e8 0%, #f5f5f5 100%);
			
 
				+  background-image:         linear-gradient(to bottom, #e8e8e8 0%, #f5f5f5 100%);
			
 
				+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe8e8e8', endColorstr='#fff5f5f5', GradientType=0);
			
 
				+  background-repeat: repeat-x;
			
 
				+  border-color: #dcdcdc;
			
 
				+  -webkit-box-shadow: inset 0 1px 3px rgba(0, 0, 0, .05), 0 1px 0 rgba(255, 255, 255, .1);
			
 
				+          box-shadow: inset 0 1px 3px rgba(0, 0, 0, .05), 0 1px 0 rgba(255, 255, 255, .1);
			
 
				+}
			
 
				+/*# sourceMappingURL=bootstrap-theme.css.map */
			
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap-theme.css.map
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap-theme.css.map
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap-theme.min.css
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap-theme.min.css
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap.css
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap.css
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap.css.map
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap.css.map
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap.min.css
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/css/bootstrap.min.css
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.eot
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.eot
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.svg
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.svg
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.ttf
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.ttf
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.woff
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/fonts/glyphicons-halflings-regular.woff
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/js/bootstrap.js
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/js/bootstrap.js
--- a/src/js/angularjs/docs/components/bootstrap-3.1.1/js/bootstrap.min.js
+++ b/src/js/angularjs/docs/components/bootstrap-3.1.1/js/bootstrap.min.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/CHANGES.html
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/CHANGES.html
@@ -0,0 +1,155 @@
 
				+<html>
			
 
				+  <head>
			
 
				+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
			
 
				+    <title>Change Log</title>
			
 
				+  </head>
			
 
				+  <body bgcolor="white">
			
 
				+    <a style="float:right" href="README.html">README</a>
			
 
				+
			
 
				+    <h1>Known Issues</h1>
			
 
				+    <ul>
			
 
				+      <li>Perl formatting is really crappy.  Partly because the author is lazy and
			
 
				+      partly because Perl is
			
 
				+      <a href="http://www.perlmonks.org/?node_id=663393">hard</a> to parse.
			
 
				+      <li>On some browsers, <code>&lt;code&gt;</code> elements with newlines in the text
			
 
				+      which use CSS to specify <code>white-space:pre</code> will have the newlines
			
 
				+      improperly stripped if the element is not attached to the document at the time
			
 
				+      the stripping is done.  Also, on IE 6, all newlines will be stripped from
			
 
				+      <code>&lt;code&gt;</code> elements because of the way IE6 produces
			
 
				+      <code>innerHTML</code>.  Workaround: use <code>&lt;pre&gt;</code> for code with
			
 
				+      newlines.
			
 
				+    </ul>
			
 
				+
			
 
				+    <h1>Change Log</h1>
			
 
				+    <h2>29 March 2007</h2>
			
 
				+    <ul>
			
 
				+      <li>Added <a href="tests/prettify_test.html#PHP">tests</a> for PHP support
			
 
				+        to address
			
 
				+      <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=3"
			
 
				+       >issue 3</a>.
			
 
				+      <li>Fixed
			
 
				+      <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=6"
			
 
				+       >bug</a>: <code>prettyPrintOne</code> was not halting.  This was not
			
 
				+        reachable through the normal entry point.
			
 
				+      <li>Fixed
			
 
				+      <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=4"
			
 
				+       >bug</a>: recursing into a script block or PHP tag that was not properly
			
 
				+        closed would not silently drop the content.
			
 
				+        (<a href="tests/prettify_test.html#issue4">test</a>)
			
 
				+      <li>Fixed
			
 
				+      <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=8"
			
 
				+       >bug</a>: was eating tabs
			
 
				+        (<a href="tests/prettify_test.html#issue8">test</a>)
			
 
				+      <li>Fixed entity handling so that the caveat
			
 
				+        <blockquote>
			
 
				+          <p>Caveats: please properly escape less-thans.  <tt>x&amp;lt;y</tt>
			
 
				+          instead of <tt>x&lt;y</tt>, and use <tt>&quot;</tt> instead of
			
 
				+          <tt>&amp;quot;</tt> for string delimiters.</p>
			
 
				+        </blockquote>
			
 
				+        is no longer applicable.
			
 
				+      <li>Added noisefree's C#
			
 
				+      <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=4"
			
 
				+       >patch</a>
			
 
				+      <li>Added a <a href="http://google-code-prettify.googlecode.com/files/prettify-small.zip">distribution</a> that has comments and
			
 
				+        whitespace removed to reduce download size from 45.5kB to 12.8kB.
			
 
				+    </ul>
			
 
				+    <h2>4 Jul 2008</h2>
			
 
				+    <ul>
			
 
				+      <li>Added <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=17">language specific formatters</a> that are triggered by the presence
			
 
				+      of a <code>lang-&lt;language-file-extension&gt;</code></li>
			
 
				+      <li>Fixed <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=29">bug</a>: python handling of <code>'''string'''</code>
			
 
				+      <li>Fixed bug: <code>/</code> in regex <code>[charsets] should not end regex</code>
			
 
				+    </ul>
			
 
				+    <h2>5 Jul 2008</h2>
			
 
				+    <ul>
			
 
				+      <li>Defined language extensions for Lisp and Lua</code>
			
 
				+    </ul>
			
 
				+    <h2>14 Jul 2008</h2>
			
 
				+    <ul>
			
 
				+      <li>Language handlers for F#, OCAML, SQL</code>
			
 
				+      <li>Support for <code>nocode</code> spans to allow embedding of line
			
 
				+      numbers and code annotations which should not be styled or otherwise
			
 
				+      affect the tokenization of prettified code.
			
 
				+      See the issue 22
			
 
				+      <a href="tests/prettify_test.html#issue22">testcase</a>.</code>
			
 
				+    </ul>
			
 
				+    <h2>6 Jan 2009</h2>
			
 
				+    <ul>
			
 
				+      <li>Language handlers for Visual Basic, Haskell, CSS, and WikiText</li>
			
 
				+      <li>Added <tt>.mxml</tt> extension to the markup style handler for
			
 
				+        Flex <a href="http://en.wikipedia.org/wiki/MXML">MXML files</a>.  See
			
 
				+        <a
			
 
				+        href="http://code.google.com/p/google-code-prettify/issues/detail?id=37"
			
 
				+        >issue 37</a>.
			
 
				+      <li>Added <tt>.m</tt> extension to the C style handler so that Objective
			
 
				+        C source files properly highlight.  See
			
 
				+        <a
			
 
				+        href="http://code.google.com/p/google-code-prettify/issues/detail?id=58"
			
 
				+       >issue 58</a>.
			
 
				+      <li>Changed HTML lexer to use the same embedded source mechanism as the
			
 
				+        wiki language handler, and changed to use the registered
			
 
				+        CSS handler for STYLE element content.
			
 
				+    </ul>
			
 
				+    <h2>21 May 2009</h2>
			
 
				+    <ul>
			
 
				+      <li>Rewrote to improve performance on large files.
			
 
				+        See <a href="http://mikesamuel.blogspot.com/2009/05/efficient-parsing-in-javascript.html">benchmarks</a>.</li>
			
 
				+      <li>Fixed bugs with highlighting of Haskell line comments, Lisp
			
 
				+        number literals, Lua strings, C preprocessor directives,
			
 
				+        newlines in Wiki code on Windows, and newlines in IE6.</li>
			
 
				+    </ul>
			
 
				+    <h2>14 August 2009</h2>
			
 
				+    <ul>
			
 
				+      <li>Fixed prettifying of <code>&lt;code&gt;</code> blocks with embedded newlines.
			
 
				+    </ul>
			
 
				+    <h2>3 October 2009</h2>
			
 
				+    <ul>
			
 
				+      <li>Fixed prettifying of XML/HTML tags that contain uppercase letters.
			
 
				+    </ul>
			
 
				+    <h2>19 July 2010</h2>
			
 
				+    <ul>
			
 
				+      <li>Added support for line numbers.  Bug
			
 
				+        <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=22"
			
 
				+         >22</a></li>
			
 
				+      <li>Added YAML support.  Bug
			
 
				+        <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=123"
			
 
				+         >123</a></li>
			
 
				+      <li>Added VHDL support courtesy Le Poussin.</li>
			
 
				+      <li>IE performance improvements.  Bug
			
 
				+        <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=102"
			
 
				+         >102</a> courtesy jacobly.</li>
			
 
				+      <li>A variety of markup formatting fixes courtesy smain and thezbyg.</li>
			
 
				+      <li>Fixed copy and paste in IE[678].
			
 
				+      <li>Changed output to use <code>&amp;#160;</code> instead of
			
 
				+        <code>&amp;nbsp;</code> so that the output works when embedded in XML.
			
 
				+        Bug
			
 
				+        <a href="http://code.google.com/p/google-code-prettify/issues/detail?id=108"
			
 
				+         >108</a>.</li>
			
 
				+    </ul>
			
 
				+    <h2>7 September 2010</h2>
			
 
				+    <ul>
			
 
				+      <li>Added support for coffeescript courtesy Cezary Bartoszuk.</li>
			
 
				+    </ul>
			
 
				+    <h2>4 March 2011</h2>
			
 
				+    <ul>
			
 
				+      <li>Added a <a href="http://google-code-prettify.googlecode.com/svn/trunk/styles/index.html">themes
			
 
				+      gallery</a> to showcase contributed styles.</li>
			
 
				+      <li>Added support for XQuery courtesy Patrick Wied, Nemerle
			
 
				+      courtesy Zimin A.V., and Latex support courtesy Martin S.</li>
			
 
				+    </ul>
			
 
				+    <h2>29 March 2011</h2>
			
 
				+    <ul>
			
 
				+      <li>Fixed IE newline issues, and copying/pasting of prettified
			
 
				+      source code from IE.  This required significant internal changes
			
 
				+      but involves no API changes.
			
 
				+      <b>Caveat:</b> <code>prettyPrintOne</code> injects the HTML
			
 
				+      passed to it into a <code>&lt;pre&gt;</code> element.
			
 
				+      If the HTML comes from a trusted source, this may allow XSS.
			
 
				+      Do not do this.  This should not be a problem for existing apps
			
 
				+      since the standard usage is to rewrite the HTML and then inject
			
 
				+      it, so anyone doing that with untrusted HTML already has an XSS
			
 
				+      vulnerability.  If you sanitize and prettify HTML from an
			
 
				+      untrusted source, sanitize first.
			
 
				+    </ul>
			
 
				+  </body>
			
 
				+</html>
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/COPYING
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/COPYING
@@ -0,0 +1,191 @@
 
				+
			
 
				+                                 Apache License
			
 
				+                           Version 2.0, January 2004
			
 
				+                        http://www.apache.org/licenses/
			
 
				+
			
 
				+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
			
 
				+
			
 
				+   1. Definitions.
			
 
				+
			
 
				+      "License" shall mean the terms and conditions for use, reproduction,
			
 
				+      and distribution as defined by Sections 1 through 9 of this document.
			
 
				+
			
 
				+      "Licensor" shall mean the copyright owner or entity authorized by
			
 
				+      the copyright owner that is granting the License.
			
 
				+
			
 
				+      "Legal Entity" shall mean the union of the acting entity and all
			
 
				+      other entities that control, are controlled by, or are under common
			
 
				+      control with that entity. For the purposes of this definition,
			
 
				+      "control" means (i) the power, direct or indirect, to cause the
			
 
				+      direction or management of such entity, whether by contract or
			
 
				+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
			
 
				+      outstanding shares, or (iii) beneficial ownership of such entity.
			
 
				+
			
 
				+      "You" (or "Your") shall mean an individual or Legal Entity
			
 
				+      exercising permissions granted by this License.
			
 
				+
			
 
				+      "Source" form shall mean the preferred form for making modifications,
			
 
				+      including but not limited to software source code, documentation
			
 
				+      source, and configuration files.
			
 
				+
			
 
				+      "Object" form shall mean any form resulting from mechanical
			
 
				+      transformation or translation of a Source form, including but
			
 
				+      not limited to compiled object code, generated documentation,
			
 
				+      and conversions to other media types.
			
 
				+
			
 
				+      "Work" shall mean the work of authorship, whether in Source or
			
 
				+      Object form, made available under the License, as indicated by a
			
 
				+      copyright notice that is included in or attached to the work
			
 
				+      (an example is provided in the Appendix below).
			
 
				+
			
 
				+      "Derivative Works" shall mean any work, whether in Source or Object
			
 
				+      form, that is based on (or derived from) the Work and for which the
			
 
				+      editorial revisions, annotations, elaborations, or other modifications
			
 
				+      represent, as a whole, an original work of authorship. For the purposes
			
 
				+      of this License, Derivative Works shall not include works that remain
			
 
				+      separable from, or merely link (or bind by name) to the interfaces of,
			
 
				+      the Work and Derivative Works thereof.
			
 
				+
			
 
				+      "Contribution" shall mean any work of authorship, including
			
 
				+      the original version of the Work and any modifications or additions
			
 
				+      to that Work or Derivative Works thereof, that is intentionally
			
 
				+      submitted to Licensor for inclusion in the Work by the copyright owner
			
 
				+      or by an individual or Legal Entity authorized to submit on behalf of
			
 
				+      the copyright owner. For the purposes of this definition, "submitted"
			
 
				+      means any form of electronic, verbal, or written communication sent
			
 
				+      to the Licensor or its representatives, including but not limited to
			
 
				+      communication on electronic mailing lists, source code control systems,
			
 
				+      and issue tracking systems that are managed by, or on behalf of, the
			
 
				+      Licensor for the purpose of discussing and improving the Work, but
			
 
				+      excluding communication that is conspicuously marked or otherwise
			
 
				+      designated in writing by the copyright owner as "Not a Contribution."
			
 
				+
			
 
				+      "Contributor" shall mean Licensor and any individual or Legal Entity
			
 
				+      on behalf of whom a Contribution has been received by Licensor and
			
 
				+      subsequently incorporated within the Work.
			
 
				+
			
 
				+   2. Grant of Copyright License. Subject to the terms and conditions of
			
 
				+      this License, each Contributor hereby grants to You a perpetual,
			
 
				+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
			
 
				+      copyright license to reproduce, prepare Derivative Works of,
			
 
				+      publicly display, publicly perform, sublicense, and distribute the
			
 
				+      Work and such Derivative Works in Source or Object form.
			
 
				+
			
 
				+   3. Grant of Patent License. Subject to the terms and conditions of
			
 
				+      this License, each Contributor hereby grants to You a perpetual,
			
 
				+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
			
 
				+      (except as stated in this section) patent license to make, have made,
			
 
				+      use, offer to sell, sell, import, and otherwise transfer the Work,
			
 
				+      where such license applies only to those patent claims licensable
			
 
				+      by such Contributor that are necessarily infringed by their
			
 
				+      Contribution(s) alone or by combination of their Contribution(s)
			
 
				+      with the Work to which such Contribution(s) was submitted. If You
			
 
				+      institute patent litigation against any entity (including a
			
 
				+      cross-claim or counterclaim in a lawsuit) alleging that the Work
			
 
				+      or a Contribution incorporated within the Work constitutes direct
			
 
				+      or contributory patent infringement, then any patent licenses
			
 
				+      granted to You under this License for that Work shall terminate
			
 
				+      as of the date such litigation is filed.
			
 
				+
			
 
				+   4. Redistribution. You may reproduce and distribute copies of the
			
 
				+      Work or Derivative Works thereof in any medium, with or without
			
 
				+      modifications, and in Source or Object form, provided that You
			
 
				+      meet the following conditions:
			
 
				+
			
 
				+      (a) You must give any other recipients of the Work or
			
 
				+          Derivative Works a copy of this License; and
			
 
				+
			
 
				+      (b) You must cause any modified files to carry prominent notices
			
 
				+          stating that You changed the files; and
			
 
				+
			
 
				+      (c) You must retain, in the Source form of any Derivative Works
			
 
				+          that You distribute, all copyright, patent, trademark, and
			
 
				+          attribution notices from the Source form of the Work,
			
 
				+          excluding those notices that do not pertain to any part of
			
 
				+          the Derivative Works; and
			
 
				+
			
 
				+      (d) If the Work includes a "NOTICE" text file as part of its
			
 
				+          distribution, then any Derivative Works that You distribute must
			
 
				+          include a readable copy of the attribution notices contained
			
 
				+          within such NOTICE file, excluding those notices that do not
			
 
				+          pertain to any part of the Derivative Works, in at least one
			
 
				+          of the following places: within a NOTICE text file distributed
			
 
				+          as part of the Derivative Works; within the Source form or
			
 
				+          documentation, if provided along with the Derivative Works; or,
			
 
				+          within a display generated by the Derivative Works, if and
			
 
				+          wherever such third-party notices normally appear. The contents
			
 
				+          of the NOTICE file are for informational purposes only and
			
 
				+          do not modify the License. You may add Your own attribution
			
 
				+          notices within Derivative Works that You distribute, alongside
			
 
				+          or as an addendum to the NOTICE text from the Work, provided
			
 
				+          that such additional attribution notices cannot be construed
			
 
				+          as modifying the License.
			
 
				+
			
 
				+      You may add Your own copyright statement to Your modifications and
			
 
				+      may provide additional or different license terms and conditions
			
 
				+      for use, reproduction, or distribution of Your modifications, or
			
 
				+      for any such Derivative Works as a whole, provided Your use,
			
 
				+      reproduction, and distribution of the Work otherwise complies with
			
 
				+      the conditions stated in this License.
			
 
				+
			
 
				+   5. Submission of Contributions. Unless You explicitly state otherwise,
			
 
				+      any Contribution intentionally submitted for inclusion in the Work
			
 
				+      by You to the Licensor shall be under the terms and conditions of
			
 
				+      this License, without any additional terms or conditions.
			
 
				+      Notwithstanding the above, nothing herein shall supersede or modify
			
 
				+      the terms of any separate license agreement you may have executed
			
 
				+      with Licensor regarding such Contributions.
			
 
				+
			
 
				+   6. Trademarks. This License does not grant permission to use the trade
			
 
				+      names, trademarks, service marks, or product names of the Licensor,
			
 
				+      except as required for reasonable and customary use in describing the
			
 
				+      origin of the Work and reproducing the content of the NOTICE file.
			
 
				+
			
 
				+   7. Disclaimer of Warranty. Unless required by applicable law or
			
 
				+      agreed to in writing, Licensor provides the Work (and each
			
 
				+      Contributor provides its Contributions) on an "AS IS" BASIS,
			
 
				+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
			
 
				+      implied, including, without limitation, any warranties or conditions
			
 
				+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
			
 
				+      PARTICULAR PURPOSE. You are solely responsible for determining the
			
 
				+      appropriateness of using or redistributing the Work and assume any
			
 
				+      risks associated with Your exercise of permissions under this License.
			
 
				+
			
 
				+   8. Limitation of Liability. In no event and under no legal theory,
			
 
				+      whether in tort (including negligence), contract, or otherwise,
			
 
				+      unless required by applicable law (such as deliberate and grossly
			
 
				+      negligent acts) or agreed to in writing, shall any Contributor be
			
 
				+      liable to You for damages, including any direct, indirect, special,
			
 
				+      incidental, or consequential damages of any character arising as a
			
 
				+      result of this License or out of the use or inability to use the
			
 
				+      Work (including but not limited to damages for loss of goodwill,
			
 
				+      work stoppage, computer failure or malfunction, or any and all
			
 
				+      other commercial damages or losses), even if such Contributor
			
 
				+      has been advised of the possibility of such damages.
			
 
				+
			
 
				+   9. Accepting Warranty or Additional Liability. While redistributing
			
 
				+      the Work or Derivative Works thereof, You may choose to offer,
			
 
				+      and charge a fee for, acceptance of support, warranty, indemnity,
			
 
				+      or other liability obligations and/or rights consistent with this
			
 
				+      License. However, in accepting such obligations, You may act only
			
 
				+      on Your own behalf and on Your sole responsibility, not on behalf
			
 
				+      of any other Contributor, and only if You agree to indemnify,
			
 
				+      defend, and hold each Contributor harmless for any liability
			
 
				+      incurred by, or claims asserted against, such Contributor by reason
			
 
				+      of your accepting any such warranty or additional liability.
			
 
				+
			
 
				+   END OF TERMS AND CONDITIONS
			
 
				+
			
 
				+   Copyright 2011 Mike Samuel et al
			
 
				+
			
 
				+   Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+   you may not use this file except in compliance with the License.
			
 
				+   You may obtain a copy of the License at
			
 
				+
			
 
				+       http://www.apache.org/licenses/LICENSE-2.0
			
 
				+
			
 
				+   Unless required by applicable law or agreed to in writing, software
			
 
				+   distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+   See the License for the specific language governing permissions and
			
 
				+   limitations under the License.
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/README-zh-Hans.html
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/README-zh-Hans.html
@@ -0,0 +1,143 @@
 
				+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
			
 
				+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
			
 
				+
			
 
				+<html>
			
 
				+  <head>
			
 
				+    <meta http-equiv="content-type" value="text/html; charset=UTF-8" />
			
 
				+    <title>Javascript code prettifier</title>
			
 
				+
			
 
				+    <link href="src/prettify.css" type="text/css" rel="stylesheet" />
			
 
				+
			
 
				+    <script src="src/prettify.js" type="text/javascript"></script>
			
 
				+
			
 
				+    <style type="text/css">
			
 
				+      body { margin-left: .5in }
			
 
				+      h1, h2, h3, h4, .footer { margin-left: -.4in; }
			
 
				+    </style>
			
 
				+  </head>
			
 
				+
			
 
				+  <body onload="prettyPrint()" bgcolor="white">
			
 
				+    <h1>Javascript code prettifier</h1>
			
 
				+	<h1>Javascript 代码美容师</h1>
			
 
				+    <h2>安装使用</h2>
			
 
				+    <ol>
			
 
				+      <li><a href="http://google-code-prettify.googlecode.com/files/prettify-small-5-Jul-2008.zip">下载</a> 文件
			
 
				+      <li>在你的文件中包含这儿的脚本和样式表(你要保证这儿的 css 和 js 文件按在你的服务器上, 并且调整在 <tt>script</tt> 和 <tt>link</tt>标签中的路径)
			
 
				+        <pre class="prettyprint">
			
 
				+&lt;link href="prettify.css" type="text/css" rel="stylesheet" />
			
 
				+&lt;script type="text/javascript" src="prettify.js">&lt;/script></pre>
			
 
				+      <li>添加<code class="prettyprint">onload="prettyPrint()"</code> 到你的文件的 body 标签中.
			
 
				+      <li>修改样式表,使用你自己喜欢的颜色.</li>
			
 
				+    </ol>
			
 
				+
			
 
				+    <h2>使用方法<br></h2>
			
 
				+    <p>在
			
 
				+    <tt>&lt;pre class="prettyprint"&gt;...&lt;/pre&gt;</tt> 或 <tt>&lt;code class="prettyprint"&gt;...&lt;/code&gt;</tt>
			
 
				+    中间放上代码片段,它就会自动被美化了.
			
 
				+
			
 
				+    <table summary="code examples">
			
 
				+      <tr>
			
 
				+        <th>The original
			
 
				+        <th>Prettier
			
 
				+      <tr>
			
 
				+        <td><pre style="border: 1px solid #888;padding: 2px"
			
 
				+             ><a name="voila1"></a>class Voila {
			
 
				+public:
			
 
				+  // Voila
			
 
				+  static const string VOILA = "Voila";
			
 
				+
			
 
				+  // will not interfere with embedded <a href="#voila1">tags</a>.
			
 
				+}</pre>
			
 
				+
			
 
				+        <td><pre class="prettyprint"><a name="voila2"></a>class Voila {
			
 
				+public:
			
 
				+  // Voila
			
 
				+  static const string VOILA = "Voila";
			
 
				+
			
 
				+  // will not interfere with embedded <a href="#voila2">tags</a>.
			
 
				+}</pre>
			
 
				+    </table>
			
 
				+
			
 
				+    
			
 
				+    <h2>常见问题</h2>
			
 
				+    <h3 id="langs">它是为什么语言工作的?</h3>
			
 
				+    <p><tt>prettify.js中的注释是权威的,但是它的语法分析程序可以在很多语言中使用</tt>,包括 C ,
			
 
				+    Java, Python, Bash, SQL, HTML, XML, CSS, Javascript, 和 Makefiles.
			
 
				+    它在 Ruby, PHP, VB, 和 Awk 中还算可以,而且也可以在 Perl 和 Ruby的合适子集中起作用,但是, 因为注释的约定,它对
			
 
				+    Smalltalk, 或 CAML类似的语言起作用.<br></p>
			
 
				+
			
 
				+    
			
 
				+    <p>LISP系列的语言可以使用一个拓展<a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-lisp.js"><code>lang-lisp.js</code></a>.</p><p>对于 <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-css"><code>CSS</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-hs"><code>Haskell</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-lua.js"><code>Lua</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-ml.js"><code>OCAML, SML, F#</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-vb.js"><code>Visual Basic</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-sql.js"><code>SQL</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-proto.js"><code>Protocol Buffers</code></a>, 和
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-wiki.js"><code>WikiText</code></a>..也是类似的</p><p>如果你想给你喜欢的语言写个拓展版本, 请参阅<tt>src/lang-lisp.js</tt> ,并写一个包括你的语言的拓展的 <a href="http://code.google.com/p/google-code-prettify/issues/list"
			
 
				+     >发布</a> 和一个测试用例.</p>
			
 
				+
			
 
				+    <h3>如何指定我的代码在哪种语言里?</h3>
			
 
				+    <p>你不需要指定语言环境,因为 <code>prettyprint()</code>
			
 
				+    会对此进行猜测.  你可以使用<code> prettyprint </code>这个类通过指定语言的拓展名来指定语言,就像这样:</p>
			
 
				+    <pre class="prettyprint lang-html"
			
 
				+>&lt;pre class=&quot;prettyprint <b>lang-html</b>&quot;&gt;
			
 
				+  The lang-* class specifies the language file extensions.
			
 
				+  File extensions supported by default include
			
 
				+    "bsh", "c", "cc", "cpp", "cs", "csh", "cyc", "cv", "htm", "html",
			
 
				+    "java", "js", "m", "mxml", "perl", "pl", "pm", "py", "rb", "sh",
			
 
				+    "xhtml", "xml", "xsl".
			
 
				+&lt;/pre&gt;</pre>
			
 
				+
			
 
				+    <h3>它在混淆代码例子上不起作用吗?</h3>
			
 
				+    <p>是的.  美化混淆代码就像给小猪涂口红,也就是不在这个工具的范围内. <br></p>
			
 
				+
			
 
				+    <h3>它可以在那些浏览器上工作?</h3>
			
 
				+    <p>这个工具已经在 IE 6, Firefox 1.5 &amp; 2, 和 Safari 2.0.4 上测试通过. 打开 <a href="tests/prettify_test.html">测试页面</a> ,看看它能不能在你的浏览器上起作用.</p>
			
 
				+
			
 
				+    <h3>有什么改变?</h3>
			
 
				+    <p>查看 <a href="CHANGES.html">变化日志</a></p>
			
 
				+
			
 
				+    <h3>&nbsp;为什么Prettyprinting 对WordPress中的字符串没用?</h3>
			
 
				+    <p>很显然,wordpress 在 &quot;smart quoting&quot; 时会改变关闭符号.
			
 
				+    这使得关闭符号跟开始符号不配套.
			
 
				+    <p>这和复制粘贴代码一样,破坏了美化作用. 去
			
 
				+    <a href="http://wordpress.org/support/topic/125038"
			
 
				+    >WordPress's help center</a> 查看更多关于如何关闭插入代码段时的&quot;smart quoting&quot;的信息.</p>
			
 
				+
			
 
				+    <h3>如何在我的代码中加入行号?  (Out of date -- see <a href="README.html">English version</a>)</h3>
			
 
				+    <p>你可以使用 <code>nocode</code> 类来标记 span 标记不是代码.
			
 
				+<pre>&lt;pre class=prettyprint&gt;
			
 
				+&lt;span class="<b>nocode</b>"&gt;1:&lt;/span&gt; /* This is line 1 of my code
			
 
				+&lt;span class="<b>nocode</b>"&gt;2:&lt;/span&gt;  * and here's line 2 */
			
 
				+&lt;span class="<b>nocode</b>"&gt;3:&lt;/span&gt; print("I'm line number 3");
			
 
				+&lt;/pre&gt;</pre>得到
			
 
				+<pre class=prettyprint>
			
 
				+<span class="nocode">1:</span> /* This is line 1 of my code
			
 
				+<span class="nocode">2:</span>  * and here's line 2 */
			
 
				+<span class="nocode">3:</span> print("I'm line number 3");
			
 
				+</pre>
			
 
				+
			
 
				+    <p>查看一个更完整的例子： issue22
			
 
				+    <a href="tests/prettify_test.html#issue22">testcase</a>.</p>
			
 
				+
			
 
				+    <h3>我得到了这样一条错误信息 &quot;a is not a function&quot; 或 &quot;opt_whenDone is not a function&quot;</h3>
			
 
				+    <p>如果你通过事件句柄条用 <code>prettyPrint</code> , 把它隐藏到一个函数中. <br></p><p>不要这么写
			
 
				+    </p><blockquote>
			
 
				+      <code class="prettyprint lang-js"
			
 
				+       >addEventListener('load', prettyPrint, false);</code>
			
 
				+    </blockquote>而要这么写
			
 
				+    <blockquote>
			
 
				+      <code class="prettyprint lang-js"
			
 
				+       >addEventListener('load', function (event) { prettyPrint() }, false);</code>
			
 
				+    </blockquote>这样的话,浏览器就不会把时间对象传递给 <code>prettyPrint</code> ,事件对象会让它困惑的.
			
 
				+
			
 
				+    <br><br><br>
			
 
				+
			
 
				+    <div class="footer">
			
 
				+<!-- Created: Tue Oct  3 17:51:56 PDT 2006 -->
			
 
				+<!-- hhmts start -->
			
 
				+Last modified: Wed Jan  7 13:25:42 PST 2009<br><!-- hhmts end -->
			
 
				+    </div>
			
 
				+  </body>
			
 
				+</html>
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/README.html
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/README.html
@@ -0,0 +1,233 @@
 
				+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
			
 
				+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
			
 
				+
			
 
				+<html>
			
 
				+  <head>
			
 
				+    <title>Javascript code prettifier</title>
			
 
				+
			
 
				+    <link href="src/prettify.css" type="text/css" rel="stylesheet" />
			
 
				+
			
 
				+    <script src="src/prettify.js" type="text/javascript"></script>
			
 
				+
			
 
				+    <style type="text/css">
			
 
				+      body { margin-left: .5in }
			
 
				+      h1, h2, h3, h4, .footer { margin-left: -.4in; }
			
 
				+    </style>
			
 
				+  </head>
			
 
				+
			
 
				+  <body onload="prettyPrint()" bgcolor="white">
			
 
				+    <small style="float: right">Languages : <a href="README-zh-Hans.html">CH</a></small>
			
 
				+    <h1>Javascript code prettifier</h1>
			
 
				+
			
 
				+    <h2>Setup</h2>
			
 
				+    <ol>
			
 
				+      <li><a href="http://code.google.com/p/google-code-prettify/downloads/list">Download</a> a distribution
			
 
				+      <li>Include the script and stylesheets in your document
			
 
				+        (you will need to make sure the css and js file are on your server, and
			
 
				+         adjust the paths in the <tt>script</tt> and <tt>link</tt> tag)
			
 
				+        <pre class="prettyprint">
			
 
				+&lt;link href="prettify.css" type="text/css" rel="stylesheet" /&gt;
			
 
				+&lt;script type="text/javascript" src="prettify.js"&gt;&lt;/script&gt;</pre>
			
 
				+      <li>Add <code class="prettyprint lang-in.tag">onload="prettyPrint()"</code> to your
			
 
				+      document's body tag.
			
 
				+      <li>Modify the stylesheet to get the coloring you prefer</li>
			
 
				+    </ol>
			
 
				+
			
 
				+    <h2>Usage</h2>
			
 
				+    <p>Put code snippets in
			
 
				+    <tt>&lt;pre class="prettyprint"&gt;...&lt;/pre&gt;</tt>
			
 
				+    or <tt>&lt;code class="prettyprint"&gt;...&lt;/code&gt;</tt>
			
 
				+    and it will automatically be pretty printed.
			
 
				+
			
 
				+    <table summary="code examples">
			
 
				+      <tr>
			
 
				+        <th>The original
			
 
				+        <th>Prettier
			
 
				+      <tr>
			
 
				+        <td><pre style="border: 1px solid #888;padding: 2px"
			
 
				+             ><a name="voila1"></a>class Voila {
			
 
				+public:
			
 
				+  // Voila
			
 
				+  static const string VOILA = "Voila";
			
 
				+
			
 
				+  // will not interfere with embedded <a href="#voila1">tags</a>.
			
 
				+}</pre>
			
 
				+
			
 
				+        <td><pre class="prettyprint"><a name="voila2"></a>class Voila {
			
 
				+public:
			
 
				+  // Voila
			
 
				+  static const string VOILA = "Voila";
			
 
				+
			
 
				+  // will not interfere with embedded <a href="#voila2">tags</a>.
			
 
				+}</pre>
			
 
				+    </table>
			
 
				+
			
 
				+    <h2>FAQ</h2>
			
 
				+    <h3 id="langs">For which languages does it work?</h3>
			
 
				+    <p>The comments in <tt>prettify.js</tt> are authoritative but the lexer
			
 
				+    should work on a number of languages including C and friends,
			
 
				+    Java, Python, Bash, SQL, HTML, XML, CSS, Javascript, and Makefiles.
			
 
				+    It works passably on Ruby, PHP, VB, and Awk and a decent subset of Perl
			
 
				+    and Ruby, but, because of commenting conventions, doesn't work on
			
 
				+    Smalltalk, or CAML-like languages.</p>
			
 
				+
			
 
				+    <p>LISPy languages are supported via an extension:
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-lisp.js"
			
 
				+     ><code>lang-lisp.js</code></a>.</p>
			
 
				+    <p>And similarly for
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-clj.js"
			
 
				+     ><code>Clojure</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-css.js"
			
 
				+     ><code>CSS</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-go.js"
			
 
				+     ><code>Go</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-hs.js"
			
 
				+     ><code>Haskell</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-lua.js"
			
 
				+     ><code>Lua</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-ml.js"
			
 
				+     ><code>OCAML, SML, F#</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-n.js"
			
 
				+     ><code>Nemerle</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-proto.js"
			
 
				+     ><code>Protocol Buffers</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-scala.js"
			
 
				+     ><code>Scala</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-sql.js"
			
 
				+     ><code>SQL</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-tex.js"
			
 
				+     ><code>TeX, LaTeX</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-vhdl.js"
			
 
				+     ><code>VHDL</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-vb.js"
			
 
				+     ><code>Visual Basic</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-wiki.js"
			
 
				+     ><code>WikiText</code></a>,
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-xq.js"
			
 
				+     ><code>XQuery</code></a>, and
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/source/browse/trunk/src/lang-yaml.js"
			
 
				+     ><code>YAML</code></a>.
			
 
				+
			
 
				+    <p>If you'd like to add an extension for your favorite language, please
			
 
				+    look at <tt>src/lang-lisp.js</tt> and file an
			
 
				+    <a href="http://code.google.com/p/google-code-prettify/issues/list"
			
 
				+     >issue</a> including your language extension, and a testcase.</p>
			
 
				+
			
 
				+    <h3>How do I specify the language of my code?</h3>
			
 
				+    <p>You don't need to specify the language since <code>prettyprint()</code>
			
 
				+    will guess.  You can specify a language by specifying the language extension
			
 
				+    along with the <code>prettyprint</code> class like so:</p>
			
 
				+    <pre class="prettyprint lang-html"
			
 
				+>&lt;pre class=&quot;prettyprint <b>lang-html</b>&quot;&gt;
			
 
				+  The lang-* class specifies the language file extensions.
			
 
				+  File extensions supported by default include
			
 
				+    "bsh", "c", "cc", "cpp", "cs", "csh", "cyc", "cv", "htm", "html",
			
 
				+    "java", "js", "m", "mxml", "perl", "pl", "pm", "py", "rb", "sh",
			
 
				+    "xhtml", "xml", "xsl".
			
 
				+&lt;/pre&gt;</pre>
			
 
				+
			
 
				+    <p>You may also use the
			
 
				+    <a href="http://dev.w3.org/html5/spec-author-view/the-code-element.html#the-code-element"
			
 
				+     >HTML 5</a> convention of embedding a <tt>code</tt> element inside the
			
 
				+    <code>PRE</code> and using <code>language-java</code> style classes.
			
 
				+    E.g. <xmp class="prettyprint"><pre class="prettyprint"><code class="language-java">...</code></pre></xmp>
			
 
				+
			
 
				+    <h3>It doesn't work on <tt>&lt;obfuscated code sample&gt;</tt>?</h3>
			
 
				+    <p>Yes.  Prettifying obfuscated code is like putting lipstick on a pig
			
 
				+    &mdash; i.e. outside the scope of this tool.</p>
			
 
				+
			
 
				+    <h3>Which browsers does it work with?</h3>
			
 
				+    <p>It's been tested with IE 6, Firefox 1.5 &amp; 2, and Safari 2.0.4.
			
 
				+    Look at <a href="tests/prettify_test.html">the test page</a> to see if it
			
 
				+    works in your browser.</p>
			
 
				+
			
 
				+    <h3>What's changed?</h3>
			
 
				+    <p>See the <a href="CHANGES.html">change log</a></p>
			
 
				+
			
 
				+    <h3>Why doesn't Prettyprinting of strings work on WordPress?</h3>
			
 
				+    <p>Apparently wordpress does "smart quoting" which changes close quotes.
			
 
				+    This causes end quotes to not match up with open quotes.
			
 
				+    <p>This breaks prettifying as well as copying and pasting of code samples.
			
 
				+    See
			
 
				+    <a href="http://wordpress.org/support/topic/125038"
			
 
				+    >WordPress's help center</a> for info on how to stop smart quoting of code
			
 
				+    snippets.</p>
			
 
				+
			
 
				+    <h3 id="linenums">How do I put line numbers in my code?</h3>
			
 
				+    <p>You can use the <code>linenums</code> class to turn on line
			
 
				+    numbering.  If your code doesn't start at line number 1, you can
			
 
				+    add a colon and a line number to the end of that class as in
			
 
				+    <code>linenums:52</code>.
			
 
				+
			
 
				+    <p>For example
			
 
				+<pre class="prettyprint">&lt;pre class="prettyprint linenums:<b>4</b>"
			
 
				+&gt;// This is line 4.
			
 
				+foo();
			
 
				+bar();
			
 
				+baz();
			
 
				+boo();
			
 
				+far();
			
 
				+faz();
			
 
				+&lt;pre&gt;</pre>
			
 
				+    produces
			
 
				+<pre class="prettyprint linenums:4"
			
 
				+>// This is line 4.
			
 
				+foo();
			
 
				+bar();
			
 
				+baz();
			
 
				+boo();
			
 
				+far();
			
 
				+faz();
			
 
				+</pre>
			
 
				+
			
 
				+    <h3>How do I prevent a portion of markup from being marked as code?</h3>
			
 
				+    <p>You can use the <code>nocode</code> class to identify a span of markup
			
 
				+    that is not code.
			
 
				+<pre class="prettyprint">&lt;pre class=prettyprint&gt;
			
 
				+int x = foo();  /* This is a comment  &lt;span class="nocode"&gt;This is not code&lt;/span&gt;
			
 
				+  Continuation of comment */
			
 
				+int y = bar();
			
 
				+&lt;/pre&gt;</pre>
			
 
				+produces
			
 
				+<pre class="prettyprint">
			
 
				+int x = foo();  /* This is a comment  <span class="nocode">This is not code</span>
			
 
				+  Continuation of comment */
			
 
				+int y = bar();
			
 
				+</pre>
			
 
				+
			
 
				+    <p>For a more complete example see the issue22
			
 
				+    <a href="tests/prettify_test.html#issue22">testcase</a>.</p>
			
 
				+
			
 
				+    <h3>I get an error message "a is not a function" or "opt_whenDone is not a function"</h3>
			
 
				+    <p>If you are calling <code>prettyPrint</code> via an event handler, wrap it in a function.
			
 
				+    Instead of doing
			
 
				+    <blockquote>
			
 
				+      <code class="prettyprint lang-js"
			
 
				+       >addEventListener('load', prettyPrint, false);</code>
			
 
				+    </blockquote>
			
 
				+    wrap it in a closure like
			
 
				+    <blockquote>
			
 
				+      <code class="prettyprint lang-js"
			
 
				+       >addEventListener('load', function (event) { prettyPrint() }, false);</code>
			
 
				+    </blockquote>
			
 
				+    so that the browser does not pass an event object to <code>prettyPrint</code> which
			
 
				+    will confuse it.
			
 
				+
			
 
				+    <h3>How can I customize the colors and styles of my code?</h3>
			
 
				+    <p>
			
 
				+    Prettify adds <code>&lt;span&gt;</code> with <code>class</code>es describing
			
 
				+    the kind of code.  You can create CSS styles to matches these
			
 
				+    classes.
			
 
				+    See the
			
 
				+    <a href="http://google-code-prettify.googlecode.com/svn/trunk/styles/index.html">
			
 
				+    theme gallery</a> for examples.
			
 
				+    </p>
			
 
				+
			
 
				+    <br><br><br>
			
 
				+
			
 
				+    <div class="footer">
			
 
				+<!-- Created: Tue Oct  3 17:51:56 PDT 2006 -->
			
 
				+<!-- hhmts start -->Last modified: Fri May 27 20:23:23 PDT 2011 <!-- hhmts end -->
			
 
				+    </div>
			
 
				+  </body>
			
 
				+</html>
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/README.md
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/README.md
@@ -0,0 +1,54 @@
 
				+# Google Code Prettify
			
 
				+
			
 
				+Direct port of svn into git from http://google-code-prettify.googlecode.com/svn/trunk/
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+via [Bower](http://twitter.github.com/bower/)
			
 
				+
			
 
				+	bower install google-code-prettify
			
 
				+
			
 
				+or [Yeoman](http://yeoman.io/)
			
 
				+
			
 
				+	yeoman install google-code-prettify
			
 
				+
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+The prettify script is AMD compatible and can be used modularly. Here is an example of it in an AMD module:
			
 
				+
			
 
				+```javascript
			
 
				+define(['jquery', 'prettify'], function($, prettify){
			
 
				+	var code = null;
			
 
				+	$('pre').addClass('prettyprint').each(function(idx, el){
			
 
				+			code = el.firstChild;
			
 
				+			code.innerHTML = prettify.prettyPrintOne(code.innerHTML);
			
 
				+		})
			
 
				+	);
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+This version of google-code-prettify defines an anonymous module, which is more flexible.  To allow your AMD loader to find google-code-prettify with a more convenient name, map a path to it as follows:
			
 
				+
			
 
				+```js
			
 
				+// using RequireJS
			
 
				+require.config({
			
 
				+	prettify: 'bower_components/google-code-prettify/prettify'
			
 
				+});
			
 
				+
			
 
				+// using curl.js
			
 
				+curl.config({
			
 
				+	prettify: 'bower_components/google-code-prettify/prettify'
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+Or it may just be used in a global context like the following:
			
 
				+
			
 
				+```javascript
			
 
				+(function(){
			
 
				+	$('pre').addClass('prettyprint');
			
 
				+	prettyPrint();
			
 
				+})();
			
 
				+```
			
 
				+
			
 
				+More information can be found in the original [README.html](http://google-code-prettify.googlecode.com/svn/trunk/README.html)
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/bower.json
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/bower.json
@@ -0,0 +1,13 @@
 
				+{
			
 
				+	"name": "google-code-prettify",
			
 
				+	"version": "1.0.1",
			
 
				+	"main": "./src/prettify.js",
			
 
				+	"dependencies": {},
			
 
				+	"ignore": [
			
 
				+		"closure-compiler",
			
 
				+		"js-modules",
			
 
				+		"tests",
			
 
				+		"yui-compressor",
			
 
				+		"Makefile"
			
 
				+	]
			
 
				+}
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-apollo.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-apollo.js
@@ -0,0 +1,51 @@
 
				+// Copyright (C) 2009 Onno Hommes.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for the AGC/AEA Assembly Language as described
			
 
				+ * at http://virtualagc.googlecode.com
			
 
				+ * <p>
			
 
				+ * This file could be used by goodle code to allow syntax highlight for
			
 
				+ * Virtual AGC SVN repository or if you don't want to commonize
			
 
				+ * the header for the agc/aea html assembly listing.
			
 
				+ *
			
 
				+ * @author ohommes@alumni.cmu.edu
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // A line comment that starts with ;
			
 
				+         [PR['PR_COMMENT'],     /^#[^\r\n]*/, null, '#'],
			
 
				+         // Whitespace
			
 
				+         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
			
 
				+         // A double quoted, possibly multi-line, string.
			
 
				+         [PR['PR_STRING'],      /^\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)/, null, '"']
			
 
				+        ],
			
 
				+        [
			
 
				+         [PR['PR_KEYWORD'], /^(?:ADS|AD|AUG|BZF|BZMF|CAE|CAF|CA|CCS|COM|CS|DAS|DCA|DCOM|DCS|DDOUBL|DIM|DOUBLE|DTCB|DTCF|DV|DXCH|EDRUPT|EXTEND|INCR|INDEX|NDX|INHINT|LXCH|MASK|MSK|MP|MSU|NOOP|OVSK|QXCH|RAND|READ|RELINT|RESUME|RETURN|ROR|RXOR|SQUARE|SU|TCR|TCAA|OVSK|TCF|TC|TS|WAND|WOR|WRITE|XCH|XLQ|XXALQ|ZL|ZQ|ADD|ADZ|SUB|SUZ|MPY|MPR|MPZ|DVP|COM|ABS|CLA|CLZ|LDQ|STO|STQ|ALS|LLS|LRS|TRA|TSQ|TMI|TOV|AXT|TIX|DLY|INP|OUT)\s/,null],
			
 
				+         [PR['PR_TYPE'], /^(?:-?GENADR|=MINUS|2BCADR|VN|BOF|MM|-?2CADR|-?[1-6]DNADR|ADRES|BBCON|[SE]?BANK\=?|BLOCK|BNKSUM|E?CADR|COUNT\*?|2?DEC\*?|-?DNCHAN|-?DNPTR|EQUALS|ERASE|MEMORY|2?OCT|REMADR|SETLOC|SUBRO|ORG|BSS|BES|SYN|EQU|DEFINE|END)\s/,null],
			
 
				+         // A single quote possibly followed by a word that optionally ends with
			
 
				+         // = ! or ?.
			
 
				+         [PR['PR_LITERAL'],
			
 
				+          /^\'(?:-*(?:\w|\\[\x21-\x7e])(?:[\w-]*|\\[\x21-\x7e])[=!?]?)?/],
			
 
				+         // Any word including labels that optionally ends with = ! or ?.
			
 
				+         [PR['PR_PLAIN'],
			
 
				+          /^-*(?:[!-z_]|\\[\x21-\x7e])(?:[\w-]*|\\[\x21-\x7e])[=!?]?/i],
			
 
				+         // A printable non-space non-special character
			
 
				+         [PR['PR_PUNCTUATION'], /^[^\w\t\n\r \xA0()\"\\\';]+/]
			
 
				+        ]),
			
 
				+    ['apollo', 'agc', 'aea']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-clj.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-clj.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-css.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-css.js
@@ -0,0 +1,159 @@
 
				+// Copyright (C) 2009 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for CSS.
			
 
				+ *
			
 
				+ *
			
 
				+ * To use, include prettify.js and this file in your HTML page.
			
 
				+ * Then put your code in an HTML tag like
			
 
				+ *      <pre class="prettyprint lang-css"></pre>
			
 
				+ *
			
 
				+ *
			
 
				+ * http://www.w3.org/TR/CSS21/grammar.html Section G2 defines the lexical
			
 
				+ * grammar.  This scheme does not recognize keywords containing escapes.
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+// This file is a call to a function defined in prettify.js which defines a
			
 
				+// lexical scanner for CSS and maps tokens to styles.
			
 
				+
			
 
				+// The call to PR['registerLangHandler'] is quoted so that Closure Compiler
			
 
				+// will not rename the call so that this language extensions can be
			
 
				+// compiled/minified separately from one another.  Other symbols defined in
			
 
				+// prettify.js are similarly quoted.
			
 
				+
			
 
				+// The call is structured thus:
			
 
				+// PR['registerLangHandler'](
			
 
				+//    PR['createSimpleLexer'](
			
 
				+//        shortcutPatterns,
			
 
				+//        fallThroughPatterns),
			
 
				+//    [languageId0, ..., languageIdN])
			
 
				+
			
 
				+// Langugage IDs
			
 
				+// =============
			
 
				+// The language IDs are typically the file extensions of source files for
			
 
				+// that language so that users can syntax highlight arbitrary files based
			
 
				+// on just the extension.  This is heuristic, but works pretty well in
			
 
				+// practice.
			
 
				+
			
 
				+// Patterns
			
 
				+// ========
			
 
				+// Lexers are typically implemented as a set of regular expressions.
			
 
				+// The SimpleLexer function takes regular expressions, styles, and some
			
 
				+// pragma-info and produces a lexer.  A token description looks like
			
 
				+//   [STYLE_NAME, /regular-expression/, pragmas]
			
 
				+
			
 
				+// Initially, simple lexer's inner loop looked like:
			
 
				+
			
 
				+//    while sourceCode is not empty:
			
 
				+//      try each regular expression in order until one matches
			
 
				+//      remove the matched portion from sourceCode
			
 
				+
			
 
				+// This was really slow for large files because some JS interpreters
			
 
				+// do a buffer copy on the matched portion which is O(n*n)
			
 
				+
			
 
				+// The current loop now looks like
			
 
				+
			
 
				+//    1. use js-modules/combinePrefixPatterns.js to 
			
 
				+//       combine all regular expressions into one 
			
 
				+//    2. use a single global regular expresion match to extract all tokens
			
 
				+//    3. for each token try regular expressions in order until one matches it
			
 
				+//       and classify it using the associated style
			
 
				+
			
 
				+// This is a lot more efficient but it does mean that lookahead and lookbehind
			
 
				+// can't be used across boundaries to classify tokens.
			
 
				+
			
 
				+// Sometimes we need lookahead and lookbehind and sometimes we want to handle
			
 
				+// embedded language -- JavaScript or CSS embedded in HTML, or inline assembly
			
 
				+// in C.
			
 
				+
			
 
				+// If a particular pattern has a numbered group, and its style pattern starts
			
 
				+// with "lang-" as in
			
 
				+//    ['lang-js', /<script>(.*?)<\/script>/]
			
 
				+// then the token classification step breaks the token into pieces.
			
 
				+// Group 1 is re-parsed using the language handler for "lang-js", and the
			
 
				+// surrounding portions are reclassified using the current language handler.
			
 
				+// This mechanism gives us both lookahead, lookbehind, and language embedding.
			
 
				+
			
 
				+// Shortcut Patterns
			
 
				+// =================
			
 
				+// A shortcut pattern is one that is tried before other patterns if the first
			
 
				+// character in the token is in the string of characters.
			
 
				+// This very effectively lets us make quick correct decisions for common token
			
 
				+// types.
			
 
				+
			
 
				+// All other patterns are fall-through patterns.
			
 
				+
			
 
				+
			
 
				+
			
 
				+// The comments inline below refer to productions in the CSS specification's
			
 
				+// lexical grammar.  See link above.
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        // Shortcut patterns.
			
 
				+        [
			
 
				+         // The space production <s>
			
 
				+         [PR['PR_PLAIN'],       /^[ \t\r\n\f]+/, null, ' \t\r\n\f']
			
 
				+        ],
			
 
				+        // Fall-through patterns.
			
 
				+        [
			
 
				+         // Quoted strings.  <string1> and <string2>
			
 
				+         [PR['PR_STRING'],
			
 
				+          /^\"(?:[^\n\r\f\\\"]|\\(?:\r\n?|\n|\f)|\\[\s\S])*\"/, null],
			
 
				+         [PR['PR_STRING'],
			
 
				+          /^\'(?:[^\n\r\f\\\']|\\(?:\r\n?|\n|\f)|\\[\s\S])*\'/, null],
			
 
				+         ['lang-css-str', /^url\(([^\)\"\']+)\)/i],
			
 
				+         [PR['PR_KEYWORD'],
			
 
				+          /^(?:url|rgb|\!important|@import|@page|@media|@charset|inherit)(?=[^\-\w]|$)/i,
			
 
				+          null],
			
 
				+         // A property name -- an identifier followed by a colon.
			
 
				+         ['lang-css-kw', /^(-?(?:[_a-z]|(?:\\[0-9a-f]+ ?))(?:[_a-z0-9\-]|\\(?:\\[0-9a-f]+ ?))*)\s*:/i],
			
 
				+         // A C style block comment.  The <comment> production.
			
 
				+         [PR['PR_COMMENT'], /^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//],
			
 
				+         // Escaping text spans
			
 
				+         [PR['PR_COMMENT'], /^(?:<!--|-->)/],
			
 
				+         // A number possibly containing a suffix.
			
 
				+         [PR['PR_LITERAL'], /^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],
			
 
				+         // A hex color
			
 
				+         [PR['PR_LITERAL'], /^#(?:[0-9a-f]{3}){1,2}/i],
			
 
				+         // An identifier
			
 
				+         [PR['PR_PLAIN'],
			
 
				+          /^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i],
			
 
				+         // A run of punctuation
			
 
				+         [PR['PR_PUNCTUATION'], /^[^\s\w\'\"]+/]
			
 
				+        ]),
			
 
				+    ['css']);
			
 
				+// Above we use embedded languages to highlight property names (identifiers
			
 
				+// followed by a colon) differently from identifiers in values.
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer']([],
			
 
				+        [
			
 
				+         [PR['PR_KEYWORD'],
			
 
				+          /^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i]
			
 
				+        ]),
			
 
				+    ['css-kw']);
			
 
				+// The content of an unquoted URL literal like url(http://foo/img.png) should
			
 
				+// be colored as string content.  This language handler is used above in the
			
 
				+// URL production to do so.
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer']([],
			
 
				+        [
			
 
				+         [PR['PR_STRING'], /^[^\)\"\']+/]
			
 
				+        ]),
			
 
				+    ['css-str']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-dart.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-dart.js
@@ -0,0 +1,88 @@
 
				+// Copyright (C) 2013 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler Dart.
			
 
				+ * Loosely structured based on the DartLexer in Pygments: http://pygments.org/.
			
 
				+ *
			
 
				+ * To use, include prettify.js and this file in your HTML page.
			
 
				+ * Then put your code in an HTML tag like
			
 
				+ *      <pre class="prettyprint lang-dart">(Dart code)</pre>
			
 
				+ *
			
 
				+ * @author armstrong.timothy@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+  PR['createSimpleLexer'](
			
 
				+    [
			
 
				+      // Whitespace.
			
 
				+      [PR['PR_PLAIN'], /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0']
			
 
				+    ],
			
 
				+    [
			
 
				+      // Script tag.
			
 
				+      [PR['PR_COMMENT'], /^#!(?:.*)/],
			
 
				+
			
 
				+      // `import`, `library`, `part of`, `part`, `as`, `show`, and `hide`
			
 
				+      // keywords.
			
 
				+      [PR['PR_KEYWORD'], /^\b(?:import|library|part of|part|as|show|hide)\b/i],
			
 
				+
			
 
				+      // Single-line comments.
			
 
				+      [PR['PR_COMMENT'], /^\/\/(?:.*)/],
			
 
				+
			
 
				+      // Multiline comments.
			
 
				+      [PR['PR_COMMENT'], /^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//], // */
			
 
				+
			
 
				+      // `class` and `interface` keywords.
			
 
				+      [PR['PR_KEYWORD'], /^\b(?:class|interface)\b/i],
			
 
				+
			
 
				+      // General keywords.
			
 
				+      [PR['PR_KEYWORD'], /^\b(?:assert|break|case|catch|continue|default|do|else|finally|for|if|in|is|new|return|super|switch|this|throw|try|while)\b/i],
			
 
				+
			
 
				+      // Declaration keywords.
			
 
				+      [PR['PR_KEYWORD'], /^\b(?:abstract|const|extends|factory|final|get|implements|native|operator|set|static|typedef|var)\b/i],
			
 
				+
			
 
				+      // Keywords for types.
			
 
				+      [PR['PR_TYPE'], /^\b(?:bool|double|Dynamic|int|num|Object|String|void)\b/i],
			
 
				+
			
 
				+      // Keywords for constants.
			
 
				+      [PR['PR_KEYWORD'], /^\b(?:false|null|true)\b/i],
			
 
				+
			
 
				+      // Multiline strings, single- and double-quoted.
			
 
				+      [PR['PR_STRING'], /^r?[\']{3}[\s|\S]*?[^\\][\']{3}/],
			
 
				+      [PR['PR_STRING'], /^r?[\"]{3}[\s|\S]*?[^\\][\"]{3}/],
			
 
				+
			
 
				+      // Normal and raw strings, single- and double-quoted.
			
 
				+      [PR['PR_STRING'], /^r?\'(\'|(?:[^\n\r\f])*?[^\\]\')/],
			
 
				+      [PR['PR_STRING'], /^r?\"(\"|(?:[^\n\r\f])*?[^\\]\")/],
			
 
				+
			
 
				+      // Identifiers.
			
 
				+      [PR['PR_PLAIN'], /^[a-z_$][a-z0-9_]*/i],
			
 
				+      
			
 
				+      // Operators.
			
 
				+      [PR['PR_PUNCTUATION'], /^[~!%^&*+=|?:<>/-]/],
			
 
				+
			
 
				+      // Hex numbers.
			
 
				+      [PR['PR_LITERAL'], /^\b0x[0-9a-f]+/i],
			
 
				+
			
 
				+      // Decimal numbers.
			
 
				+      [PR['PR_LITERAL'], /^\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i],
			
 
				+      [PR['PR_LITERAL'], /^\b\.\d+(?:e[+-]?\d+)?/i],
			
 
				+
			
 
				+      // Punctuation.
			
 
				+      [PR['PR_PUNCTUATION'], /^[(){}\[\],.;]/]
			
 
				+    ]),
			
 
				+  ['dart']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-go.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-go.js
@@ -0,0 +1,58 @@
 
				+// Copyright (C) 2010 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for the Go language..
			
 
				+ * <p>
			
 
				+ * Based on the lexical grammar at 
			
 
				+ * http://golang.org/doc/go_spec.html#Lexical_elements
			
 
				+ * <p>
			
 
				+ * Go uses a minimal style for highlighting so the below does not distinguish
			
 
				+ * strings, keywords, literals, etc. by design.
			
 
				+ * From a discussion with the Go designers:
			
 
				+ * <pre>
			
 
				+ * On Thursday, July 22, 2010, Mike Samuel <...> wrote:
			
 
				+ * > On Thu, Jul 22, 2010, Rob 'Commander' Pike <...> wrote:
			
 
				+ * >> Personally, I would vote for the subdued style godoc presents at http://golang.org
			
 
				+ * >>
			
 
				+ * >> Not as fancy as some like, but a case can be made it's the official style.
			
 
				+ * >> If people want more colors, I wouldn't fight too hard, in the interest of
			
 
				+ * >> encouragement through familiarity, but even then I would ask to shy away
			
 
				+ * >> from technicolor starbursts.
			
 
				+ * >
			
 
				+ * > Like http://golang.org/pkg/go/scanner/ where comments are blue and all
			
 
				+ * > other content is black?  I can do that.
			
 
				+ * </pre>
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // Whitespace is made up of spaces, tabs and newline characters.
			
 
				+         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
			
 
				+         // Not escaped as a string.  See note on minimalism above.
			
 
				+         [PR['PR_PLAIN'],       /^(?:\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)|\'(?:[^\'\\]|\\[\s\S])+(?:\'|$)|`[^`]*(?:`|$))/, null, '"\'']
			
 
				+        ],
			
 
				+        [
			
 
				+         // Block comments are delimited by /* and */.
			
 
				+         // Single-line comments begin with // and extend to the end of a line.
			
 
				+         [PR['PR_COMMENT'],     /^(?:\/\/[^\r\n]*|\/\*[\s\S]*?\*\/)/],
			
 
				+         [PR['PR_PLAIN'],       /^(?:[^\/\"\'`]|\/(?![\/\*]))+/i]
			
 
				+        ]),
			
 
				+    ['go']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-hs.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-hs.js
@@ -0,0 +1,101 @@
 
				+// Copyright (C) 2009 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for Haskell.
			
 
				+ *
			
 
				+ *
			
 
				+ * To use, include prettify.js and this file in your HTML page.
			
 
				+ * Then put your code in an HTML tag like
			
 
				+ *      <pre class="prettyprint lang-hs">(my lisp code)</pre>
			
 
				+ * The lang-cl class identifies the language as common lisp.
			
 
				+ * This file supports the following language extensions:
			
 
				+ *     lang-cl - Common Lisp
			
 
				+ *     lang-el - Emacs Lisp
			
 
				+ *     lang-lisp - Lisp
			
 
				+ *     lang-scm - Scheme
			
 
				+ *
			
 
				+ *
			
 
				+ * I used http://www.informatik.uni-freiburg.de/~thiemann/haskell/haskell98-report-html/syntax-iso.html
			
 
				+ * as the basis, but ignore the way the ncomment production nests since this
			
 
				+ * makes the lexical grammar irregular.  It might be possible to support
			
 
				+ * ncomments using the lookbehind filter.
			
 
				+ *
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // Whitespace
			
 
				+         // whitechar    ->    newline | vertab | space | tab | uniWhite
			
 
				+         // newline      ->    return linefeed | return | linefeed | formfeed
			
 
				+         [PR['PR_PLAIN'],       /^[\t\n\x0B\x0C\r ]+/, null, '\t\n\x0B\x0C\r '],
			
 
				+         // Single line double and single-quoted strings.
			
 
				+         // char         ->    ' (graphic<' | \> | space | escape<\&>) '
			
 
				+         // string       ->    " {graphic<" | \> | space | escape | gap}"
			
 
				+         // escape       ->    \ ( charesc | ascii | decimal | o octal
			
 
				+         //                        | x hexadecimal )
			
 
				+         // charesc      ->    a | b | f | n | r | t | v | \ | " | ' | &
			
 
				+         [PR['PR_STRING'],      /^\"(?:[^\"\\\n\x0C\r]|\\[\s\S])*(?:\"|$)/,
			
 
				+          null, '"'],
			
 
				+         [PR['PR_STRING'],      /^\'(?:[^\'\\\n\x0C\r]|\\[^&])\'?/,
			
 
				+          null, "'"],
			
 
				+         // decimal      ->    digit{digit}
			
 
				+         // octal        ->    octit{octit}
			
 
				+         // hexadecimal  ->    hexit{hexit}
			
 
				+         // integer      ->    decimal
			
 
				+         //               |    0o octal | 0O octal
			
 
				+         //               |    0x hexadecimal | 0X hexadecimal
			
 
				+         // float        ->    decimal . decimal [exponent]
			
 
				+         //               |    decimal exponent
			
 
				+         // exponent     ->    (e | E) [+ | -] decimal
			
 
				+         [PR['PR_LITERAL'],
			
 
				+          /^(?:0o[0-7]+|0x[\da-f]+|\d+(?:\.\d+)?(?:e[+\-]?\d+)?)/i,
			
 
				+          null, '0123456789']
			
 
				+        ],
			
 
				+        [
			
 
				+         // Haskell does not have a regular lexical grammar due to the nested
			
 
				+         // ncomment.
			
 
				+         // comment      ->    dashes [ any<symbol> {any}] newline
			
 
				+         // ncomment     ->    opencom ANYseq {ncomment ANYseq}closecom
			
 
				+         // dashes       ->    '--' {'-'}
			
 
				+         // opencom      ->    '{-'
			
 
				+         // closecom     ->    '-}'
			
 
				+         [PR['PR_COMMENT'],     /^(?:(?:--+(?:[^\r\n\x0C]*)?)|(?:\{-(?:[^-]|-+[^-\}])*-\}))/],
			
 
				+         // reservedid   ->    case | class | data | default | deriving | do
			
 
				+         //               |    else | if | import | in | infix | infixl | infixr
			
 
				+         //               |    instance | let | module | newtype | of | then
			
 
				+         //               |    type | where | _
			
 
				+         [PR['PR_KEYWORD'],     /^(?:case|class|data|default|deriving|do|else|if|import|in|infix|infixl|infixr|instance|let|module|newtype|of|then|type|where|_)(?=[^a-zA-Z0-9\']|$)/, null],
			
 
				+         // qvarid       ->    [ modid . ] varid
			
 
				+         // qconid       ->    [ modid . ] conid
			
 
				+         // varid        ->    (small {small | large | digit | ' })<reservedid>
			
 
				+         // conid        ->    large {small | large | digit | ' }
			
 
				+         // modid        ->    conid
			
 
				+         // small        ->    ascSmall | uniSmall | _
			
 
				+         // ascSmall     ->    a | b | ... | z
			
 
				+         // uniSmall     ->    any Unicode lowercase letter
			
 
				+         // large        ->    ascLarge | uniLarge
			
 
				+         // ascLarge     ->    A | B | ... | Z
			
 
				+         // uniLarge     ->    any uppercase or titlecase Unicode letter
			
 
				+         [PR['PR_PLAIN'],  /^(?:[A-Z][\w\']*\.)*[a-zA-Z][\w\']*/],
			
 
				+         // matches the symbol production
			
 
				+         [PR['PR_PUNCTUATION'], /^[^\t\n\x0B\x0C\r a-zA-Z0-9\'\"]+/]
			
 
				+        ]),
			
 
				+    ['hs']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-lisp.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-lisp.js
@@ -0,0 +1,94 @@
 
				+// Copyright (C) 2008 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for Common Lisp and related languages.
			
 
				+ *
			
 
				+ *
			
 
				+ * To use, include prettify.js and this file in your HTML page.
			
 
				+ * Then put your code in an HTML tag like
			
 
				+ *      <pre class="prettyprint lang-lisp">(my lisp code)</pre>
			
 
				+ * The lang-cl class identifies the language as common lisp.
			
 
				+ * This file supports the following language extensions:
			
 
				+ *     lang-cl - Common Lisp
			
 
				+ *     lang-el - Emacs Lisp
			
 
				+ *     lang-lisp - Lisp
			
 
				+ *     lang-scm - Scheme
			
 
				+ *     lang-lsp - FAT 8.3 filename version of lang-lisp.
			
 
				+ *
			
 
				+ *
			
 
				+ * I used http://www.devincook.com/goldparser/doc/meta-language/grammar-LISP.htm
			
 
				+ * as the basis, but added line comments that start with ; and changed the atom
			
 
				+ * production to disallow unquoted semicolons.
			
 
				+ *
			
 
				+ * "Name"    = 'LISP'
			
 
				+ * "Author"  = 'John McCarthy'
			
 
				+ * "Version" = 'Minimal'
			
 
				+ * "About"   = 'LISP is an abstract language that organizes ALL'
			
 
				+ *           | 'data around "lists".'
			
 
				+ *
			
 
				+ * "Start Symbol" = [s-Expression]
			
 
				+ *
			
 
				+ * {Atom Char}   = {Printable} - {Whitespace} - [()"\'']
			
 
				+ *
			
 
				+ * Atom = ( {Atom Char} | '\'{Printable} )+
			
 
				+ *
			
 
				+ * [s-Expression] ::= [Quote] Atom
			
 
				+ *                  | [Quote] '(' [Series] ')'
			
 
				+ *                  | [Quote] '(' [s-Expression] '.' [s-Expression] ')'
			
 
				+ *
			
 
				+ * [Series] ::= [s-Expression] [Series]
			
 
				+ *            |
			
 
				+ *
			
 
				+ * [Quote]  ::= ''      !Quote = do not evaluate
			
 
				+ *            |
			
 
				+ *
			
 
				+ *
			
 
				+ * I used <a href="http://gigamonkeys.com/book/">Practical Common Lisp</a> as
			
 
				+ * the basis for the reserved word list.
			
 
				+ *
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         ['opn',             /^\(+/, null, '('],
			
 
				+         ['clo',             /^\)+/, null, ')'],
			
 
				+         // A line comment that starts with ;
			
 
				+         [PR['PR_COMMENT'],     /^;[^\r\n]*/, null, ';'],
			
 
				+         // Whitespace
			
 
				+         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
			
 
				+         // A double quoted, possibly multi-line, string.
			
 
				+         [PR['PR_STRING'],      /^\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)/, null, '"']
			
 
				+        ],
			
 
				+        [
			
 
				+         [PR['PR_KEYWORD'],     /^(?:block|c[ad]+r|catch|con[ds]|def(?:ine|un)|do|eq|eql|equal|equalp|eval-when|flet|format|go|if|labels|lambda|let|load-time-value|locally|macrolet|multiple-value-call|nil|progn|progv|quote|require|return-from|setq|symbol-macrolet|t|tagbody|the|throw|unwind)\b/, null],
			
 
				+         [PR['PR_LITERAL'],
			
 
				+          /^[+\-]?(?:[0#]x[0-9a-f]+|\d+\/\d+|(?:\.\d+|\d+(?:\.\d*)?)(?:[ed][+\-]?\d+)?)/i],
			
 
				+         // A single quote possibly followed by a word that optionally ends with
			
 
				+         // = ! or ?.
			
 
				+         [PR['PR_LITERAL'],
			
 
				+          /^\'(?:-*(?:\w|\\[\x21-\x7e])(?:[\w-]*|\\[\x21-\x7e])[=!?]?)?/],
			
 
				+         // A word that optionally ends with = ! or ?.
			
 
				+         [PR['PR_PLAIN'],
			
 
				+          /^-*(?:[a-z_]|\\[\x21-\x7e])(?:[\w-]*|\\[\x21-\x7e])[=!?]?/i],
			
 
				+         // A printable non-space non-special character
			
 
				+         [PR['PR_PUNCTUATION'], /^[^\w\t\n\r \xA0()\"\\\';]+/]
			
 
				+        ]),
			
 
				+    ['cl', 'el', 'lisp', 'lsp', 'scm', 'ss', 'rkt']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-lua.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-lua.js
@@ -0,0 +1,59 @@
 
				+// Copyright (C) 2008 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for Lua.
			
 
				+ *
			
 
				+ *
			
 
				+ * To use, include prettify.js and this file in your HTML page.
			
 
				+ * Then put your code in an HTML tag like
			
 
				+ *      <pre class="prettyprint lang-lua">(my Lua code)</pre>
			
 
				+ *
			
 
				+ *
			
 
				+ * I used http://www.lua.org/manual/5.1/manual.html#2.1
			
 
				+ * Because of the long-bracket concept used in strings and comments, Lua does
			
 
				+ * not have a regular lexical grammar, but luckily it fits within the space
			
 
				+ * of irregular grammars supported by javascript regular expressions.
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // Whitespace
			
 
				+         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
			
 
				+         // A double or single quoted, possibly multi-line, string.
			
 
				+         [PR['PR_STRING'],      /^(?:\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)|\'(?:[^\'\\]|\\[\s\S])*(?:\'|$))/, null, '"\'']
			
 
				+        ],
			
 
				+        [
			
 
				+         // A comment is either a line comment that starts with two dashes, or
			
 
				+         // two dashes preceding a long bracketed block.
			
 
				+         [PR['PR_COMMENT'], /^--(?:\[(=*)\[[\s\S]*?(?:\]\1\]|$)|[^\r\n]*)/],
			
 
				+         // A long bracketed block not preceded by -- is a string.
			
 
				+         [PR['PR_STRING'],  /^\[(=*)\[[\s\S]*?(?:\]\1\]|$)/],
			
 
				+         [PR['PR_KEYWORD'], /^(?:and|break|do|else|elseif|end|false|for|function|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/, null],
			
 
				+         // A number is a hex integer literal, a decimal real literal, or in
			
 
				+         // scientific notation.
			
 
				+         [PR['PR_LITERAL'],
			
 
				+          /^[+-]?(?:0x[\da-f]+|(?:(?:\.\d+|\d+(?:\.\d*)?)(?:e[+\-]?\d+)?))/i],
			
 
				+         // An identifier
			
 
				+         [PR['PR_PLAIN'], /^[a-z_]\w*/i],
			
 
				+         // A run of punctuation
			
 
				+         [PR['PR_PUNCTUATION'], /^[^\w\t\n\r \xA0][^\w\t\n\r \xA0\"\'\-\+=]*/]
			
 
				+        ]),
			
 
				+    ['lua']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-ml.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-ml.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-n.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-n.js
@@ -0,0 +1,64 @@
 
				+// Copyright (C) 2011 Zimin A.V.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for the Nemerle language.
			
 
				+ * http://nemerle.org
			
 
				+ * @author Zimin A.V.
			
 
				+ */
			
 
				+(function () {
			
 
				+  var keywords = 'abstract|and|as|base|catch|class|def|delegate|enum|event|extern|false|finally|'
			
 
				+         + 'fun|implements|interface|internal|is|macro|match|matches|module|mutable|namespace|new|'
			
 
				+         + 'null|out|override|params|partial|private|protected|public|ref|sealed|static|struct|'
			
 
				+         + 'syntax|this|throw|true|try|type|typeof|using|variant|virtual|volatile|when|where|with|'
			
 
				+         + 'assert|assert2|async|break|checked|continue|do|else|ensures|for|foreach|if|late|lock|new|nolate|'
			
 
				+         + 'otherwise|regexp|repeat|requires|return|surroundwith|unchecked|unless|using|while|yield';
			
 
				+
			
 
				+  PR['registerLangHandler'](PR['createSimpleLexer'](
			
 
				+      // shortcutStylePatterns
			
 
				+      [
			
 
				+        [PR['PR_STRING'], /^(?:\'(?:[^\\\'\r\n]|\\.)*\'|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/, null, '"'],
			
 
				+        [PR['PR_COMMENT'], /^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\r\n]*)/, null, '#'],
			
 
				+        [PR['PR_PLAIN'], /^\s+/, null, ' \r\n\t\xA0']
			
 
				+      ],
			
 
				+      // fallthroughStylePatterns
			
 
				+      [
			
 
				+        [PR['PR_STRING'], /^@\"(?:[^\"]|\"\")*(?:\"|$)/, null],
			
 
				+        [PR['PR_STRING'], /^<#(?:[^#>])*(?:#>|$)/, null],
			
 
				+        [PR['PR_STRING'], /^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/, null],
			
 
				+        [PR['PR_COMMENT'], /^\/\/[^\r\n]*/, null],
			
 
				+        [PR['PR_COMMENT'], /^\/\*[\s\S]*?(?:\*\/|$)/, null],
			
 
				+        [PR['PR_KEYWORD'], new RegExp('^(?:' + keywords + ')\\b'), null],
			
 
				+        [PR['PR_TYPE'], /^(?:array|bool|byte|char|decimal|double|float|int|list|long|object|sbyte|short|string|ulong|uint|ufloat|ulong|ushort|void)\b/, null],
			
 
				+        [PR['PR_LITERAL'], /^@[a-z_$][a-z_$@0-9]*/i, null],
			
 
				+        [PR['PR_TYPE'], /^@[A-Z]+[a-z][A-Za-z_$@0-9]*/, null],
			
 
				+        [PR['PR_PLAIN'], /^'?[A-Za-z_$][a-z_$@0-9]*/i, null],
			
 
				+        [PR['PR_LITERAL'], new RegExp(
			
 
				+             '^(?:'
			
 
				+  // A hex number
			
 
				+             + '0x[a-f0-9]+'
			
 
				+  // or an octal or decimal number,
			
 
				+             + '|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)'
			
 
				+  // possibly in scientific notation
			
 
				+             + '(?:e[+\\-]?\\d+)?'
			
 
				+             + ')'
			
 
				+  // with an optional modifier like UL for unsigned long
			
 
				+             + '[a-z]*', 'i'), null, '0123456789'],
			
 
				+
			
 
				+        [PR['PR_PUNCTUATION'], /^.[^\s\w\.$@\'\"\`\/\#]*/, null]
			
 
				+      ]),
			
 
				+      ['n', 'nemerle']);
			
 
				+})();
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-proto.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-proto.js
@@ -0,0 +1,35 @@
 
				+// Copyright (C) 2006 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for Protocol Buffers as described at
			
 
				+ * http://code.google.com/p/protobuf/.
			
 
				+ *
			
 
				+ * Based on the lexical grammar at
			
 
				+ * http://research.microsoft.com/fsharp/manual/spec2.aspx#_Toc202383715
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](PR['sourceDecorator']({
			
 
				+        'keywords': (
			
 
				+            'bytes,default,double,enum,extend,extensions,false,'
			
 
				+            + 'group,import,max,message,option,'
			
 
				+            + 'optional,package,repeated,required,returns,rpc,service,'
			
 
				+            + 'syntax,to,true'),
			
 
				+        'types': /^(bool|(double|s?fixed|[su]?int)(32|64)|float|string)\b/,
			
 
				+        'cStyleComments': true
			
 
				+      }), ['proto']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-scala.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-scala.js
@@ -0,0 +1,54 @@
 
				+// Copyright (C) 2010 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for Scala.
			
 
				+ *
			
 
				+ * Derived from http://lampsvn.epfl.ch/svn-repos/scala/scala-documentation/trunk/src/reference/SyntaxSummary.tex
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // Whitespace
			
 
				+         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
			
 
				+         // A double or single quoted string 
			
 
				+          // or a triple double-quoted multi-line string.
			
 
				+         [PR['PR_STRING'],
			
 
				+          /^(?:"(?:(?:""(?:""?(?!")|[^\\"]|\\.)*"{0,3})|(?:[^"\r\n\\]|\\.)*"?))/,
			
 
				+          null, '"'],
			
 
				+         [PR['PR_LITERAL'],     /^`(?:[^\r\n\\`]|\\.)*`?/, null, '`'],
			
 
				+         [PR['PR_PUNCTUATION'], /^[!#%&()*+,\-:;<=>?@\[\\\]^{|}~]+/, null,
			
 
				+          '!#%&()*+,-:;<=>?@[\\]^{|}~']
			
 
				+        ],
			
 
				+        [
			
 
				+         // A symbol literal is a single quote followed by an identifier with no
			
 
				+         // single quote following
			
 
				+         // A character literal has single quotes on either side
			
 
				+         [PR['PR_STRING'],      /^'(?:[^\r\n\\']|\\(?:'|[^\r\n']+))'/],
			
 
				+         [PR['PR_LITERAL'],     /^'[a-zA-Z_$][\w$]*(?!['$\w])/],
			
 
				+         [PR['PR_KEYWORD'],     /^(?:abstract|case|catch|class|def|do|else|extends|final|finally|for|forSome|if|implicit|import|lazy|match|new|object|override|package|private|protected|requires|return|sealed|super|throw|trait|try|type|val|var|while|with|yield)\b/],
			
 
				+         [PR['PR_LITERAL'],     /^(?:true|false|null|this)\b/],
			
 
				+         [PR['PR_LITERAL'],     /^(?:(?:0(?:[0-7]+|X[0-9A-F]+))L?|(?:(?:0|[1-9][0-9]*)(?:(?:\.[0-9]+)?(?:E[+\-]?[0-9]+)?F?|L?))|\\.[0-9]+(?:E[+\-]?[0-9]+)?F?)/i],
			
 
				+         // Treat upper camel case identifiers as types.
			
 
				+         [PR['PR_TYPE'],        /^[$_]*[A-Z][_$A-Z0-9]*[a-z][\w$]*/],
			
 
				+         [PR['PR_PLAIN'],       /^[$a-zA-Z_][\w$]*/],
			
 
				+         [PR['PR_COMMENT'],     /^\/(?:\/.*|\*(?:\/|\**[^*/])*(?:\*+\/?)?)/],
			
 
				+         [PR['PR_PUNCTUATION'], /^(?:\.+|\/)/]
			
 
				+        ]),
			
 
				+    ['scala']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-sql.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-sql.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-tex.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-tex.js
@@ -0,0 +1,46 @@
 
				+// Copyright (C) 2011 Martin S.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Support for tex highlighting as discussed on
			
 
				+ * <a href="http://meta.tex.stackexchange.com/questions/872/text-immediate-following-double-backslashes-is-highlighted-as-macro-inside-a-code/876#876">meta.tex.stackexchange.com</a>.
			
 
				+ *
			
 
				+ * @author Martin S.
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // whitespace
			
 
				+         [PR['PR_PLAIN'],   /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
			
 
				+         // all comments begin with '%'
			
 
				+         [PR['PR_COMMENT'], /^%[^\r\n]*/, null, '%']
			
 
				+        ],
			
 
				+        [
			
 
				+         //[PR['PR_DECLARATION'], /^\\([egx]?def|(new|renew|provide)(command|environment))\b/],
			
 
				+         // any command starting with a \ and contains
			
 
				+         // either only letters (a-z,A-Z), '@' (internal macros)
			
 
				+         [PR['PR_KEYWORD'], /^\\[a-zA-Z@]+/],
			
 
				+         // or contains only one character
			
 
				+         [PR['PR_KEYWORD'], /^\\./],
			
 
				+         // Highlight dollar for math mode and ampersam for tabular
			
 
				+         [PR['PR_TYPE'],    /^[$&]/],
			
 
				+         // numeric measurement values with attached units
			
 
				+         [PR['PR_LITERAL'],
			
 
				+          /[+-]?(?:\.\d+|\d+(?:\.\d*)?)(cm|em|ex|in|pc|pt|bp|mm)/i],
			
 
				+         // punctuation usually occurring within commands
			
 
				+         [PR['PR_PUNCTUATION'], /^[{}()\[\]=]+/]
			
 
				+        ]),
			
 
				+    ['latex', 'tex']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-vb.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-vb.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-vhdl.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-vhdl.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-wiki.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-wiki.js
@@ -0,0 +1,53 @@
 
				+// Copyright (C) 2009 Google Inc.
			
 
				+//
			
 
				+// Licensed under the Apache License, Version 2.0 (the "License");
			
 
				+// you may not use this file except in compliance with the License.
			
 
				+// You may obtain a copy of the License at
			
 
				+//
			
 
				+//      http://www.apache.org/licenses/LICENSE-2.0
			
 
				+//
			
 
				+// Unless required by applicable law or agreed to in writing, software
			
 
				+// distributed under the License is distributed on an "AS IS" BASIS,
			
 
				+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			
 
				+// See the License for the specific language governing permissions and
			
 
				+// limitations under the License.
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for Wiki pages.
			
 
				+ *
			
 
				+ * Based on WikiSyntax at http://code.google.com/p/support/wiki/WikiSyntax
			
 
				+ *
			
 
				+ * @author mikesamuel@gmail.com
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer'](
			
 
				+        [
			
 
				+         // Whitespace
			
 
				+         [PR['PR_PLAIN'],       /^[\t \xA0a-gi-z0-9]+/, null,
			
 
				+          '\t \xA0abcdefgijklmnopqrstuvwxyz0123456789'],
			
 
				+         // Wiki formatting
			
 
				+         [PR['PR_PUNCTUATION'], /^[=*~\^\[\]]+/, null, '=*~^[]']
			
 
				+        ],
			
 
				+        [
			
 
				+         // Meta-info like #summary, #labels, etc.
			
 
				+         ['lang-wiki.meta',  /(?:^^|\r\n?|\n)(#[a-z]+)\b/],
			
 
				+         // A WikiWord
			
 
				+         [PR['PR_LITERAL'],     /^(?:[A-Z][a-z][a-z0-9]+[A-Z][a-z][a-zA-Z0-9]+)\b/
			
 
				+          ],
			
 
				+         // A preformatted block in an unknown language
			
 
				+         ['lang-',           /^\{\{\{([\s\S]+?)\}\}\}/],
			
 
				+         // A block of source code in an unknown language
			
 
				+         ['lang-',           /^`([^\r\n`]+)`/],
			
 
				+         // An inline URL.
			
 
				+         [PR['PR_STRING'],
			
 
				+          /^https?:\/\/[^\/?#\s]*(?:\/[^?#\s]*)?(?:\?[^#\s]*)?(?:#\S*)?/i],
			
 
				+         [PR['PR_PLAIN'],       /^(?:\r\n|[\s\S])[^#=*~^A-Zh\{`\[\r\n]*/]
			
 
				+        ]),
			
 
				+    ['wiki']);
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+    PR['createSimpleLexer']([[PR['PR_KEYWORD'], /^#[a-z]+/i, null, '#']], []),
			
 
				+    ['wiki.meta']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-xq.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-xq.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-yaml.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/lang-yaml.js
@@ -0,0 +1,27 @@
 
				+// Contributed by ribrdb @ code.google.com
			
 
				+
			
 
				+/**
			
 
				+ * @fileoverview
			
 
				+ * Registers a language handler for YAML.
			
 
				+ *
			
 
				+ * @author ribrdb
			
 
				+ */
			
 
				+
			
 
				+PR['registerLangHandler'](
			
 
				+  PR['createSimpleLexer'](
			
 
				+    [
			
 
				+      [PR['PR_PUNCTUATION'], /^[:|>?]+/, null, ':|>?'],
			
 
				+      [PR['PR_DECLARATION'],  /^%(?:YAML|TAG)[^#\r\n]+/, null, '%'],
			
 
				+      [PR['PR_TYPE'], /^[&]\S+/, null, '&'],
			
 
				+      [PR['PR_TYPE'], /^!\S*/, null, '!'],
			
 
				+      [PR['PR_STRING'], /^"(?:[^\\"]|\\.)*(?:"|$)/, null, '"'],
			
 
				+      [PR['PR_STRING'], /^'(?:[^']|'')*(?:'|$)/, null, "'"],
			
 
				+      [PR['PR_COMMENT'], /^#[^\r\n]*/, null, '#'],
			
 
				+      [PR['PR_PLAIN'], /^\s+/, null, ' \t\r\n']
			
 
				+    ],
			
 
				+    [
			
 
				+      [PR['PR_DECLARATION'], /^(?:---|\.\.\.)(?:[\r\n]|$)/],
			
 
				+      [PR['PR_PUNCTUATION'], /^-/],
			
 
				+      [PR['PR_KEYWORD'], /^\w+:[ \r\n]/],
			
 
				+      [PR['PR_PLAIN'], /^\w+/]
			
 
				+    ]), ['yaml', 'yml']);
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/prettify.css
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/prettify.css
@@ -0,0 +1,52 @@
 
				+/* Pretty printing styles. Used with prettify.js. */
			
 
				+
			
 
				+/* SPAN elements with the classes below are added by prettyprint. */
			
 
				+.pln { color: #000 }  /* plain text */
			
 
				+
			
 
				+@media screen {
			
 
				+  .str { color: #080 }  /* string content */
			
 
				+  .kwd { color: #008 }  /* a keyword */
			
 
				+  .com { color: #800 }  /* a comment */
			
 
				+  .typ { color: #606 }  /* a type name */
			
 
				+  .lit { color: #066 }  /* a literal value */
			
 
				+  /* punctuation, lisp open bracket, lisp close bracket */
			
 
				+  .pun, .opn, .clo { color: #660 }
			
 
				+  .tag { color: #008 }  /* a markup tag name */
			
 
				+  .atn { color: #606 }  /* a markup attribute name */
			
 
				+  .atv { color: #080 }  /* a markup attribute value */
			
 
				+  .dec, .var { color: #606 }  /* a declaration; a variable name */
			
 
				+  .fun { color: red }  /* a function name */
			
 
				+}
			
 
				+
			
 
				+/* Use higher contrast and text-weight for printable form. */
			
 
				+@media print, projection {
			
 
				+  .str { color: #060 }
			
 
				+  .kwd { color: #006; font-weight: bold }
			
 
				+  .com { color: #600; font-style: italic }
			
 
				+  .typ { color: #404; font-weight: bold }
			
 
				+  .lit { color: #044 }
			
 
				+  .pun, .opn, .clo { color: #440 }
			
 
				+  .tag { color: #006; font-weight: bold }
			
 
				+  .atn { color: #404 }
			
 
				+  .atv { color: #060 }
			
 
				+}
			
 
				+
			
 
				+/* Put a border around prettyprinted code snippets. */
			
 
				+pre.prettyprint { padding: 2px; border: 1px solid #888 }
			
 
				+
			
 
				+/* Specify class=linenums on a pre to get line numbering */
			
 
				+ol.linenums { margin-top: 0; margin-bottom: 0 } /* IE indents via margin-left */
			
 
				+li.L0,
			
 
				+li.L1,
			
 
				+li.L2,
			
 
				+li.L3,
			
 
				+li.L5,
			
 
				+li.L6,
			
 
				+li.L7,
			
 
				+li.L8 { list-style-type: none }
			
 
				+/* Alternate shading for lines */
			
 
				+li.L1,
			
 
				+li.L3,
			
 
				+li.L5,
			
 
				+li.L7,
			
 
				+li.L9 { background: #eee }
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/prettify.js
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/src/prettify.js
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/demo.html
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/demo.html
@@ -0,0 +1,61 @@
 
				+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
			
 
				+<html><head>
			
 
				+<script src="../src/prettify.js"></script>
			
 
				+<script src="../src/lang-css.js"></script>
			
 
				+<style>
			
 
				+body { margin: 0; padding: 0 }
			
 
				+pre { margin: 0 }
			
 
				+</style>
			
 
				+</head>
			
 
				+<script>
			
 
				+// This page displays some code styled using a theme named in the
			
 
				+// query part of the URL.
			
 
				+var themeName = decodeURIComponent(document.location.search.replace(/^\?/, ''));
			
 
				+
			
 
				+// Call out to the parent so that it can resize the iframe once this
			
 
				+// document's body is loaded.
			
 
				+function adjustHeightInParent() {
			
 
				+  if (parent !== window) {
			
 
				+    try {
			
 
				+      var div = document.body.getElementsByTagName('div')[0];
			
 
				+      parent.adjustChildIframeSize(
			
 
				+          themeName, div.offsetWidth, div.offsetHeight);
			
 
				+    } catch (ex) {
			
 
				+      // Can happen when this page is opened in its own tab.
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+// Load the necessary CSS
			
 
				+(function () {
			
 
				+  document.title = 'Theme ' + themeName;
			
 
				+  // Load the stylesheet that we're demoing.
			
 
				+  var link = document.createElement('link');
			
 
				+  link.rel = 'stylesheet';
			
 
				+  link.type = 'text/css';
			
 
				+  link.href = themeName === 'default'
			
 
				+      ? '../src/prettify.css' : themeName + '.css';
			
 
				+  document.getElementsByTagName('head')[0].appendChild(link);
			
 
				+})();
			
 
				+</script>
			
 
				+
			
 
				+<body onload="prettyPrint(); adjustHeightInParent()">
			
 
				+<div style="width: 40em; display: inline-block">
			
 
				+<pre class="prettyprint lang-html linenums">
			
 
				+&lt;script type="text/javascript"&gt;
			
 
				+// Say hello world until the user starts questioning
			
 
				+// the meaningfulness of their existence.
			
 
				+function helloWorld(world) {
			
 
				+  for (var i = 42; --i &gt;= 0;) {
			
 
				+    alert('Hello ' + String(world));
			
 
				+  }
			
 
				+}
			
 
				+&lt;/script&gt;
			
 
				+&lt;style&gt;
			
 
				+p { color: pink }
			
 
				+b { color: blue }
			
 
				+u { color: "umber" }
			
 
				+&lt;/style&gt;
			
 
				+</pre>
			
 
				+</div>
			
 
				+</body></html>
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/desert.css
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/desert.css
@@ -0,0 +1,35 @@
 
				+/* desert scheme ported from vim to google prettify */
			
 
				+pre.prettyprint { display: block; background-color: #333 }
			
 
				+pre .nocode { background-color: none; color: #000 }
			
 
				+pre .str { color: #ffa0a0 } /* string  - pink */
			
 
				+pre .kwd { color: #f0e68c; font-weight: bold }
			
 
				+pre .com { color: #87ceeb } /* comment - skyblue */
			
 
				+pre .typ { color: #98fb98 } /* type    - lightgreen */
			
 
				+pre .lit { color: #cd5c5c } /* literal - darkred */
			
 
				+pre .pun { color: #fff }    /* punctuation */
			
 
				+pre .pln { color: #fff }    /* plaintext */
			
 
				+pre .tag { color: #f0e68c; font-weight: bold } /* html/xml tag    - lightyellow */
			
 
				+pre .atn { color: #bdb76b; font-weight: bold } /* attribute name  - khaki */
			
 
				+pre .atv { color: #ffa0a0 } /* attribute value - pink */
			
 
				+pre .dec { color: #98fb98 } /* decimal         - lightgreen */
			
 
				+
			
 
				+/* Specify class=linenums on a pre to get line numbering */
			
 
				+ol.linenums { margin-top: 0; margin-bottom: 0; color: #AEAEAE } /* IE indents via margin-left */
			
 
				+li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8 { list-style-type: none }
			
 
				+/* Alternate shading for lines */
			
 
				+li.L1,li.L3,li.L5,li.L7,li.L9 { }
			
 
				+
			
 
				+@media print {
			
 
				+  pre.prettyprint { background-color: none }
			
 
				+  pre .str, code .str { color: #060 }
			
 
				+  pre .kwd, code .kwd { color: #006; font-weight: bold }
			
 
				+  pre .com, code .com { color: #600; font-style: italic }
			
 
				+  pre .typ, code .typ { color: #404; font-weight: bold }
			
 
				+  pre .lit, code .lit { color: #044 }
			
 
				+  pre .pun, code .pun { color: #440 }
			
 
				+  pre .pln, code .pln { color: #000 }
			
 
				+  pre .tag, code .tag { color: #006; font-weight: bold }
			
 
				+  pre .atn, code .atn { color: #404 }
			
 
				+  pre .atv, code .atv { color: #060 }
			
 
				+}
			
 
				+
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/index.html
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/index.html
@@ -0,0 +1,88 @@
 
				+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
			
 
				+<html><head>
			
 
				+<title>Prettify Themes Gallery</title>
			
 
				+<style type="text/css">
			
 
				+iframe { width: 100%; border-style: none; margin: 0; padding: 0 }
			
 
				+</style>
			
 
				+<script>
			
 
				+var allThemes = [
			
 
				+  { name: 'default' },
			
 
				+  { name: 'desert',
			
 
				+    authorHtml: '<a href="http://code.google.com/u/@VhJeSlJYBhVMWgF7/">'
			
 
				+        + 'techto&hellip;@<\/a>' },
			
 
				+  { name: 'sunburst', authorHtml: 'David Leibovic' },
			
 
				+  { name: 'sons-of-obsidian',
			
 
				+    authorHtml: '<a href="http://CodeTunnel.com/blog/post/71'
			
 
				+        + '/google-code-prettify-obsidian-theme">Alex Ford<\/a>' },
			
 
				+];
			
 
				+
			
 
				+// Called by the demo.html frames loaded per theme to
			
 
				+// size the iframes properly and to allow them to tile
			
 
				+// the page nicely.
			
 
				+function adjustChildIframeSize(themeName, width, height) {
			
 
				+  if (typeof console != 'undefined') {
			
 
				+    try {
			
 
				+      console.log('adjusting ' + themeName + ' to ' + width + 'x' + height);
			
 
				+    } catch (ex) {
			
 
				+      // Don't bother logging log failure.
			
 
				+    }
			
 
				+  }
			
 
				+
			
 
				+  var container = document.getElementById(themeName).parentNode;
			
 
				+  container.style.width = (+width + 16) + 'px';
			
 
				+  container.style.display = 'inline-block';
			
 
				+  var iframe = container.getElementsByTagName('iframe')[0];
			
 
				+  iframe.style.height = (+height + 16) + 'px';
			
 
				+}
			
 
				+</script>
			
 
				+</head>
			
 
				+
			
 
				+<body>
			
 
				+<noscript>This page requires JavaScript</noscript>
			
 
				+
			
 
				+<h1>Gallery of themes for
			
 
				+<a href="http://code.google.com/p/google-code-prettify/">code prettify</a></h1>
			
 
				+<p>
			
 
				+Click on a theme name for a link to the file in revision control.
			
 
				+Print preview this page to see how the themes work on the printed page.
			
 
				+</p>
			
 
				+<script>(function () {
			
 
				+  // Produce an iframe per theme.
			
 
				+  // We pass the threme name to the iframe via its URI query, and
			
 
				+  // it loads prettify and the theme CSS, and calls back to this page
			
 
				+  // to resize the iframe.
			
 
				+  for (var i = 0, n = allThemes.length; i < n; ++i) {
			
 
				+    var theme = allThemes[i];
			
 
				+    if (!theme) { continue; }
			
 
				+    var iframe = document.createElement('iframe');
			
 
				+    iframe.name = theme.name;
			
 
				+    iframe.src = 'demo.html?' + encodeURIComponent(theme.name);
			
 
				+    var header = document.createElement('h2');
			
 
				+    header.id = theme.name;
			
 
				+    var linkToThemeSrc = document.createElement('a');
			
 
				+    linkToThemeSrc.href = (
			
 
				+        'http://code.google.com/p/google-code-prettify/source/browse/trunk/' +
			
 
				+        (theme.name === 'default'
			
 
				+         ? 'src/prettify.css'
			
 
				+         : 'styles/' + encodeURIComponent(theme.name) + '.css'));
			
 
				+    linkToThemeSrc.appendChild(document.createTextNode(
			
 
				+       theme.name.replace(/\b[a-z]/g,  // Capitalize first letter of each word
			
 
				+       function (letter) { return letter.toUpperCase(); })));
			
 
				+    header.appendChild(linkToThemeSrc);
			
 
				+
			
 
				+    var attribution;
			
 
				+    if (theme.authorHtml) {
			
 
				+      attribution = document.createElement('span');
			
 
				+      attribution.className = 'attribution';
			
 
				+      attribution.innerHTML = 'by ' + theme.authorHtml;
			
 
				+    }
			
 
				+
			
 
				+    var div = document.createElement('div');
			
 
				+    div.appendChild(header);
			
 
				+    if (attribution) { div.appendChild(attribution); }
			
 
				+    div.appendChild(iframe);
			
 
				+    document.body.appendChild(div);
			
 
				+  }
			
 
				+})()</script>
			
 
				+
			
 
				+</body></html>
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/sons-of-obsidian.css
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/sons-of-obsidian.css
@@ -0,0 +1,118 @@
 
				+/*
			
 
				+ * Derived from einaros's Sons of Obsidian theme at
			
 
				+ * http://studiostyl.es/schemes/son-of-obsidian by
			
 
				+ * Alex Ford of CodeTunnel:
			
 
				+ * http://CodeTunnel.com/blog/post/71/google-code-prettify-obsidian-theme
			
 
				+ */
			
 
				+
			
 
				+.str
			
 
				+{
			
 
				+    color: #EC7600;
			
 
				+}
			
 
				+.kwd
			
 
				+{
			
 
				+    color: #93C763;
			
 
				+}
			
 
				+.com
			
 
				+{
			
 
				+    color: #66747B;
			
 
				+}
			
 
				+.typ
			
 
				+{
			
 
				+    color: #678CB1;
			
 
				+}
			
 
				+.lit
			
 
				+{
			
 
				+    color: #FACD22;
			
 
				+}
			
 
				+.pun
			
 
				+{
			
 
				+    color: #F1F2F3;
			
 
				+}
			
 
				+.pln
			
 
				+{
			
 
				+    color: #F1F2F3;
			
 
				+}
			
 
				+.tag
			
 
				+{
			
 
				+    color: #8AC763;
			
 
				+}
			
 
				+.atn
			
 
				+{
			
 
				+    color: #E0E2E4;
			
 
				+}
			
 
				+.atv
			
 
				+{
			
 
				+    color: #EC7600;
			
 
				+}
			
 
				+.dec
			
 
				+{
			
 
				+    color: purple;
			
 
				+}
			
 
				+pre.prettyprint
			
 
				+{
			
 
				+    border: 0px solid #888;
			
 
				+}
			
 
				+ol.linenums
			
 
				+{
			
 
				+    margin-top: 0;
			
 
				+    margin-bottom: 0;
			
 
				+}
			
 
				+.prettyprint {
			
 
				+    background: #000;
			
 
				+}
			
 
				+li.L0, li.L1, li.L2, li.L3, li.L4, li.L5, li.L6, li.L7, li.L8, li.L9
			
 
				+{
			
 
				+    color: #555;
			
 
				+    list-style-type: decimal;
			
 
				+}
			
 
				+li.L1, li.L3, li.L5, li.L7, li.L9 {
			
 
				+    background: #111;
			
 
				+}
			
 
				+@media print
			
 
				+{
			
 
				+    .str
			
 
				+    {
			
 
				+        color: #060;
			
 
				+    }
			
 
				+    .kwd
			
 
				+    {
			
 
				+        color: #006;
			
 
				+        font-weight: bold;
			
 
				+    }
			
 
				+    .com
			
 
				+    {
			
 
				+        color: #600;
			
 
				+        font-style: italic;
			
 
				+    }
			
 
				+    .typ
			
 
				+    {
			
 
				+        color: #404;
			
 
				+        font-weight: bold;
			
 
				+    }
			
 
				+    .lit
			
 
				+    {
			
 
				+        color: #044;
			
 
				+    }
			
 
				+    .pun
			
 
				+    {
			
 
				+        color: #440;
			
 
				+    }
			
 
				+    .pln
			
 
				+    {
			
 
				+        color: #000;
			
 
				+    }
			
 
				+    .tag
			
 
				+    {
			
 
				+        color: #006;
			
 
				+        font-weight: bold;
			
 
				+    }
			
 
				+    .atn
			
 
				+    {
			
 
				+        color: #404;
			
 
				+    }
			
 
				+    .atv
			
 
				+    {
			
 
				+        color: #060;
			
 
				+    }
			
 
				+}
			
--- a/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/sunburst.css
+++ b/src/js/angularjs/docs/components/google-code-prettify-1.0.1/styles/sunburst.css
@@ -0,0 +1,51 @@
 
				+/* Pretty printing styles. Used with prettify.js. */
			
 
				+/* Vim sunburst theme by David Leibovic */
			
 
				+
			
 
				+pre .str, code .str { color: #65B042; } /* string  - green */
			
 
				+pre .kwd, code .kwd { color: #E28964; } /* keyword - dark pink */
			
 
				+pre .com, code .com { color: #AEAEAE; font-style: italic; } /* comment - gray */
			
 
				+pre .typ, code .typ { color: #89bdff; } /* type - light blue */
			
 
				+pre .lit, code .lit { color: #3387CC; } /* literal - blue */
			
 
				+pre .pun, code .pun { color: #fff; } /* punctuation - white */
			
 
				+pre .pln, code .pln { color: #fff; } /* plaintext - white */
			
 
				+pre .tag, code .tag { color: #89bdff; } /* html/xml tag    - light blue */
			
 
				+pre .atn, code .atn { color: #bdb76b; } /* html/xml attribute name  - khaki */
			
 
				+pre .atv, code .atv { color: #65B042; } /* html/xml attribute value - green */
			
 
				+pre .dec, code .dec { color: #3387CC; } /* decimal - blue */
			
 
				+
			
 
				+pre.prettyprint, code.prettyprint {
			
 
				+	background-color: #000;
			
 
				+	-moz-border-radius: 8px;
			
 
				+	-webkit-border-radius: 8px;
			
 
				+	-o-border-radius: 8px;
			
 
				+	-ms-border-radius: 8px;
			
 
				+	-khtml-border-radius: 8px;
			
 
				+	border-radius: 8px;
			
 
				+}
			
 
				+
			
 
				+pre.prettyprint {
			
 
				+	width: 95%;
			
 
				+	margin: 1em auto;
			
 
				+	padding: 1em;
			
 
				+	white-space: pre-wrap;
			
 
				+}
			
 
				+
			
 
				+
			
 
				+/* Specify class=linenums on a pre to get line numbering */
			
 
				+ol.linenums { margin-top: 0; margin-bottom: 0; color: #AEAEAE; } /* IE indents via margin-left */
			
 
				+li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8 { list-style-type: none }
			
 
				+/* Alternate shading for lines */
			
 
				+li.L1,li.L3,li.L5,li.L7,li.L9 { }
			
 
				+
			
 
				+@media print {
			
 
				+  pre .str, code .str { color: #060; }
			
 
				+  pre .kwd, code .kwd { color: #006; font-weight: bold; }
			
 
				+  pre .com, code .com { color: #600; font-style: italic; }
			
 
				+  pre .typ, code .typ { color: #404; font-weight: bold; }
			
 
				+  pre .lit, code .lit { color: #044; }
			
 
				+  pre .pun, code .pun { color: #440; }
			
 
				+  pre .pln, code .pln { color: #000; }
			
 
				+  pre .tag, code .tag { color: #006; font-weight: bold; }
			
 
				+  pre .atn, code .atn { color: #404; }
			
 
				+  pre .atv, code .atv { color: #060; }
			
 
				+}
			
--- a/src/js/angularjs/docs/components/jquery-2.1.1/jquery.js
+++ b/src/js/angularjs/docs/components/jquery-2.1.1/jquery.js
--- a/src/js/angularjs/docs/components/jquery-2.1.1/jquery.min.js
+++ b/src/js/angularjs/docs/components/jquery-2.1.1/jquery.min.js
--- a/src/js/angularjs/docs/components/lunr.js-0.4.2/lunr.js
+++ b/src/js/angularjs/docs/components/lunr.js-0.4.2/lunr.js
--- a/src/js/angularjs/docs/components/lunr.js-0.4.2/lunr.min.js
+++ b/src/js/angularjs/docs/components/lunr.js-0.4.2/lunr.min.js
--- a/src/js/angularjs/docs/components/lunr.js-0.4.2/server.js
+++ b/src/js/angularjs/docs/components/lunr.js-0.4.2/server.js
@@ -0,0 +1,45 @@
 
				+var http = require('http'),
			
 
				+    url = require('url'),
			
 
				+    join = require('path').join,
			
 
				+    exists = require('path').exists,
			
 
				+    extname = require('path').extname,
			
 
				+    join = require('path').join,
			
 
				+    fs = require('fs'),
			
 
				+    port = process.argv[2] || 3000
			
 
				+
			
 
				+var mime = {
			
 
				+    'html': 'text/html',
			
 
				+    'css': 'text/css',
			
 
				+    'js': 'application/javascript',
			
 
				+}
			
 
				+
			
 
				+http.createServer(function(req, res){
			
 
				+  console.log('  \033[90m%s \033[36m%s\033[m', req.method, req.url)
			
 
				+
			
 
				+  var pathname = url.parse(req.url).pathname,
			
 
				+      path = join(process.cwd(), pathname)
			
 
				+
			
 
				+  function notFound() {
			
 
				+    res.statusCode = 404
			
 
				+    res.end("404 Not Found\n")
			
 
				+  }
			
 
				+
			
 
				+  function error(err) {
			
 
				+    res.statusCode = 500
			
 
				+    res.end(err.message + "\n")
			
 
				+  }
			
 
				+
			
 
				+  exists(path, function(exists){
			
 
				+    if (!exists) return notFound()
			
 
				+
			
 
				+    fs.stat(path, function(err, stat){
			
 
				+      if (err) return error()
			
 
				+      if (stat.isDirectory()) path = join(path, 'index.html')
			
 
				+      res.setHeader('Cache-Control', 'no-cache')
			
 
				+      res.setHeader('Content-Type', mime[path.split('.').slice(-1)] || 'application/octet-stream')
			
 
				+      fs.createReadStream(path).pipe(res)
			
 
				+    })
			
 
				+  })
			
 
				+}).listen(port)
			
 
				+
			
 
				+console.log('\n  Server listening on %d\n', port)
			
--- a/src/js/angularjs/docs/components/marked-0.3.2/index.js
+++ b/src/js/angularjs/docs/components/marked-0.3.2/index.js
@@ -0,0 +1 @@
 
				+module.exports = require('./lib/marked');
			
--- a/src/js/angularjs/docs/components/marked-0.3.2/lib/marked.js
+++ b/src/js/angularjs/docs/components/marked-0.3.2/lib/marked.js
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/README.md
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/README.md
@@ -0,0 +1,11 @@
 
				+# Open Sans @font-face kit
			
 
				+
			
 
				+Installable via [Bower](http://twitter.github.com/bower/):
			
 
				+```
			
 
				+bower install open-sans-fontface
			
 
				+```
			
 
				+
			
 
				+## Demo
			
 
				+__Our repository:__ [http://fontfacekit.github.com/open-sans](http://fontfacekit.github.com/open-sans)
			
 
				+
			
 
				+__Google Web Fonts:__ [http://www.google.com/fonts/specimen/Open+Sans](http://www.google.com/fonts/specimen/Open+Sans)
			
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/bower.json
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/bower.json
@@ -0,0 +1,22 @@
 
				+{
			
 
				+  "name": "open-sans-fontface",
			
 
				+  "version": "1.0.4",
			
 
				+  "main": "./css/open-sans.css",
			
 
				+  "homepage": "https://github.com/FontFaceKit/open-sans",
			
 
				+  "authors": [
			
 
				+    "Gustavo Henke <gustavo@injoin.com.br>",
			
 
				+    "Martin Domke <martin.domke@gateprotect.com>"
			
 
				+  ],
			
 
				+  "description": "The Open Sans fontface",
			
 
				+  "keywords": [
			
 
				+    "font"
			
 
				+  ],
			
 
				+  "license": "Apache License version 2.0",
			
 
				+  "ignore": [
			
 
				+    "**/.*",
			
 
				+    "node_modules",
			
 
				+    "bower_components",
			
 
				+    "test",
			
 
				+    "tests"
			
 
				+  ]
			
 
				+}
			
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.eot
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.eot
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.svg
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.svg
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.ttf
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.ttf
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.woff
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/Bold/OpenSans-Bold.woff
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.eot
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.eot
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.svg
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.svg
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.ttf
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.ttf
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.woff
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/BoldItalic/OpenSans-BoldItalic.woff
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/ExtraBold/OpenSans-ExtraBold.eot
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/ExtraBold/OpenSans-ExtraBold.eot
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/ExtraBold/OpenSans-ExtraBold.svg
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/ExtraBold/OpenSans-ExtraBold.svg
--- a/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/ExtraBold/OpenSans-ExtraBold.ttf
+++ b/src/js/angularjs/docs/components/open-sans-fontface-1.0.4/fonts/ExtraBold/OpenSans-ExtraBold.ttf