Added support for generators (Iterable<T>).

Altered forEach to return a number instead of true, false, or other.
Includes Promise<T> prototype.

bower.json

@@ -1,6 +1,6 @@
 {
 	"name": "typescript-dotnet",
-	"version": "2.13.3",
+	"version": "2.13.4",
 	"ignore": [
 		".bowercc",
 		".gitignore",

dist/commonjs/System.Linq/Linq.d.ts

@@ -105,7 +105,7 @@ export declare class Enumerable<T> extends InfiniteEnumerable<T> {
     static generate<T>(factory: (index?: number) => T): InfiniteEnumerable<T>;
     static generate<T>(factory: (index?: number) => T, count: number): FiniteEnumerable<T>;
     static unfold<T>(seed: T, valueFactory: Selector<T, T>, skipSeed?: Boolean): InfiniteEnumerable<T>;
-    static forEach<T>(enumerable: IEnumerableOrArray<T>, action: (element: T, index?: number) => any): void;
+    static forEach<T>(enumerable: IEnumerableOrArray<T>, action: (element: T, index?: number) => any, max?: number): number;
     static map<T, TResult>(enumerable: IEnumerableOrArray<T>, selector: Selector<T, TResult>): TResult[];
     static max(values: FiniteEnumerable<number>): number;
     static min(values: FiniteEnumerable<number>): number;
@@ -117,7 +117,7 @@ export declare class Enumerable<T> extends InfiniteEnumerable<T> {
     takeUntil(predicate: Predicate<T>, includeUntilValue?: boolean): Enumerable<T>;
     forEach(action: Predicate<T> | Action<T>): void;
     toArray(predicate?: Predicate<T>): T[];
-    copyTo(target: T[], index?: number): T[];
+    copyTo(target: T[], index?: number, count?: number): T[];
     toLookup<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
     toMap<TResult>(keySelector: Selector<T, string>, elementSelector: Selector<T, TResult>): IMap<TResult>;
     toDictionary<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): Dictionary<TKey, TValue>;

dist/commonjs/System/Collections/CollectionBase.d.ts

@@ -37,7 +37,7 @@ export declare abstract class CollectionBase<T> extends DisposableBase implement
     importEntries(entries: IEnumerableOrArray<T>): number;
     abstract getEnumerator(): IEnumerator<T>;
     contains(entry: T): boolean;
-    forEach(action: Predicate<T> | Action<T>, useCopy?: boolean): void;
+    forEach(action: Predicate<T> | Action<T>, useCopy?: boolean): number;
     copyTo<TTarget extends IArray<T>>(target: TTarget, index?: number): TTarget;
     toArray(): T[];
 }

dist/commonjs/System/Collections/Enumeration/Enumerator.d.ts

@@ -6,12 +6,14 @@ import { Selector } from "../../FunctionTypes";
 import { IEnumerator } from "./IEnumerator";
 import { IEnumerable } from "./IEnumerable";
 import { IEnumerableOrArray } from "../IEnumerableOrArray";
+import { InfiniteValueFactory } from "./InfiniteEnumerator";
+import { IIterator } from "./IIterator";
 export declare function throwIfEndless(isEndless: boolean): void;
-export declare const empty: IEnumerator<any>;
-export declare function from<T>(source: IEnumerableOrArray<T>): IEnumerator<T>;
+export declare function from<T>(source: IEnumerableOrArray<T> | InfiniteValueFactory<T> | IIterator<T>): IEnumerator<T>;
 export declare function isEnumerable<T>(instance: any): instance is IEnumerable<T>;
 export declare function isEnumerableOrArrayLike<T>(instance: any): instance is IEnumerableOrArray<T>;
 export declare function isEnumerator<T>(instance: any): instance is IEnumerator<T>;
-export declare function forEach<T>(e: IEnumerableOrArray<T> | IEnumerator<T>, action: (element: T, index?: number) => any): boolean | void;
-export declare function toArray<T>(source: IEnumerableOrArray<T> | IEnumerator<T>): T[];
-export declare function map<T, TResult>(source: IEnumerableOrArray<T> | IEnumerator<T>, selector: Selector<T, TResult>): TResult[];
+export declare function isIterator<T>(instance: any): instance is IIterator<T>;
+export declare function forEach<T>(e: IEnumerableOrArray<T> | IEnumerator<T> | IIterator<T>, action: (element: T, index?: number) => any, max?: number): number;
+export declare function toArray<T>(source: IEnumerableOrArray<T> | IEnumerator<T>, max?: number): T[];
+export declare function map<T, TResult>(source: IEnumerableOrArray<T> | IEnumerator<T>, selector: Selector<T, TResult>, max?: number): TResult[];