@angular-wave/angular.ts 0.0.66 → 0.0.68

package/src/directive/show-hide/show-hide.js

@@ -1,119 +1,12 @@
 const NG_HIDE_CLASS = "ng-hide";
 const NG_HIDE_IN_PROGRESS_CLASS = "ng-hide-animate";
-/**
- * @ngdoc directive
- * @name ngShow
- * @multiElement
- *
- * @description
- * The `ngShow` directive shows or hides the given HTML element based on the expression provided to
- * the `ngShow` attribute.
- *
- * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
- * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
- * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
- * {@link ng.directive:ngCsp ngCsp}).
- *
- * ```html
- * <!-- when $scope.myValue is truthy (element is visible) -->
- * <div ng-show="myValue"></div>
- *
- * <!-- when $scope.myValue is falsy (element is hidden) -->
- * <div ng-show="myValue" class="ng-hide"></div>
- * ```
- *
- * When the `ngShow` expression evaluates to a falsy value then the `.ng-hide` CSS class is added
- * to the class attribute on the element causing it to become hidden. When truthy, the `.ng-hide`
- * CSS class is removed from the element causing the element not to appear hidden.
- *
- * ## Why is `!important` used?
- *
- * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
- * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
- * simple as changing the display style on a HTML list item would make hidden elements appear
- * visible. This also becomes a bigger issue when dealing with CSS frameworks.
- *
- * By using `!important`, the show and hide behavior will work as expected despite any clash between
- * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
- * developer chooses to override the styling to change how to hide an element then it is just a
- * matter of using `!important` in their own CSS code.
- *
- * ### Overriding `.ng-hide`
- *
- * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
- * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
- * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
- * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
- *
- * ```css
- * .ng-hide:not(.ng-hide-animate) {
- *   /&#42; These are just alternative ways of hiding an element &#42;/
- *   display: block!important;
- *   position: absolute;
- *   top: -9999px;
- *   left: -9999px;
- * }
- * ```
- *
- * By default you don't need to override anything in CSS and the animations will work around the
- * display style.
- *
- * @animations
- * | Animation                                           | Occurs                                                                                                        |
- * |-----------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
- * | {@link $animate#addClass addClass} `.ng-hide`       | After the `ngShow` expression evaluates to a non truthy value and just before the contents are set to hidden. |
- * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngShow` expression evaluates to a truthy value and just before contents are set to visible.        |
- *
- * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
- * directive expression is true and false. This system works like the animation system present with
- * `ngClass` except that you must also include the `!important` flag to override the display
- * property so that the elements are not actually hidden during the animation.
- *
- * ```css
- * /&#42; A working example can be found at the bottom of this page. &#42;/
- * .my-element.ng-hide-add, .my-element.ng-hide-remove {
- *   transition: all 0.5s linear;
- * }
- *
- * .my-element.ng-hide-add { ... }
- * .my-element.ng-hide-add.ng-hide-add-active { ... }
- * .my-element.ng-hide-remove { ... }
- * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
- * ```
- *
- * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
- * to block during animation states - ngAnimate will automatically handle the style toggling for you.
- *
- * @element ANY
- * @param {string} ngShow If the {@link guide/expression expression} is truthy/falsy then the
- *                            element is shown/hidden respectively.
- *
- * @example
- * A simple example, animating the element's opacity:
 
-* <hr />
- *
- * @knownIssue
- *
- * ### Flickering when using ngShow to toggle between elements
- *
- * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
- * happen that both the element to show and the element to hide are visible for a very short time.
- *
- * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
- * are defined for {@link ngShow} / {@link ngHide}.
- * 
- * There are several way to mitigate this problem:
- *
- * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
- * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
- * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
- * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
- * - Define an animation on the affected elements.
+ngShowDirective.$inject = ["$animate"];
+/**
+ * @returns {import('../../types').Directive}
  */
