@angular-wave/angular.ts 0.0.65 → 0.0.66

package/src/core/di/injector.spec.js

@@ -1,5 +1,5 @@
 import { Angular } from "../../loader";
-import { createInjector } from "./injector";
+import { createInjector, annotate } from "./injector";
 import { valueFn, extend } from "../../shared/utils";
 
 describe("injector.modules", () => {
@@ -17,6 +17,19 @@ describe("injector.modules", () => {
     expect($injector.get("$injector")).toBe($injector);
   });
 
+  it("should have modules property", () => {
+    const $injector = createInjector([]);
+    expect($injector.modules).toEqual({});
+  });
+
+  it("should have methods", () => {
+    const $injector = createInjector([]);
+    expect($injector.has).toBeDefined();
+    expect($injector.invoke).toBeDefined();
+    expect($injector.instantiate).toBeDefined();
+    expect($injector.get).toBeDefined();
+  });
+
   it("should have a false strictDi property", () => {
     const injector = createInjector([]);
     expect(injector.strictDi).toBe(false);
@@ -30,13 +43,15 @@ describe("injector.modules", () => {
 
   it("should provide useful message if no provider", () => {
     expect(() => {
-      createInjector([]).get("idontexist");
+      const injector = createInjector([]);
+      injector.get("idontexist");
     }).toThrowError(/Unknown provider/);
   });
 
   it("has a constant that has been registered to a module", () => {
     const module = angular.module("myModule", []);
     module.constant("aConstant", 42);
+
     const injector = createInjector(["myModule"]);
     expect(injector.has("aConstant")).toBe(true);
   });
@@ -108,6 +123,7 @@ describe("injector.modules", () => {
       log.push("initial");
     });
     const injector = createInjector(["initial"]);
+    expect(log).toEqual(["initial"]);
     log.push("created");
 
     angular
@@ -386,12 +402,10 @@ describe("injector.modules", () => {
 });
 
 describe("annotate", () => {
-  let annotate;
   let injector;
   beforeEach(() => {
     window.angular = new Angular();
     injector = createInjector([]);
-    annotate = injector.annotate;
   });
 
   it("should return $inject", () => {
@@ -511,43 +525,43 @@ describe("annotate", () => {
     const injector = createInjector([]);
     const fn = () => {};
     fn.$inject = ["a", "b"];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns the array-style annotations of a function", () => {
     const injector = createInjector([]);
     const fn = ["a", "b", () => {}];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns the array-style annotations of a function", () => {
     const injector = createInjector([]);
     const fn = ["a", "b", () => {}];
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns annotations parsed from function args when not annotated", () => {
     const injector = createInjector([]);
     const fn = function (a, b) {};
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("returns annotations parsed from arrow args when not annotated", () => {
     const injector = createInjector([]);
     const fn = (a, b) => {};
-    expect(injector.annotate(fn)).toEqual(["a", "b"]);
+    expect(annotate(fn)).toEqual(["a", "b"]);
   });
 
   it("strips comments from argument lists when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, /*b,*/ c) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips several comments from argument lists when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, /*b,*/ c /*, d*/) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips // comments from argument lists when parsing", () => {
@@ -556,19 +570,13 @@ describe("annotate", () => {
       a, //b,
       c,
     ) {};
-    expect(injector.annotate(fn)).toEqual(["a", "c"]);
+    expect(annotate(fn)).toEqual(["a", "c"]);
   });
 
   it("strips surrounding underscores from argument names when parsing", () => {
     const injector = createInjector([]);
     const fn = function (a, _b_, c_, _d, an_argument) {};
-    expect(injector.annotate(fn)).toEqual([
-      "a",
-      "b",
-      "c_",
-      "_d",
-      "an_argument",
-    ]);
+    expect(annotate(fn)).toEqual(["a", "b", "c_", "_d", "an_argument"]);
   });
 
   it("throws when using a non-annotated fn in strict mode", () => {
@@ -1922,7 +1930,8 @@ describe("decorator", () => {
       "ng",
       function ($provide) {
         $provide.decorator("$injector", function ($delegate) {
-          return extend({}, $delegate, {
+          // Don't forget the prototype
+          return extend(Object.create($delegate), $delegate, {
             get: function (val) {
               if (val === "key") {
                 return "value";
@@ -1933,7 +1942,6 @@ describe("decorator", () => {
         });
       },
     ]);
-
     expect(injector.get("key")).toBe("value");
     expect(injector.get("$http")).not.toBeUndefined();
   });
@@ -2245,9 +2253,7 @@ describe("protection modes", () => {
   });
 
   it("should prevent instance lookup in module", () => {
-    function instanceLookupInModule(name) {
-      throw new Error("FAIL");
-    }
+    function instanceLookupInModule(name) {}
     expect(() => {
       createInjector([
         function ($provide) {

package/src/core/di/internal-injector.js

@@ -0,0 +1,233 @@
+import { assertArgFn, minErr } from "../../shared/utils";
+import { INJECTOR_LITERAL } from "./ng-module";
+
+const ARROW_ARG = /^([^(]+?)=>/;
+const FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
+const FN_ARG_SPLIT = /,/;
+const FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const $injectorMinErr = minErr(INJECTOR_LITERAL);
+
+const providerSuffix = "Provider";
+const INSTANTIATING = "INSTANTIATING";
+
+export class ProviderInjector {
+  /**
+   *
+   * @param {Object} cache
+   * @param {boolean} strictDi
+   */
+  constructor(cache, strictDi) {
+    this.cache = cache;
+    this.strictDi = strictDi;
+    this.path = [];
+    this.providerCache = cache;
+    this.modules = undefined;
+  }
+
+  factory(caller) {
+    this.path.push(caller);
+    // prevents lookups to providers through get
+    throw $injectorMinErr(
+      "unpr",
+      "Unknown provider: {0}",
+      this.path.join(" <- "),
+    );
+  }
+
+  /**
+   *
+   * @param {String} serviceName
+   * @returns {any}
+   */
+  get(serviceName) {
+    if (Object.prototype.hasOwnProperty.call(this.cache, serviceName)) {
+      if (this.cache[serviceName] === INSTANTIATING) {
+        throw $injectorMinErr(
+          "cdep",
+          "Circular dependency found: {0}",
+          `${serviceName} <- ${this.path.join(" <- ")}`,
+        );
+      }
+      return this.cache[serviceName];
+    }
+
+    this.path.unshift(serviceName);
+    this.cache[serviceName] = INSTANTIATING;
+    try {
+      // this goes to line 60
+      this.cache[serviceName] = this.factory(serviceName);
+    } catch (err) {
+      // this is for the error handling being thrown by the providerCache multiple times
+      delete this.cache[serviceName];
+      throw err;
+    }
+    return this.cache[serviceName];
+  }
+
+  injectionArgs(fn, locals, serviceName) {
+    const args = [];
+    const $inject = annotate(fn, this.strictDi, serviceName);
+
+    for (let i = 0, { length } = $inject; i < length; i++) {
+      const key = $inject[i];
+      if (typeof key !== "string") {
+        throw $injectorMinErr(
+          "itkn",
+          "Incorrect injection token! Expected service name as string, got {0}",
+          key,
+        );
+      }
+      args.push(
+        locals && Object.prototype.hasOwnProperty.call(locals, key)
+          ? locals[key]
+          : this.get(key),
+      );
+    }
+    return args;
+  }
+
+  invoke(fn, self, locals, serviceName) {
+    if (typeof locals === "string") {
+      serviceName = locals;
+      locals = null;
+    }
+
+    const args = this.injectionArgs(fn, locals, serviceName);
+    if (Array.isArray(fn)) {
+      fn = fn[fn.length - 1];
+    }
+
+    if (isClass(fn)) {
+      args.unshift(null);
+      return new (Function.prototype.bind.apply(fn, args))();
+    } else {
+      return fn.apply(self, args);
+    }
+  }
+
+  instantiate(Type, locals, serviceName) {
+    // Check if Type is annotated and use just the given function at n-1 as parameter
+    // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
+    const ctor = Array.isArray(Type) ? Type[Type.length - 1] : Type;
+    const args = this.injectionArgs(Type, locals, serviceName);
+    // Empty object at position 0 is ignored for invocation with `new`, but required.
+    args.unshift(null);
+    return new (Function.prototype.bind.apply(ctor, args))();
+  }
+
+  /**
+   *
+   * @param {String} name
+   * @returns {boolean}
+   */
+  has(name) {
+    const hasProvider = Object.prototype.hasOwnProperty.call(
+      this.providerCache,
+      name + providerSuffix,
+    );
+    const hasCache = Object.prototype.hasOwnProperty.call(this.cache, name);
+    return hasProvider || hasCache;
+  }
+}
+
+// /**
+//  * @typedef {Object} LegacyInjectorService
+//  * @property {function(Function, boolean=): string[]} annotate - Annotate a function or an array of inline annotations.
+//  * @property {function(string, string=): any} get - Get a service by name.
+//  * @property {function(Function, any?): any} instantiate - Instantiate a type constructor with optional locals.
+//  * @property {function(import("../../types").Injectable<Function | ((...args: any[]) => any)>, any=, any=): any} invoke - Invoke a function with optional context and locals.
+//  * @property {function(Array<import("../../types").Module | string | import("../../types").Injectable<(...args: any[]) => void>>): void} [loadNewModules] - Add and load new modules to the injector.
+//  * @property {Object.<string, import("../../types").Module>} [modules] - A map of all the modules loaded into the injector.
+//  * @property {boolean} [strictDi] - Indicates if strict dependency injection is enforced.
+//  */
+
+export class InjectorService extends ProviderInjector {
+  constructor(cache, strictDi, providerInjector) {
+    super(cache, strictDi);
+    this.strictDi = strictDi;
+    this.providerInjector = providerInjector;
+    this.providerCache = providerInjector.cache;
+    this.modules = undefined;
+  }
+
+  factory(serviceName, caller) {
+    const provider = this.providerInjector.get(
+      serviceName + providerSuffix,
+      caller,
+    );
+    const res = this.invoke(provider.$get, provider, undefined, serviceName);
+    return res;
+  }
+
+  // Gets overridden
+  loadNewModules() {}
+}
+
+// Helpers
+
+/**
+ * @param {String} fn
+ * @returns {String}
+ */
+function stringifyFn(fn) {
+  return Function.prototype.toString.call(fn);
+}
+
+/**
+ * @param {String} fn
+ * @returns {Array<any>}
+ */
+function extractArgs(fn) {
+  const fnText = stringifyFn(fn).replace(STRIP_COMMENTS, "");
+  const args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
+  return args;
+}
+
+/**
+ * @param {String} func
+ * @returns {boolean}
+ */
+function isClass(func) {
+  return /^class\b/.test(stringifyFn(func));
+}
+
+/**
+ *
+ * @param {any} fn
+ * @param {boolean} strictDi
+ * @param {String} name
+ * @returns {Array<string>}
+ */
+function annotate(fn, strictDi, name) {
+  var $inject, argDecl, last;
+
+  if (typeof fn === "function") {
+    if (!($inject = fn.$inject)) {
+      $inject = [];
+      if (fn.length) {
+        if (strictDi) {
+          throw $injectorMinErr(
+            "strictdi",
+            "{0} is not using explicit annotation and cannot be invoked in strict mode",
+            name,
+          );
+        }
+        argDecl = extractArgs(/** @type {String} */ (fn));
+        argDecl[1].split(FN_ARG_SPLIT).forEach(function (arg) {
+          arg.replace(FN_ARG, function (all, underscore, name) {
+            $inject.push(name);
+          });
+        });
+      }
+      fn.$inject = $inject;
+    }
+  } else if (Array.isArray(fn)) {
+    last = /** @type {Array} */ (fn).length - 1;
+    assertArgFn(fn[last], "fn");
+    $inject = /** @type {Array} */ (fn).slice(0, last);
+  } else {
+    assertArgFn(fn, "fn", true);
+  }
+  return $inject;
+}

package/src/core/filter/filter.js

@@ -22,6 +22,11 @@ export function $FilterProvider($provide) {
 
   this.$get = [
     "$injector",
+    /**
+     *
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @returns
+     */
     function ($injector) {
       return function (name) {
         return $injector.get(name + suffix);

package/src/core/sce/sce.js

@@ -248,7 +248,12 @@ export function $SceDelegateProvider() {
   this.$get = [
     "$injector",
     "$$sanitizeUri",
-
+    /**
+     *
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @param {*} $$sanitizeUri
+     * @returns
+     */
     function ($injector, $$sanitizeUri) {
       let htmlSanitizer = function () {
         throw $sceMinErr(

package/src/loader.js

@@ -144,7 +144,7 @@ export class Angular {
          * @param {*} scope
          * @param {JQLite} el
          * @param {*} compile
-         * @param {*} $injector
+         * @param {import("./core/di/internal-injector").InjectorService} $injector
          */
         function (scope, el, compile, $injector) {
           scope.$apply(() => {

package/src/router/services.js

@@ -10,8 +10,16 @@
 import { services } from "./common/coreservices";
 import { unnestR } from "../shared/common";
 import { trace } from "./common/trace";
+import { annotate } from "../core/di/injector";
 
 runBlock.$inject = ["$injector", "$q", "$stateRegistry", "$urlService"];
+/**
+ *
+ * @param {import("../core/di/internal-injector").InjectorService} $injector
+ * @param {*} $q
+ * @param {*} $stateRegistry
+ * @param {*} $urlService
+ */
 export function runBlock($injector, $q, $stateRegistry, $urlService) {
   services.$injector = $injector;
   services.$q = $q;
@@ -32,10 +40,7 @@ export function runBlock($injector, $q, $stateRegistry, $urlService) {
     .filter((x) => x.deps === "deferred")
     .forEach(
       (resolvable) =>
-        (resolvable.deps = $injector.annotate(
-          resolvable.resolveFn,
-          $injector.strictDi,
-        )),
+        (resolvable.deps = annotate(resolvable.resolveFn, $injector.strictDi)),
     );
   // Start listening for url changes
   $urlService.listen();

package/src/router/state/state-builder.js

@@ -11,6 +11,7 @@ import { stringify } from "../../shared/strings";
 import { is, pattern, pipe, prop, val } from "../../shared/hof";
 import { Resolvable } from "../resolve/resolvable";
 import { services } from "../common/coreservices";
+import { annotate } from "../../core/di/injector";
 const parseUrl = (url) => {
   if (!isString(url)) return false;
   const root = url.charAt(0) === "^";
@@ -145,14 +146,14 @@ export function resolvablesBuilder(state) {
       policy: resolvePolicies[token],
     }));
   /** fetch DI annotations from a function or ng1-style array */
-  const annotate = (fn) => {
+  const annotateFn = (fn) => {
     const $injector = services.$injector;
     // ng1 doesn't have an $injector until runtime.
     // If the $injector doesn't exist, use "deferred" literal as a
     // marker indicating they should be annotated when runtime starts
     return (
       fn["$inject"] ||
-      ($injector && $injector.annotate(fn, $injector.strictDi)) ||
+      ($injector && annotate(fn, $injector.strictDi)) ||
       "deferred"
     );
   };
@@ -207,7 +208,7 @@ export function resolvablesBuilder(state) {
   const tuple2Resolvable = pattern([
         [pipe(prop('val'), isString), (tuple) => new Resolvable(tuple.token, ((x) => x), [tuple.val], tuple.policy)],
         [pipe(prop('val'), Array.isArray), (tuple) => new Resolvable(tuple.token, tail(tuple.val), tuple.val.slice(0, -1), tuple.policy)],
-        [pipe(prop('val'), isFunction), (tuple) => new Resolvable(tuple.token, tuple.val, annotate(tuple.val), tuple.policy)],
+        [pipe(prop('val'), isFunction), (tuple) => new Resolvable(tuple.token, tuple.val, annotateFn(tuple.val), tuple.policy)],
     ]);
   // prettier-ignore
   const item2Resolvable = pattern([

package/src/router/state/state-registry.js

@@ -50,6 +50,11 @@ export class StateRegistry {
 
   $get = [
     "$injector",
+    /**
+     *
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @returns
+     */
     ($injector) => {
       this.$injector = $injector;
       this.builder.$injector = $injector;

package/src/router/state/views.js

@@ -5,6 +5,7 @@ import { services } from "../common/coreservices";
 import { trace } from "../common/trace";
 import { ResolveContext } from "../resolve/resolve-context";
 import { Resolvable } from "../resolve/resolvable";
+import { annotate } from "../../core/di/injector";
 
 export function getNg1ViewConfigFactory() {
   let templateFactory = null;
@@ -141,7 +142,7 @@ export class Ng1ViewConfig {
   getController(context) {
     const provider = this.viewDecl.controllerProvider;
     if (!isInjectable(provider)) return this.viewDecl.controller;
-    const deps = services.$injector.annotate(provider);
+    const deps = annotate(provider);
     const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);

package/src/router/template-factory.js

@@ -3,6 +3,7 @@ import { services } from "./common/coreservices";
 import { tail, unnestR } from "../shared/common";
 import { Resolvable } from "./resolve/resolvable";
 import { kebobString } from "../shared/strings";
+import { annotate } from "../core/di/injector";
 
 /**
  * @typedef BindingTuple
@@ -30,7 +31,7 @@ export class TemplateFactory {
      * @param {angular.ITemplateCacheService} $templateCache
      * @param {angular.ITemplateRequestService} $templateRequest
      * @param {angular.IQService} $q
-     * @param {angular.auto.IInjectorService} $injector
+     * @param {import("../core/di/internal-injector").InjectorService} $injector
      * @returns
      */
     ($http, $templateCache, $templateRequest, $q, $injector) => {
@@ -146,7 +147,7 @@ export class TemplateFactory {
    * for that string.
    */
   fromProvider(provider, params, context) {
-    const deps = this.$injector.annotate(provider);
+    const deps = annotate(provider);
     const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
@@ -159,7 +160,7 @@ export class TemplateFactory {
    * @return {string} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
    */
   fromComponentProvider(provider, params, context) {
-    const deps = this.$injector.annotate(provider);
+    const deps = annotate(provider);
     const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
@@ -207,7 +208,7 @@ export class TemplateFactory {
       if (type === "&") {
         const res = context.getResolvable(resolveName);
         const fn = res && res.data;
-        const args = (fn && this.$injector.annotate(fn)) || [];
+        const args = (fn && annotate(fn)) || [];
         // account for array style injection, i.e., ['foo', function(foo) {}]
         const arrayIdxStr = Array.isArray(fn) ? `[${fn.length - 1}]` : "";
         return `${attrName}='$resolve.${resolveName}${arrayIdxStr}(${args.join(",")})'`;

package/src/services/http/http.js

@@ -499,6 +499,18 @@ export function $HttpProvider() {
     "$q",
     "$injector",
     "$sce",
+    /**
+     *
+     * @param {*} $browser
+     * @param {*} $httpBackend
+     * @param {*} $$cookieReader
+     * @param {*} $cacheFactory
+     * @param {*} $rootScope
+     * @param {*} $q
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @param {*} $sce
+     * @returns
+     */
     function (
       $browser,
       $httpBackend,

package/src/types.js

@@ -10,6 +10,15 @@
  * @template T
  */
 
+/**
+ *
+ * @typedef {Object} Annotated
+ * @property {Array<String>} $inject
+ *  *
+ * @typedef {Function & Annotated & Array<any>} AnnotatedFunction
+ *
+ */
+
 /**
  * @typedef {Object} ComponentOptions
  * @description Component definition object (a simplified directive definition object)
@@ -444,15 +453,4 @@
  * @property {function(any, any): IPromise<any>} [index] - Async validator function for each index.
  */
 
-/**
- * @typedef {Object} InjectorService
- * @property {function(Function, boolean=): string[]} annotate - Annotate a function or an array of inline annotations.
- * @property {function(string, string=): any} get - Get a service by name.
- * @property {function(Function, any?): any} instantiate - Instantiate a type constructor with optional locals.
- * @property {function(Injectable<Function | ((...args: any[]) => any)>, any=, any=): any} invoke - Invoke a function with optional context and locals.
- * @property {function(Array<Module | string | Injectable<(...args: any[]) => void>>): void} [loadNewModules] - Add and load new modules to the injector.
- * @property {Object.<string, Module>} [modules] - A map of all the modules loaded into the injector.
- * @property {boolean} [strictDi] - Indicates if strict dependency injection is enforced.
- */
-
 export {};

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

@@ -1,7 +1,7 @@
 export function $$AnimateJsProvider($animateProvider: any): void;
 export class $$AnimateJsProvider {
     constructor($animateProvider: any);
-    $get: (string | (($injector: any, $$AnimateRunner: any) => (element: any, event: any, classes: any, options: any, ...args: any[]) => {
+    $get: (string | (($injector: import("../core/di/internal-injector").InjectorService, $$AnimateRunner: any) => (element: any, event: any, classes: any, options: any, ...args: any[]) => {
         $$willAnimate: boolean;
         end(): any;
         start(): any;

package/types/animations/animation.d.ts

@@ -1,5 +1,5 @@
 export function $$AnimationProvider(): void;
 export class $$AnimationProvider {
     drivers: any[];
-    $get: (string | (($rootScope: any, $injector: any, $$AnimateRunner: any, $$rAFScheduler: import("./raf-scheduler").RafScheduler, $$animateCache: any) => (element: any, event: any, options: any) => any))[];
+    $get: (string | (($rootScope: any, $injector: import("../core/di/internal-injector").InjectorService, $$AnimateRunner: any, $$rAFScheduler: import("./raf-scheduler").RafScheduler, $$animateCache: any) => (element: any, event: any, options: any) => any))[];
 }

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

@@ -161,7 +161,7 @@ export class $CompileProvider {
      * @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) => string | NodeList | JQLite))[];
+    $get: (string | (($injector: import("../../core/di/internal-injector").InjectorService, $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) => string | NodeList | JQLite))[];
 }
 export namespace $CompileProvider {
     let $inject: string[];

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

@@ -28,5 +28,5 @@ export class $ControllerProvider {
      *    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))[];
+    $get: (string | (($injector: import("../../core/di/internal-injector").InjectorService) => (expression: Function | string, locals: any, later: any, ident: any) => any))[];
 }