diff --git a/bower.json b/bower.json
index c6f693e2..8f1d4ae1 100644
--- a/bower.json
+++ b/bower.json
@@ -1,6 +1,6 @@
{
"name": "typescript-dotnet",
- "version": "2.11.7",
+ "version": "2.12.0",
"ignore": [
".bowercc",
".gitignore",
diff --git a/dist/amd/System.Linq/Linq.d.ts b/dist/amd/System.Linq/Linq.d.ts
new file mode 100644
index 00000000..fabea935
--- /dev/null
+++ b/dist/amd/System.Linq/Linq.d.ts
@@ -0,0 +1,196 @@
+///
+///
+///
+///
+///
+///
+///
+///
+///
+/*!
+ * @author electricessence / https://github.com/electricessence/
+ * Original: http://linqjs.codeplex.com/
+ * Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
+ */
+import Dictionary from "../System/Collections/Dictionaries/Dictionary";
+import DisposableBase from "../System/Disposable/DisposableBase";
+export declare const enum EnumerableAction {
+ Break = 0,
+ Return = 1,
+ Skip = 2,
+}
+export declare class InfiniteEnumerable extends DisposableBase implements IEnumerable {
+ protected _enumeratorFactory: () => IEnumerator;
+ constructor(_enumeratorFactory: () => IEnumerator, finalizer?: () => void);
+ protected _isEndless: boolean;
+ isEndless: boolean;
+ getEnumerator(): IEnumerator;
+ protected _onDispose(): void;
+ asEnumerable(): InfiniteEnumerable;
+ doAction(action: Action | Predicate | Selector | Selector, initializer?: () => void, isEndless?: boolean): InfiniteEnumerable;
+ force(): void;
+ skip(count: number): InfiniteEnumerable;
+ take(count: number): FiniteEnumerable;
+ elementAt(index: number): T;
+ elementAtOrDefault(index: number, defaultValue?: T): T;
+ first(): T;
+ firstOrDefault(defaultValue?: T): T;
+ single(): T;
+ singleOrDefault(defaultValue?: T): T;
+ any(): boolean;
+ isEmpty(): boolean;
+ traverseBreadthFirst(childrenSelector: (element: T) => IEnumerableOrArray): Enumerable;
+ traverseBreadthFirst(childrenSelector: (element: T | TNode) => IEnumerableOrArray): Enumerable;
+ traverseBreadthFirst(childrenSelector: (element: T) => IEnumerableOrArray, resultSelector?: (element: T, nestLevel?: number) => TResult): Enumerable;
+ traverseBreadthFirst(childrenSelector: (element: T | TNode) => IEnumerableOrArray, resultSelector?: (element: TNode, nestLevel?: number) => TResult): Enumerable;
+ traverseDepthFirst(childrenSelector: (element: T) => IEnumerableOrArray): Enumerable;
+ traverseDepthFirst(childrenSelector: (element: T | TNode) => IEnumerableOrArray): Enumerable;
+ traverseDepthFirst(childrenSelector: (element: T) => IEnumerableOrArray, resultSelector?: (element: T, nestLevel?: number) => TResult): Enumerable;
+ traverseDepthFirst(childrenSelector: (element: T | TNode) => IEnumerableOrArray, resultSelector?: (element: TNode, nestLevel?: number) => TResult): Enumerable;
+ flatten(): Enumerable;
+ pairwise(selector: (prev: T, current: T) => TSelect): Enumerable;
+ scan(func: (a: T, b: T) => T, seed?: T): Enumerable;
+ select(selector: Selector): InfiniteEnumerable;
+ protected _selectMany(collectionSelector: Selector>, resultSelector?: (collection: T, element: TElement) => TResult): Enumerable;
+ selectMany(collectionSelector: Selector>): InfiniteEnumerable;
+ selectMany(collectionSelector: Selector>, resultSelector: (collection: T, element: TElement) => TResult): InfiniteEnumerable;
+ protected _choose(selector: Selector): Enumerable;
+ choose(): InfiniteEnumerable;
+ choose(selector?: Selector): InfiniteEnumerable;
+ where(predicate: Predicate): InfiniteEnumerable;
+ ofType(type: {
+ new (...params: any[]): TType;
+ }): InfiniteEnumerable;
+ except(second: IEnumerableOrArray, compareSelector?: Selector): InfiniteEnumerable;
+ distinct(compareSelector?: (value: T) => T): InfiniteEnumerable;
+ distinctUntilChanged(compareSelector?: Selector): InfiniteEnumerable;
+ defaultIfEmpty(defaultValue?: T): Enumerable;
+ zip(second: IEnumerableOrArray, resultSelector: (first: T, second: TSecond, index?: number) => TResult): Enumerable;
+ zipMultiple(second: IArray>, resultSelector: (first: T, second: TSecond, index?: number) => TResult): Enumerable;
+ join(inner: IEnumerableOrArray, outerKeySelector: Selector, innerKeySelector: Selector, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: Selector): Enumerable;
+ groupJoin(inner: IEnumerableOrArray, outerKeySelector: Selector, innerKeySelector: Selector, resultSelector: (outer: T, inner: TInner[]) => TResult, compareSelector?: Selector): Enumerable;
+ merge(enumerables: IArray>): InfiniteEnumerable;
+ concat(...enumerables: Array>): InfiniteEnumerable;
+ union(second: IEnumerableOrArray, compareSelector?: Selector): Enumerable;
+ insertAt(index: number, other: IEnumerableOrArray): Enumerable;
+ alternateMultiple(sequence: IEnumerableOrArray): Enumerable;
+ alternateSingle(value: T): Enumerable;
+ alternate(...sequence: T[]): Enumerable;
+ catchError(handler: (e: any) => void): InfiniteEnumerable;
+ finallyAction(action: () => void): InfiniteEnumerable;
+ buffer(size: number): InfiniteEnumerable;
+ share(): InfiniteEnumerable;
+}
+export declare class Enumerable extends InfiniteEnumerable {
+ constructor(enumeratorFactory: () => IEnumerator, finalizer?: () => void, isEndless?: boolean);
+ static from(source: IEnumerableOrArray): Enumerable;
+ static fromAny(source: IEnumerableOrArray): Enumerable;
+ static fromAny(source: any): Enumerable;
+ static fromOrEmpty(source: IEnumerableOrArray): Enumerable;
+ static toArray(source: IEnumerableOrArray): T[];
+ static choice(values: IArray): InfiniteEnumerable;
+ static chooseFrom(...args: T[]): InfiniteEnumerable;
+ static cycle(values: IArray): InfiniteEnumerable;
+ static cycleThrough(...args: T[]): InfiniteEnumerable;
+ static empty(): FiniteEnumerable;
+ static repeat(element: T): InfiniteEnumerable;
+ static repeat(element: T, count: number): FiniteEnumerable;
+ static repeatWithFinalize(initializer: () => T, finalizer: (element: T) => void): InfiniteEnumerable;
+ static make(element: T): FiniteEnumerable;
+ static range(start: number, count: number, step?: number): FiniteEnumerable;
+ static rangeDown(start: number, count: number, step?: number): FiniteEnumerable;
+ static toInfinity(start?: number, step?: number): InfiniteEnumerable;
+ static toNegativeInfinity(start?: number, step?: number): InfiniteEnumerable;
+ static rangeTo(start: number, to: number, step?: number): FiniteEnumerable;
+ static matches(input: string, pattern: any, flags?: string): FiniteEnumerable;
+ static generate(factory: (index?: number) => T): InfiniteEnumerable;
+ static generate(factory: (index?: number) => T, count: number): FiniteEnumerable;
+ static unfold(seed: T, valueFactory: Selector, skipSeed?: Boolean): InfiniteEnumerable;
+ static forEach(enumerable: IEnumerableOrArray, action: (element: T, index?: number) => any): void;
+ static map(enumerable: IEnumerableOrArray, selector: Selector): TResult[];
+ static max(values: FiniteEnumerable): number;
+ static min(values: FiniteEnumerable): number;
+ static weave(enumerables: IEnumerableOrArray>): Enumerable;
+ doAction(action: Action | Predicate | Selector | Selector, initializer?: () => void, isEndless?: boolean): Enumerable;
+ skip(count: number): Enumerable;
+ skipWhile(predicate: Predicate): Enumerable;
+ takeWhile(predicate: Predicate): Enumerable;
+ takeUntil(predicate: Predicate, includeUntilValue?: boolean): Enumerable;
+ forEach(action: Predicate | Action): void;
+ toArray(predicate?: Predicate): T[];
+ copyTo(target: T[], index?: number): T[];
+ toLookup(keySelector: Selector, elementSelector?: Selector, compareSelector?: Selector): ILookup;
+ toMap(keySelector: Selector, elementSelector: Selector): IMap;
+ toDictionary(keySelector: Selector, elementSelector: Selector, compareSelector?: Selector): Dictionary;
+ toJoinedString(separator?: string, selector?: Selector): string;
+ takeExceptLast(count?: number): Enumerable;
+ skipToLast(count: number): Enumerable;
+ where(predicate: Predicate): Enumerable;
+ select(selector: Selector): Enumerable;
+ selectMany(collectionSelector: Selector>): Enumerable;
+ selectMany(collectionSelector: Selector>, resultSelector: (collection: T, element: TElement) => TResult): Enumerable;
+ choose(): Enumerable;
+ choose(selector?: Selector): Enumerable;
+ reverse(): Enumerable;
+ shuffle(): Enumerable;
+ count(predicate?: Predicate): number;
+ all(predicate: Predicate): boolean;
+ every(predicate: Predicate): boolean;
+ any(predicate?: Predicate): boolean;
+ some(predicate: Predicate): boolean;
+ contains(value: T, compareSelector?: Selector): boolean;
+ indexOf(value: T, compareSelector?: Selector): number;
+ lastIndexOf(value: T, compareSelector?: Selector): number;
+ merge(enumerables: IArray>): Enumerable;
+ concat(...enumerables: Array>): Enumerable;
+ intersect(second: IEnumerableOrArray, compareSelector?: Selector): Enumerable;
+ sequenceEqual(second: IEnumerableOrArray, equalityComparer?: EqualityComparison): boolean;
+ ofType(type: {
+ new (...params: any[]): TType;
+ }): Enumerable;
+ except(second: IEnumerableOrArray, compareSelector?: Selector): Enumerable;
+ distinct(compareSelector?: (value: T) => T): Enumerable;
+ distinctUntilChanged(compareSelector?: Selector): Enumerable;
+ orderBy(keySelector?: Selector): IOrderedEnumerable;
+ orderUsing(comparison: Comparison): IOrderedEnumerable;
+ orderUsingReversed(comparison: Comparison): IOrderedEnumerable;
+ orderByDescending(keySelector?: Selector): IOrderedEnumerable