-export const ngShowDirective = [
-  "$animate",
-  ($animate) => ({
+export function ngShowDirective($animate) {
+  return {
     restrict: "A",
     multiElement: true,
     link(scope, element, attr) {
@@ -127,119 +20,15 @@ export const ngShowDirective = [
         });
       });
     },
-  }),
-];
+  };
+}
 
+ngHideDirective.$inject = ["$animate"];
 /**
- * @ngdoc directive
- * @name ngHide
- * @multiElement
- *
- * @description
- * The `ngHide` directive shows or hides the given HTML element based on the expression provided to
- * the `ngHide` attribute.
- *
- * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
- * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
- * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
- * {@link ng.directive:ngCsp ngCsp}).
- *
- * ```html
- * <!-- when $scope.myValue is truthy (element is hidden) -->
- * <div ng-hide="myValue" class="ng-hide"></div>
- *
- * <!-- when $scope.myValue is falsy (element is visible) -->
- * <div ng-hide="myValue"></div>
- * ```
- *
- * When the `ngHide` expression evaluates to a truthy value then the `.ng-hide` CSS class is added
- * to the class attribute on the element causing it to become hidden. When falsy, the `.ng-hide`
- * CSS class is removed from the element causing the element not to appear hidden.
- *
- * ## Why is `!important` used?
- *
- * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
- * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
- * simple as changing the display style on a HTML list item would make hidden elements appear
- * visible. This also becomes a bigger issue when dealing with CSS frameworks.
- *
- * By using `!important`, the show and hide behavior will work as expected despite any clash between
- * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
- * developer chooses to override the styling to change how to hide an element then it is just a
- * matter of using `!important` in their own CSS code.
- *
- * ### Overriding `.ng-hide`
- *
- * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
- * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
- * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
- * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
- *
- * ```css
- * .ng-hide:not(.ng-hide-animate) {
- *   /&#42; These are just alternative ways of hiding an element &#42;/
- *   display: block!important;
- *   position: absolute;
- *   top: -9999px;
- *   left: -9999px;
- * }
- * ```
- *
- * By default you don't need to override in CSS anything and the animations will work around the
- * display style.
- *
- * @animations
- * | Animation                                           | Occurs                                                                                                     |
- * |-----------------------------------------------------|------------------------------------------------------------------------------------------------------------|
- * | {@link $animate#addClass addClass} `.ng-hide`       | After the `ngHide` expression evaluates to a truthy value and just before the contents are set to hidden.  |
- * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngHide` expression evaluates to a non truthy value and just before contents are set to visible. |
- *
- * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
- * directive expression is true and false. This system works like the animation system present with
- * `ngClass` except that you must also include the `!important` flag to override the display
- * property so that the elements are not actually hidden during the animation.
- *
- * ```css
- * /&#42; A working example can be found at the bottom of this page. &#42;/
- * .my-element.ng-hide-add, .my-element.ng-hide-remove {
- *   transition: all 0.5s linear;
- * }
- *
- * .my-element.ng-hide-add { ... }
- * .my-element.ng-hide-add.ng-hide-add-active { ... }
- * .my-element.ng-hide-remove { ... }
- * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
- * ```
- *
- * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
- * to block during animation states - ngAnimate will automatically handle the style toggling for you.
- *
- * @element ANY
- * @param {string} ngHide If the {@link guide/expression expression} is truthy/falsy then the
- *                            element is hidden/shown respectively.
- *
- * @knownIssue
- *
- * ### Flickering when using ngHide to toggle between elements
- *
- * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
- * happen that both the element to show and the element to hide are visible for a very short time.
- *
- * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
- * are defined for {@link ngShow} / {@link ngHide}. Internet Explorer is affected more often than
- * other browsers.
- *
- * There are several way to mitigate this problem:
- *
- * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
- * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
- * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
- * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
- * - Define an animation on the affected elements.
+ * @returns {import('../../types').Directive}
  */
