@angular-wave/angular.ts 0.0.38 → 0.0.40

package/src/shared/strings.js

@@ -7,7 +7,7 @@
  */
 import { isInjectable, isNull, isPromise } from "./predicates";
 import { isUndefined, isFunction, isString, isObject } from "./utils";
-import { identity, pushR, tail } from "./common";
+import { pushR, tail } from "./common";
 import { pattern, val } from "./hof";
 /**
  * Returns a string shortened to a maximum length
@@ -75,7 +75,7 @@ export function stringify(o) {
     [isRejection, (x) => x._transitionRejection.toString()],
     [hasToString, (x) => x.toString()],
     [isInjectable, functionToString],
-    [val(true), identity],
+    [val(true), (x) => x],
   ]);
   function format(value) {
     if (isObject(value)) {

package/src/shared/test-utils.js

@@ -1,11 +1,11 @@
-import { jqLite } from "./jqlite/jqlite";
+import { JQLite } from "./jqlite/jqlite";
 
 /**
  * @param {HTMLElement} element
  * @param {string} event
  */
 export function browserTrigger(element, event) {
-  jqLite(element)[0].dispatchEvent(
+  JQLite(element)[0].dispatchEvent(
     new Event(event, { bubbles: true, cancelable: true }),
   );
 }

package/src/shared/utils.js

@@ -52,8 +52,8 @@ export function isArrayLike(obj) {
   if (obj == null || isWindow(obj)) return false;
 
   // arrays, strings and jQuery/jqLite objects are array like
-  // * we have to check the existence of jqLite first as this method is called
-  //   via the forEach method when constructing the jqLite object in the first place
+  // * we have to check the existence of JQLite first as this method is called
+  //   via the forEach method when constructing the JQLite object in the first place
   if (Array.isArray(obj) || obj instanceof Array || isString(obj)) return true;
 
   // Support: iOS 8.2 (not reproducible in simulator)
@@ -1174,6 +1174,8 @@ export function assertArgFn(arg, name, acceptArrayAnnotation) {
   return arg;
 }
 
+export const minErrConfig = {};
+
 /**
  * @description
  *
@@ -1201,21 +1203,16 @@ export function assertArgFn(arg, name, acceptArrayAnnotation) {
  * @param {string} module The namespace to use for the new minErr instance.
  * @returns {function(string, string, ...*): Error} minErr instance
  */
-
-export const minErrConfig = {};
-
 export function minErr(module) {
   const url = 'https://errors.angularjs.org/"NG_VERSION_FULL"/';
   const regex = `${url.replace(".", "\\.")}[\\s\\S]*`;
   const errRegExp = new RegExp(regex, "g");
 
-  return function () {
-    const code = arguments[0];
-    const template = arguments[1];
+  return function (...args) {
+    const code = args[0];
+    const template = args[1];
     let message = `[${module ? `${module}:` : ""}${code}] `;
-    const templateArgs = sliceArgs(arguments, 2).map((arg) =>
-      toDebugString(arg),
-    );
+    const templateArgs = sliceArgs(args, 2).map((arg) => toDebugString(arg));
     let paramPrefix;
     let i;
 

package/src/src.test.js

@@ -0,0 +1,10 @@
+import { test, expect } from "@playwright/test";
+
+test("unitstate-directives tests contain no errors", async ({ page }) => {
+  await page.goto("src/src.html");
+  await page.content();
+  await page.waitForTimeout(6000);
+  await expect(page.locator(".jasmine-overall-result")).toHaveText(
+    /0 failures/,
+  );
+});

package/tsconfig.json

@@ -13,5 +13,5 @@
     "typeRoots": ["node_modules/@types"]
   },
   "include": ["./src/*.js", "./**/*.ts"],
-  "exclude": []
+  "exclude": ["**/*.test.js", "**/*.spec.js"]
 }

package/tsconfig.types.json

@@ -0,0 +1,11 @@
+{
+    "compilerOptions": {
+      "declaration": true,
+      "allowJs": true,
+      "emitDeclarationOnly": true,
+      "outDir": "types"
+    },
+    "include": ["src/**/*.js"],
+    "exclude": ["**/*.spec.js", "**/*.test.js"]
+  }
+  

package/types/animations/animate-cache.d.ts

@@ -1,12 +1,12 @@
 export function animateCache(): {
-  cacheKey(node: any, method: any, addClass: any, removeClass: any): string;
-  containsCachedAnimationWithoutDuration(key: any): boolean;
-  flush(): void;
-  count(key: any): any;
-  get(key: any): any;
-  put(key: any, value: any, isValid: any): void;
+    cacheKey(node: any, method: any, addClass: any, removeClass: any): string;
+    containsCachedAnimationWithoutDuration(key: any): boolean;
+    flush(): void;
+    count(key: any): any;
+    get(key: any): any;
+    put(key: any, value: any, isValid: any): void;
 };
 export function $$AnimateCacheProvider(): void;
 export class $$AnimateCacheProvider {
-  $get: (typeof animateCache)[];
+    $get: (typeof animateCache)[];
 }

package/types/animations/animate-children-directive.d.ts

@@ -76,9 +76,6 @@
     </file>
   </example>
  */
-export const $$AnimateChildrenDirective: (
-  | string
-  | (($interpolate: any) => {
-      link(scope: any, element: any, attrs: any): void;
-    })
-)[];
+export const $$AnimateChildrenDirective: (string | (($interpolate: any) => {
+    link(scope: any, element: any, attrs: any): void;
+}))[];

package/types/animations/animate-swap.d.ts

@@ -85,19 +85,10 @@
  *  </file>
  * </example>
  */
-export const ngAnimateSwapDirective: (
-  | string
-  | (($animate: any) => {
-      restrict: string;
-      transclude: string;
-      terminal: boolean;
-      priority: number;
-      link(
-        scope: any,
-        $element: any,
-        attrs: any,
-        ctrl: any,
-        $transclude: any,
-      ): void;
-    })
-)[];
+export const ngAnimateSwapDirective: (string | (($animate: any) => {
+    restrict: string;
+    transclude: string;
+    terminal: boolean;
+    priority: number;
+    link(scope: any, $element: any, attrs: any, ctrl: any, $transclude: any): void;
+}))[];

package/types/animations/animation.d.ts

@@ -1,14 +1,5 @@
 export function $$AnimationProvider(): void;
 export class $$AnimationProvider {
-  drivers: any[];
-  $get: (
-    | string
-    | ((
-        $rootScope: any,
-        $injector: any,
-        $$AnimateRunner: any,
-        $$rAFScheduler: any,
-        $$animateCache: any,
-      ) => (element: any, event: any, options: any) => any)
-  )[];
+    drivers: any[];
+    $get: (string | (($rootScope: any, $injector: any, $$AnimateRunner: any, $$rAFScheduler: any, $$animateCache: any) => (element: any, event: any, options: any) => any))[];
 }

package/types/animations/raf-scheduler.d.ts

@@ -1,5 +1,5 @@
 export const $$rAFSchedulerFactory: (() => {
-  (tasks: any): void;
-  queue: any[];
-  waitUntilQuiet(fn: any): void;
+    (tasks: any): void;
+    queue: any[];
+    waitUntilQuiet(fn: any): void;
 })[];

package/types/animations/shared.d.ts

@@ -1,40 +1,25 @@
 export function assertArg(arg: any, name: any, reason: any): any;
 export function mergeClasses(a: any, b: any): any;
 export function packageStyles(options: any): {
-  to: any;
-  from: any;
+    to: any;
+    from: any;
 };
 export function pendClasses(classes: any, fix: any, isPrefix: any): string;
 export function removeFromArray(arr: any, val: any): void;
 export function stripCommentsFromElement(element: any): any;
 export function extractElementNode(element: any): any;
-export function applyAnimationClassesFactory(): (
-  element: any,
-  options: any,
-) => void;
+export function applyAnimationClassesFactory(): (element: any, options: any) => void;
 export function prepareAnimationOptions(options: any): any;
 export function applyAnimationStyles(element: any, options: any): void;
 export function applyAnimationFromStyles(element: any, options: any): void;
 export function applyAnimationToStyles(element: any, options: any): void;
-export function mergeAnimationDetails(
-  element: any,
-  oldAnimation: any,
-  newAnimation: any,
-): any;
-export function resolveElementClasses(
-  existing: any,
-  toAdd: any,
-  toRemove: any,
-): {
-  addClass: string;
-  removeClass: string;
+export function mergeAnimationDetails(element: any, oldAnimation: any, newAnimation: any): any;
+export function resolveElementClasses(existing: any, toAdd: any, toRemove: any): {
+    addClass: string;
+    removeClass: string;
 };
 export function getDomNode(element: any): any;
-export function applyGeneratedPreparationClasses(
-  element: any,
-  event: any,
-  options: any,
-): void;
+export function applyGeneratedPreparationClasses(element: any, event: any, options: any): void;
 export function clearGeneratedClasses(element: any, options: any): void;
 export function blockKeyframeAnimations(node: any, applyBlock: any): string[];
 export function applyInlineStyle(node: any, styleTuple: any): void;
@@ -62,4 +47,4 @@ export const ANIMATION_DELAY_PROP: string;
 export const ANIMATION_DURATION_PROP: string;
 export const TRANSITION_DELAY_PROP: string;
 export const TRANSITION_DURATION_PROP: string;
-export const ngMinErr: (...args: any[]) => Error;
+export const ngMinErr: (arg0: string, arg1: string, ...arg2: any[]) => Error;

package/types/core/{animate-css.d.ts → animate/animate-css.d.ts}

@@ -12,14 +12,8 @@
  */
 export function CoreAnimateCssProvider(): void;
 export class CoreAnimateCssProvider {
-  $get: (
-    | string
-    | (($$AnimateRunner: any) => (
-        element: any,
-        initialOptions: any,
-      ) => {
+    $get: (string | (($$AnimateRunner: any) => (element: any, initialOptions: any) => {
         start: () => any;
         end: () => any;
-      })
-  )[];
+    }))[];
 }

package/types/core/{cache.d.ts → cache/cache.d.ts}

@@ -17,9 +17,9 @@ export const EXPANDO: "ngId";
  */
 export const CACHE: Map<number, ExpandoStore>;
 export type ExpandoStore = {
-  data: {
-    [x: string]: any;
-  };
-  events: any;
-  handle: Function | null;
+    data: {
+        [x: string]: any;
+    };
+    events: any;
+    handle: Function | null;
 };

package/types/core/compile/compile.d.ts

@@ -0,0 +1,173 @@
+export function $CompileProvider($provide: any, $$sanitizeUriProvider: any): void;
+export class $CompileProvider {
+    constructor($provide: any, $$sanitizeUriProvider: any);
+    /**
+     * @ngdoc method
+     * @name $compileProvider#directive
+     * @kind function
+     *
+     * @description
+     * Register a new directive with the compiler.
+     *
+     * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
+     *    as `ng-bind`), or an object map of directives where the keys are the names and the values
+     *    are the factories.
+     * @param {Function|Array} directiveFactory An injectable directive factory function. See the
+     *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
+     * @returns {ng.ICompileProvider} Self for chaining.
+     */
+    directive: (name: string | any, directiveFactory: Function | any[]) => ng.ICompileProvider;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#component
+     * @module ng
+     * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
+     *    or an object map of components where the keys are the names and the values are the component definition objects.
+     * @param {Object} options Component definition object (a simplified
+     *    {@link ng.$compile#directive-definition-object directive definition object}),
+     *    with the following properties (all optional):
+     *
+     *    - `controller` – `{(string|function()=}` – controller constructor function that should be
+     *      associated with newly created scope or the name of a {@link ng.$compile#-controller-
+     *      registered controller} if passed as a string. An empty `noop` function by default.
+     *    - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
+     *      If present, the controller will be published to scope under the `controllerAs` name.
+     *      If not present, this will default to be `$ctrl`.
+     *    - `template` – `{string=|function()=}` – html template as a string or a function that
+     *      returns an html template as a string which should be used as the contents of this component.
+     *      Empty string by default.
+     *
+     *      If `template` is a function, then it is {@link auto.$injector#invoke injected} with
+     *      the following locals:
+     *
+     *      - `$element` - Current element
+     *      - `$attrs` - Current attributes object for the element
+     *
+     *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
+     *      template that should be used  as the contents of this component.
+     *
+     *      If `templateUrl` is a function, then it is {@link auto.$injector#invoke injected} with
+     *      the following locals:
+     *
+     *      - `$element` - Current element
+     *      - `$attrs` - Current attributes object for the element
+     *
+     *    - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
+     *      Component properties are always bound to the component controller and not to the scope.
+     *      See {@link ng.$compile#-bindtocontroller- `bindToController`}.
+     *    - `transclude` – `{boolean=}` – whether {@link $compile#transclusion content transclusion} is enabled.
+     *      Disabled by default.
+     *    - `require` - `{Object<string, string>=}` - requires the controllers of other directives and binds them to
+     *      this component's controller. The object keys specify the property names under which the required
+     *      controllers (object values) will be bound. See {@link ng.$compile#-require- `require`}.
+     *    - `$...` – additional properties to attach to the directive factory function and the controller
+     *      constructor function. (This is used by the component router to annotate)
+     *
+     * @returns {ng.$compileProvider} the compile provider itself, for chaining of function calls.
+     * @description
+     * Register a **component definition** with the compiler. This is a shorthand for registering a special
+     * type of directive, which represents a self-contained UI component in your application. Such components
+     * are always isolated (i.e. `scope: {}`) and are always restricted to elements (i.e. `restrict: 'E'`).
+     *
+     * Component definitions are very simple and do not require as much configuration as defining general
+     * directives. Component definitions usually consist only of a template and a controller backing it.
+     *
+     * In order to make the definition easier, components enforce best practices like use of `controllerAs`,
+     * `bindToController`. They always have **isolate scope** and are restricted to elements.
+     *
+     * Here are a few examples of how you would usually define components:
+     *
+     * ```js
+     *   let myMod = angular.module(...);
+     *   myMod.component('myComp', {
+     *     template: '<div>My name is {{$ctrl.name}}</div>',
+     *     controller: function() {
+     *       this.name = 'shahar';
+     *     }
+     *   });
+     *
+     *   myMod.component('myComp', {
+     *     template: '<div>My name is {{$ctrl.name}}</div>',
+     *     bindings: {name: '@'}
+     *   });
+     *
+     *   myMod.component('myComp', {
+     *     templateUrl: 'views/my-comp.html',
+     *     controller: 'MyCtrl',
+     *     controllerAs: 'ctrl',
+     *     bindings: {name: '@'}
+     *   });
+     *
+     * ```
+     * For more examples, and an in-depth guide, see the {@link guide/component component guide}.
+     *
+     * <br />
+     * See also {@link ng.$compileProvider#directive $compileProvider.directive()}.
+     */
+    component: (name: string | any, options: any) => ng.$compileProvider;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#aHrefSanitizationTrustedUrlList
+     * @kind function
+     *
+     * @description
+     * Retrieves or overrides the default regular expression that is used for determining trusted safe
+     * urls during a[href] sanitization.
+     *
+     * The sanitization is a security measure aimed at preventing XSS attacks via html links.
+     *
+     * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
+     * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationTrustedUrlList`
+     * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+     * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
+     *
+     * @param {RegExp=} regexp New regexp to trust urls with.
+     * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+     *    chaining otherwise.
+     */
+    aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#imgSrcSanitizationTrustedUrlList
+     * @kind function
+     *
+     * @description
+     * Retrieves or overrides the default regular expression that is used for determining trusted safe
+     * urls during img[src] sanitization.
+     *
+     * The sanitization is a security measure aimed at prevent XSS attacks via html links.
+     *
+     * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
+     * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationTrustedUrlList`
+     * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+     * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
+     *
+     * @param {RegExp=} regexp New regexp to trust urls with.
+     * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+     *    chaining otherwise.
+     */
+    imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    debugInfoEnabled: (enabled: any) => boolean | this;
+    strictComponentBindingsEnabled: (enabled: any) => boolean | this;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#addPropertySecurityContext
+     * @description
+     *
+     * Defines the security context for DOM properties bound by ng-prop-*.
+     *
+     * @param {string} elementName The element name or '*' to match any element.
+     * @param {string} propertyName The DOM property name.
+     * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
+     * @returns {object} `this` for chaining
+     */
+    addPropertySecurityContext: (elementName: string, propertyName: string, ctx: string) => object;
+    $get: (string | (($injector: any, $interpolate: any, $exceptionHandler: any, $templateRequest: any, $parse: any, $controller: any, $rootScope: any, $sce: any, $animate: any) => ($compileNodes: string | NodeList, transcludeFn: any, maxPriority: any, ignoreDirective: any, previousCompileContext: any) => (scope: any, cloneConnectFn: any, options: any) => any))[];
+}
+export namespace $CompileProvider {
+    let $inject: string[];
+}
+/**
+ * Function that aggregates all linking fns for a compilation root (nodeList)
+ */
+export type CompositeLinkFn = Function;

package/types/core/controller/controller.d.ts

@@ -0,0 +1,32 @@
+export function identifierForController(controller: any, ident: any): any;
+/**
+ * @ngdoc provider
+ * @name $controllerProvider
+ *
+ *
+ * @description
+ * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * controllers.
+ *
+ * This provider allows controller registration via the
+ * {@link ng.$controllerProvider#register register} method.
+ */
+export function $ControllerProvider(): void;
+export class $ControllerProvider {
+    /**
+     * @ngdoc method
+     * @name $controllerProvider#has
+     * @param {string} name Controller name to check.
+     */
+    has: (name: string) => any;
+    /**
+     * @ngdoc method
+     * @name $controllerProvider#register
+     * @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|Array} constructor Controller constructor fn (optionally decorated with DI
+     *    annotations in the array notation).
+     */
+    register: (name: string | any, constructor: Function | any[]) => void;
+    $get: (string | (($injector: any) => (expression: Function | string, locals: any, later: any, ident: any) => any))[];
+}

package/types/core/exception-handler.d.ts

@@ -1,46 +1,13 @@
 /**
- * @ngdoc service
- * @name $exceptionHandler
- * @requires ng.$log
- *
- *
- * @description
- * Any uncaught exception in AngularJS expressions is delegated to this service.
- * The default implementation simply delegates to `$log.error` which logs it into
- * the browser console.
- *
- *
- * ## Example:
- *
- * The example below will overwrite the default `$exceptionHandler` in order to (a) log uncaught
- * errors to the backend for later inspection by the developers and (b) to use `$log.warn()` instead
- * of `$log.error()`.
- *
- * ```js
- *   angular.
- *     module('exceptionOverwrite', []).
- *     factory('$exceptionHandler', ['$log', 'logErrorsToBackend', function($log, logErrorsToBackend) {
- *       return function myExceptionHandler(exception, cause) {
- *         logErrorsToBackend(exception, cause);
- *         $log.warn(exception, cause);
- *       };
- *     }]);
- * ```
- *
- * <hr />
- * Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind`
- * methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler}
- * (unless executed during a digest).
- *
- * If you wish, you can manually delegate exceptions, e.g.
- * `try { ... } catch(e) { $exceptionHandler(e); }`
- *
- * @param {Error} exception Exception associated with the error.
- * @param {string=} cause Optional information about the context in which
- *       the error was thrown.
- *
+ * @constructor
+ * @this {angular.ExceptionHandlerProvider}
  */
-export function $ExceptionHandlerProvider(): void;
+export function $ExceptionHandlerProvider(this: import("../index").angular.ServiceProvider): void;
 export class $ExceptionHandlerProvider {
-  $get: (string | (($log: any) => (...args: any[]) => void))[];
+    $get: (string | (($log: import("../services/log").angular.LogService) => angular.ErrorHandler))[];
+}
+export function errorHandler(exception: any, cause: any): void;
+export namespace angular {
+    type ExceptionHandlerProvider = import("../index").angular.ServiceProvider;
+    type ErrorHandler = (exception: Error, cause?: string) => void;
 }

package/types/core/filter/filter.d.ts

@@ -0,0 +1,9 @@
+export function $FilterProvider($provide: any): void;
+export class $FilterProvider {
+    constructor($provide: any);
+    register: (name: any, factory: any) => any;
+    $get: (string | (($injector: any) => (name: any) => any))[];
+}
+export namespace $FilterProvider {
+    let $inject: string[];
+}

package/types/core/{interpolate.d.ts → interpolate/interpolate.d.ts}

@@ -17,43 +17,28 @@
  */
 export function $InterpolateProvider(): void;
 export class $InterpolateProvider {
-  /**
-   * @ngdoc method
-   * @name $interpolateProvider#startSymbol
-   * @description
-   * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
-   *
-   * @param {string=} value new value to set the starting symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
-   */
-  startSymbol: (
-    value?: string | undefined,
-  ) => string | (Window & typeof globalThis);
-  /**
-   * @ngdoc method
-   * @name $interpolateProvider#endSymbol
-   * @description
-   * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
-   *
-   * @param {string=} value new value to set the ending symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
-   */
-  endSymbol: (
-    value?: string | undefined,
-  ) => string | (Window & typeof globalThis);
-  $get: (
-    | string
-    | ((
-        $parse: any,
-        $exceptionHandler: any,
-        $sce: any,
-      ) => {
-        (
-          text: string,
-          mustHaveExpression?: boolean | undefined,
-          trustedContext?: string | undefined,
-          allOrNothing?: boolean | undefined,
-        ): (arg0: context) => any;
+    /**
+     * @ngdoc method
+     * @name $interpolateProvider#startSymbol
+     * @description
+     * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
+     *
+     * @param {string=} value new value to set the starting symbol to.
+     * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+     */
+    startSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
+    /**
+     * @ngdoc method
+     * @name $interpolateProvider#endSymbol
+     * @description
+     * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+     *
+     * @param {string=} value new value to set the ending symbol to.
+     * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+     */
+    endSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
+    $get: (string | (($parse: any, $exceptionHandler: import("../exception-handler").angular.ErrorHandler, $sce: any) => {
+        (text: string, mustHaveExpression?: boolean | undefined, trustedContext?: string | undefined, allOrNothing?: boolean | undefined): (arg0: context) => any;
         /**
          * @ngdoc method
          * @name $interpolate#startSymbol
@@ -78,6 +63,5 @@ export class $InterpolateProvider {
          * @returns {string} end symbol.
          */
         endSymbol(): string;
-      })
-  )[];
+    }))[];
 }

package/types/core/interval/interval-factory.d.ts

@@ -0,0 +1,4 @@
+export function $$IntervalFactoryProvider(): void;
+export class $$IntervalFactoryProvider {
+    $get: (string | (($browser: any, $q: any, $$q: any, $rootScope: any) => (setIntervalFn: any, clearIntervalFn: any) => (fn: any, delay: any, count: any, invokeApply: any, ...args: any[]) => any))[];
+}

package/types/core/{interval.d.ts → interval/interval.d.ts}

@@ -1,4 +1,4 @@
 export function $IntervalProvider(): void;
 export class $IntervalProvider {
-  $get: (string | (($$intervalFactory: any) => any))[];
+    $get: (string | (($$intervalFactory: any) => any))[];
 }