-export const ngHideDirective = [
-  "$animate",
-  ($animate) => ({
+export function ngHideDirective($animate) {
+  return {
     restrict: "A",
     multiElement: true,
     link(scope, element, attr) {
@@ -251,5 +40,5 @@ export const ngHideDirective = [
         });
       });
     },
-  }),
-];
+  };
+}

package/src/directive/show-hide/show-hide.md

@@ -0,0 +1,257 @@
+/\*\*
+
+- @ngdoc directive
+- @name ngShow
+- @multiElement
+-
+- @description
+- The `ngShow` directive shows or hides the given HTML element based on the expression provided to
+- the `ngShow` attribute.
+-
+- The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+- The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
+- `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
+- {@link ng.directive:ngCsp ngCsp}).
+-
+- ```html
+
+  ```
+
+- <!-- when $scope.myValue is truthy (element is visible) -->
+- <div ng-show="myValue"></div>
+-
+- <!-- when $scope.myValue is falsy (element is hidden) -->
+- <div ng-show="myValue" class="ng-hide"></div>
+- ```
+
+  ```
+
+-
+- When the `ngShow` expression evaluates to a falsy value then the `.ng-hide` CSS class is added
+- to the class attribute on the element causing it to become hidden. When truthy, the `.ng-hide`
+- CSS class is removed from the element causing the element not to appear hidden.
+-
+- ## Why is `!important` used?
+-
+- You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
+- `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
+- simple as changing the display style on a HTML list item would make hidden elements appear
+- visible. This also becomes a bigger issue when dealing with CSS frameworks.
+-
+- By using `!important`, the show and hide behavior will work as expected despite any clash between
+- CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
+- developer chooses to override the styling to change how to hide an element then it is just a
+- matter of using `!important` in their own CSS code.
+-
+- ### Overriding `.ng-hide`
+-
+- By default, the `.ng-hide` class will style the element with `display: none !important`. If you
+- wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
+- the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
+- `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
+-
+- ```css
+
+  ```
+
+- .ng-hide:not(.ng-hide-animate) {
+- /\* These are just alternative ways of hiding an element \*/
+- display: block!important;
+- position: absolute;
+- top: -9999px;
+- left: -9999px;
+- }
+- ```
+
+  ```
+
+-
+- By default you don't need to override anything in CSS and the animations will work around the
+- display style.
+-
+- @animations
+- | Animation | Occurs |
+- |-----------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
+- | {@link $animate#addClass addClass} `.ng-hide` | After the `ngShow` expression evaluates to a non truthy value and just before the contents are set to hidden. |
+- | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngShow` expression evaluates to a truthy value and just before contents are set to visible. |
+-
+- Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
+- directive expression is true and false. This system works like the animation system present with
+- `ngClass` except that you must also include the `!important` flag to override the display
+- property so that the elements are not actually hidden during the animation.
+-
+- ```css
+
+  ```
+
+- /\* A working example can be found at the bottom of this page. \*/
+- .my-element.ng-hide-add, .my-element.ng-hide-remove {
+- transition: all 0.5s linear;
+- }
+-
+- .my-element.ng-hide-add { ... }
+- .my-element.ng-hide-add.ng-hide-add-active { ... }
+- .my-element.ng-hide-remove { ... }
+- .my-element.ng-hide-remove.ng-hide-remove-active { ... }
+- ```
+
+  ```
+
+-
+- Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
+- to block during animation states - ngAnimate will automatically handle the style toggling for you.
+-
+- @element ANY
+- @param {string} ngShow If the {@link guide/expression expression} is truthy/falsy then the
+-                            element is shown/hidden respectively.
+-
+- @example
+- A simple example, animating the element's opacity:
+
+- <hr />
+-
+- @knownIssue
+-
+- ### Flickering when using ngShow to toggle between elements
+-
+- When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
+- happen that both the element to show and the element to hide are visible for a very short time.
+-
+- This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
+- are defined for {@link ngShow} / {@link ngHide}.
+-
+- There are several way to mitigate this problem:
+-
+- - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
+- - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
+- - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
+- - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
+- - Define an animation on the affected elements.
+    \*/
+
+/\*\*
+
+- @ngdoc directive
+- @name ngHide
+- @multiElement
+-
+- @description
+- The `ngHide` directive shows or hides the given HTML element based on the expression provided to
+- the `ngHide` attribute.
+-
+- The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
+- The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
+- `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
+- {@link ng.directive:ngCsp ngCsp}).
+-
+- ```html
+
+  ```
+
+- <!-- when $scope.myValue is truthy (element is hidden) -->
+- <div ng-hide="myValue" class="ng-hide"></div>
+-
+- <!-- when $scope.myValue is falsy (element is visible) -->
+- <div ng-hide="myValue"></div>
+- ```
+
+  ```
+
+-
+- When the `ngHide` expression evaluates to a truthy value then the `.ng-hide` CSS class is added
+- to the class attribute on the element causing it to become hidden. When falsy, the `.ng-hide`
+- CSS class is removed from the element causing the element not to appear hidden.
+-
+- ## Why is `!important` used?
+-
+- You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
+- `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
+- simple as changing the display style on a HTML list item would make hidden elements appear
+- visible. This also becomes a bigger issue when dealing with CSS frameworks.
+-
+- By using `!important`, the show and hide behavior will work as expected despite any clash between
+- CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
+- developer chooses to override the styling to change how to hide an element then it is just a
+- matter of using `!important` in their own CSS code.
+-
+- ### Overriding `.ng-hide`
+-
+- By default, the `.ng-hide` class will style the element with `display: none !important`. If you
+- wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
+- the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
+- `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
+-
+- ```css
+
+  ```
+
+- .ng-hide:not(.ng-hide-animate) {
+- /\* These are just alternative ways of hiding an element \*/
+- display: block!important;
+- position: absolute;
+- top: -9999px;
+- left: -9999px;
+- }
+- ```
+
+  ```
+
+-
+- By default you don't need to override in CSS anything and the animations will work around the
+- display style.
+-
+- @animations
+- | Animation | Occurs |
+- |-----------------------------------------------------|------------------------------------------------------------------------------------------------------------|
+- | {@link $animate#addClass addClass} `.ng-hide` | After the `ngHide` expression evaluates to a truthy value and just before the contents are set to hidden. |
+- | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngHide` expression evaluates to a non truthy value and just before contents are set to visible. |
+-
+- Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
+- directive expression is true and false. This system works like the animation system present with
+- `ngClass` except that you must also include the `!important` flag to override the display
+- property so that the elements are not actually hidden during the animation.
+-
+- ```css
+
+  ```
+
+- /\* A working example can be found at the bottom of this page. \*/
+- .my-element.ng-hide-add, .my-element.ng-hide-remove {
+- transition: all 0.5s linear;
+- }
+-
+- .my-element.ng-hide-add { ... }
+- .my-element.ng-hide-add.ng-hide-add-active { ... }
+- .my-element.ng-hide-remove { ... }
+- .my-element.ng-hide-remove.ng-hide-remove-active { ... }
+- ```
+
+  ```
+
+-
+- Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
+- to block during animation states - ngAnimate will automatically handle the style toggling for you.
+-
+- @element ANY
+- @param {string} ngHide If the {@link guide/expression expression} is truthy/falsy then the
+-                            element is hidden/shown respectively.
+-
+- @knownIssue
+-
+- ### Flickering when using ngHide to toggle between elements
+-
+- When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
+- happen that both the element to show and the element to hide are visible for a very short time.
+-
+- This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
+- are defined for {@link ngShow} / {@link ngHide}. Internet Explorer is affected more often than
+- other browsers.
+-
+- There are several way to mitigate this problem:
+-
+- - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
+- - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
+- - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
+- - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
+- - Define an animation on the affected elements.
+    \*/

package/src/exts/messages/messages.js

@@ -20,6 +20,8 @@ export function initMessageModule(angular) {
               const ctrl = this;
               let latestKey = 0;
               let nextAttachId = 0;
+              this.head = undefined;
+              this.default = undefined;
 
               this.getAttachId = function getAttachId() {
                 return nextAttachId++;

package/src/filters/limit-to.spec.js

@@ -1,5 +1,5 @@
 import { Angular } from "../loader";
-import { createInjector } from "../di/injector";
+import { createInjector } from "../core/di/injector";
 import { JQLite } from "../shared/jqlite/jqlite";
 
 describe("Filter: limitTo", () => {

package/src/filters/order-by.spec.js

@@ -1,5 +1,5 @@
 import { Angular } from "../loader";
-import { createInjector } from "../di/injector";
+import { createInjector } from "../core/di/injector";
 
 describe("Filter: orderBy", () => {
   let orderBy;

package/src/index.js

@@ -3,6 +3,10 @@ import { Angular } from "./loader";
 export const angular = new Angular();
 window["angular"] = angular;
 
-document.addEventListener("DOMContentLoaded", () => {
+if (document.readyState === "complete") {
   angular.init(document);
-});
+} else {
+  document.addEventListener("DOMContentLoaded", () => {
+    angular.init(document);
+  });
+}

package/src/loader.js

@@ -175,7 +175,7 @@ export class Angular {
    *
    * @param {any[]} modules
    * @param {boolean?} strictDi
-   * @returns {import("./types").InjectorService}
+   * @returns {import("./core/di/internal-injector").InjectorService}
    */
   injector(modules, strictDi) {
     return createInjector(modules, strictDi);
@@ -267,7 +267,7 @@ export class Angular {
    * @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
+   * @param {Array<any>|Function} [configFn] Optional configuration function for the module. Same as
    *        {@link import('./types').Module#config Module#config()}.
    * @returns {NgModule} A newly registered module.
    */
@@ -284,7 +284,11 @@ export class Angular {
           name,
         );
       }
-      const moduleInstance = new NgModule(name, requires, configFn);
+      const moduleInstance = new NgModule(
+        name,
+        requires,
+        /** @type {Function} */ (configFn),
+      );
       return moduleInstance;
     });
   }

package/src/public.js

@@ -59,7 +59,6 @@ import {
 } from "./core/animate/animate";
 import { BrowserProvider } from "./services/browser";
 import { CoreAnimateCssProvider } from "./core/animate/animate-css";
-import { CookieReaderProvider } from "./services/cookie-reader";
 import {
   AnimateAsyncRunFactoryProvider,
   AnimateRunnerFactoryProvider,
@@ -79,10 +78,7 @@ import {
   $HttpParamSerializerProvider,
   $HttpParamSerializerJQLikeProvider,
 } from "./services/http/http";
-import {
-  $HttpBackendProvider,
-  $xhrFactoryProvider,
-} from "./services/http-backend/http-backend";
+import { $HttpBackendProvider } from "./services/http-backend/http-backend";
 import { $LocationProvider } from "./core/location/location";
 import { $LogProvider } from "./services/log";
 import { $ParseProvider } from "./core/parser/parse";
@@ -192,7 +188,6 @@ export function publishExternalAPI(angular) {
             $httpParamSerializer: $HttpParamSerializerProvider,
             $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
             $httpBackend: $HttpBackendProvider,
-            $xhrFactory: $xhrFactoryProvider,
             $location: $LocationProvider,
             $log: $LogProvider,
             $parse: $ParseProvider,
@@ -205,7 +200,6 @@ export function publishExternalAPI(angular) {
             $templateCache: TemplateCacheProvider,
             $templateRequest: TemplateRequestProvider,
             $timeout: $TimeoutProvider,
-            $$cookieReader: CookieReaderProvider,
           });
         },
       ],