TypeScript/tests/baselines/reference/underscoreTest1.types

=== tests/cases/compiler/underscoreTest1_underscoreTests.ts ===
/// <reference path="underscoreTest1_underscore.ts" />

declare var $;
>$ : any, Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))

declare function alert(x: string): void;
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>x : string, Symbol(x, Decl(underscoreTest1_underscoreTests.ts, 3, 23))

_.each([1, 2, 3], (num) => alert(num.toString()));
>_.each([1, 2, 3], (num) => alert(num.toString())) : void
>_.each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>(num) => alert(num.toString()) : (num: number) => void
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
>alert(num.toString()) : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>num.toString() : string
>num.toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
>toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))

_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString()));
>_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())) : void
>_.each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>{ one: 1, two: 2, three: 3 } : { [x: string]: number; one: number; two: number; three: number; }
>one : number, Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 6, 8))
>1 : number
>two : number, Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 6, 16))
>2 : number
>three : number, Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 6, 24))
>3 : number
>(value: number, key?: string) => alert(value.toString()) : (value: number, key?: string) => void
>value : number, Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
>key : string, Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 6, 52))
>alert(value.toString()) : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>value.toString() : string
>value.toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
>value : number, Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
>toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))

_.map([1, 2, 3], (num) => num * 3);
>_.map([1, 2, 3], (num) => num * 3) : number[]
>_.map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>(num) => num * 3 : (num: number) => number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
>num * 3 : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
>3 : number

_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
>_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3) : number[]
>_.map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
>{ one: 1, two: 2, three: 3 } : { [x: string]: number; one: number; two: number; three: number; }
>one : number, Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 9, 7))
>1 : number
>two : number, Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 9, 15))
>2 : number
>three : number, Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 9, 23))
>3 : number
>(value: number, key?: string) => value * 3 : (value: number, key?: string) => number
>value : number, Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 9, 37))
>key : string, Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 9, 51))
>value * 3 : number
>value : number, Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 9, 37))
>3 : number

var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
>sum : number, Symbol(sum, Decl(underscoreTest1_underscoreTests.ts, 11, 3))
>_.reduce([1, 2, 3], (memo, num) => memo + num, 0) : number
>_.reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>(memo, num) => memo + num : (memo: number, num: number) => number
>memo : number, Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 11, 36))
>memo + num : number
>memo : number, Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 11, 36))
>0 : number

var list = [[0, 1], [2, 3], [4, 5]];
>list : number[][], Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3))
>[[0, 1], [2, 3], [4, 5]] : number[][]
>[0, 1] : number[]
>0 : number
>1 : number
>[2, 3] : number[]
>2 : number
>3 : number
>[4, 5] : number[]
>4 : number
>5 : number

var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
>flat : number[], Symbol(flat, Decl(underscoreTest1_underscoreTests.ts, 14, 3))
>_.reduceRight(list, (a, b) => a.concat(b), []) : number[]
>_.reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
>list : number[][], Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3))
>(a, b) => a.concat(b) : (a: number[], b: number[]) => number[]
>a : number[], Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
>b : number[], Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
>a.concat(b) : number[]
>a.concat : { <U extends number[]>(...items: U[]): number[]; (...items: number[]): number[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>a : number[], Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
>concat : { <U extends number[]>(...items: U[]): number[]; (...items: number[]): number[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>b : number[], Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
>[] : undefined[]

var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
>even : number, Symbol(even, Decl(underscoreTest1_underscoreTests.ts, 16, 3))
>_.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number
>_.find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }, Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }, Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
>[1, 2, 3, 4, 5, 6] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>6 : number
>(num) => num % 2 == 0 : (num: number) => boolean
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
>num % 2 == 0 : boolean
>num % 2 : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
>2 : number
>0 : number

var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
>evens : number[], Symbol(evens, Decl(underscoreTest1_underscoreTests.ts, 18, 3))
>_.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number[]
>_.filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
>[1, 2, 3, 4, 5, 6] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>6 : number
>(num) => num % 2 == 0 : (num: number) => boolean
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
>num % 2 == 0 : boolean
>num % 2 : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
>2 : number
>0 : number

var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }];
>listOfPlays : { title: string; author: string; year: number; }[], Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
>[{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }] : { title: string; author: string; year: number; }[]
>{ title: "Cymbeline", author: "Shakespeare", year: 1611 } : { title: string; author: string; year: number; }
>title : string, Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 20))
>"Cymbeline" : string
>author : string, Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 40))
>"Shakespeare" : string
>year : number, Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 63))
>1611 : number
>{ title: "The Tempest", author: "Shakespeare", year: 1611 } : { title: string; author: string; year: number; }
>title : string, Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 79))
>"The Tempest" : string
>author : string, Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 101))
>"Shakespeare" : string
>year : number, Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 124))
>1611 : number
>{ title: "Other", author: "Not Shakespeare", year: 2012 } : { title: string; author: string; year: number; }
>title : string, Symbol(title, Decl(underscoreTest1_underscoreTests.ts, 20, 140))
>"Other" : string
>author : string, Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 20, 156))
>"Not Shakespeare" : string
>year : number, Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 183))
>2012 : number

_.where(listOfPlays, { author: "Shakespeare", year: 1611 });
>_.where(listOfPlays, { author: "Shakespeare", year: 1611 }) : { title: string; author: string; year: number; }[]
>_.where : { <T>(list: T[], properties: Object): T[]; <T>(list: Dictionary<T>, properties: Object): T[]; }, Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 436, 91), Decl(underscoreTest1_underscore.ts, 438, 53))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>where : { <T>(list: T[], properties: Object): T[]; <T>(list: Dictionary<T>, properties: Object): T[]; }, Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 436, 91), Decl(underscoreTest1_underscore.ts, 438, 53))
>listOfPlays : { title: string; author: string; year: number; }[], Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
>{ author: "Shakespeare", year: 1611 } : { author: string; year: number; }
>author : string, Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 21, 22))
>"Shakespeare" : string
>year : number, Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 21, 45))
>1611 : number

var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
>odds : number[], Symbol(odds, Decl(underscoreTest1_underscoreTests.ts, 23, 3))
>_.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number[]
>_.reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
>[1, 2, 3, 4, 5, 6] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>6 : number
>(num) => num % 2 == 0 : (num: number) => boolean
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
>num % 2 == 0 : boolean
>num % 2 : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
>2 : number
>0 : number

_.all([true, 1, null, 'yes'], _.identity);
>_.all([true, 1, null, 'yes'], _.identity) : boolean
>_.all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 448, 95), Decl(underscoreTest1_underscore.ts, 449, 83))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 448, 95), Decl(underscoreTest1_underscore.ts, 449, 83))
>[true, 1, null, 'yes'] : (string | number | boolean)[]
>true : boolean
>1 : number
>null : null
>'yes' : string
>_.identity : <T>(value: T) => T, Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 617, 29))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>identity : <T>(value: T) => T, Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 617, 29))

_.any([null, 0, 'yes', false]);
>_.any([null, 0, 'yes', false]) : boolean
>_.any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 453, 94), Decl(underscoreTest1_underscore.ts, 454, 83))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 453, 94), Decl(underscoreTest1_underscore.ts, 454, 83))
>[null, 0, 'yes', false] : (string | number | boolean)[]
>null : null
>0 : number
>'yes' : string
>false : boolean

_.contains([1, 2, 3], 3);
>_.contains([1, 2, 3], 3) : boolean
>_.contains : { <T>(list: T[], value: T): boolean; <T>(list: Dictionary<T>, value: T): boolean; }, Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 455, 93), Decl(underscoreTest1_underscore.ts, 457, 50))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>contains : { <T>(list: T[], value: T): boolean; <T>(list: Dictionary<T>, value: T): boolean; }, Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 455, 93), Decl(underscoreTest1_underscore.ts, 457, 50))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>3 : number

_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
>_.invoke([[5, 1, 7], [3, 2, 1]], 'sort') : any[]
>_.invoke : { (list: any[], methodName: string, ...args: any[]): any[]; (list: Dictionary<any>, methodName: string, ...args: any[]): any[]; }, Symbol(Underscore.Static.invoke, Decl(underscoreTest1_underscore.ts, 460, 59), Decl(underscoreTest1_underscore.ts, 462, 71))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>invoke : { (list: any[], methodName: string, ...args: any[]): any[]; (list: Dictionary<any>, methodName: string, ...args: any[]): any[]; }, Symbol(Underscore.Static.invoke, Decl(underscoreTest1_underscore.ts, 460, 59), Decl(underscoreTest1_underscore.ts, 462, 71))
>[[5, 1, 7], [3, 2, 1]] : number[][]
>[5, 1, 7] : number[]
>5 : number
>1 : number
>7 : number
>[3, 2, 1] : number[]
>3 : number
>2 : number
>1 : number
>'sort' : string

var stooges = [{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }];
>stooges : { name: string; age: number; }[], Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
>[{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }] : { name: string; age: number; }[]
>{ name: 'moe', age: 40 } : { name: string; age: number; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 16))
>'moe' : string
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
>40 : number
>{ name: 'larry', age: 50 } : { name: string; age: number; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 42))
>'larry' : string
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 57))
>50 : number
>{ name: 'curly', age: 60 } : { name: string; age: number; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 33, 70))
>'curly' : string
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 85))
>60 : number

_.pluck(stooges, 'name');
>_.pluck(stooges, 'name') : any[]
>_.pluck : { (list: any[], propertyName: string): any[]; (list: Dictionary<any>, propertyName: string): any[]; }, Symbol(Underscore.Static.pluck, Decl(underscoreTest1_underscore.ts, 463, 81), Decl(underscoreTest1_underscore.ts, 465, 56))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>pluck : { (list: any[], propertyName: string): any[]; (list: Dictionary<any>, propertyName: string): any[]; }, Symbol(Underscore.Static.pluck, Decl(underscoreTest1_underscore.ts, 463, 81), Decl(underscoreTest1_underscore.ts, 465, 56))
>stooges : { name: string; age: number; }[], Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
>'name' : string

_.max(stooges, (stooge) => stooge.age);
>_.max(stooges, (stooge) => stooge.age) : { name: string; age: number; }
>_.max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 466, 66), Decl(underscoreTest1_underscore.ts, 468, 73))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 466, 66), Decl(underscoreTest1_underscore.ts, 468, 73))
>stooges : { name: string; age: number; }[], Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
>(stooge) => stooge.age : (stooge: { name: string; age: number; }) => number
>stooge : { name: string; age: number; }, Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
>stooge.age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
>stooge : { name: string; age: number; }, Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))

var numbers = [10, 5, 100, 2, 1000];
>numbers : number[], Symbol(numbers, Decl(underscoreTest1_underscoreTests.ts, 38, 3))
>[10, 5, 100, 2, 1000] : number[]
>10 : number
>5 : number
>100 : number
>2 : number
>1000 : number

_.min(numbers);
>_.min(numbers) : number
>_.min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 469, 83), Decl(underscoreTest1_underscore.ts, 471, 73))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 469, 83), Decl(underscoreTest1_underscore.ts, 471, 73))
>numbers : number[], Symbol(numbers, Decl(underscoreTest1_underscoreTests.ts, 38, 3))

_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
>_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)) : number[]
>_.sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }, Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }, Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
>[1, 2, 3, 4, 5, 6] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>6 : number
>(num) => Math.sin(num) : (num: number) => number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))
>Math.sin(num) : number
>Math.sin : (x: number) => number, Symbol(Math.sin, Decl(lib.d.ts, 615, 29))
>Math : Math, Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
>sin : (x: number) => number, Symbol(Math.sin, Decl(lib.d.ts, 615, 29))
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))


// not sure how this is typechecking at all.. Math.floor(e) is number not string..?
_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e));
>_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)) : Dictionary<number[]>
>_([1.3, 2.1, 2.4]).groupBy : { (iterator?: Iterator<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }, Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
>_([1.3, 2.1, 2.4]) : Underscore.WrappedArray<number>
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>[1.3, 2.1, 2.4] : number[]
>1.3 : number
>2.1 : number
>2.4 : number
>groupBy : { (iterator?: Iterator<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }, Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
>(e: number, i?: number, list?: number[]) => Math.floor(e) : (e: number, i?: number, list?: number[]) => number
>e : number, Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
>i : number, Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38))
>list : number[], Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50))
>Math.floor(e) : number
>Math.floor : (x: number) => number, Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
>Math : Math, Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
>floor : (x: number) => number, Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
>e : number, Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))

_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
>_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)) : Dictionary<number[]>
>_.groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>[1.3, 2.1, 2.4] : number[]
>1.3 : number
>2.1 : number
>2.4 : number
>(num: number) => Math.floor(num) : (num: number) => number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
>Math.floor(num) : number
>Math.floor : (x: number) => number, Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
>Math : Math, Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
>floor : (x: number) => number, Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))

_.groupBy(['one', 'two', 'three'], 'length');
>_.groupBy(['one', 'two', 'three'], 'length') : Dictionary<string[]>
>_.groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>['one', 'two', 'three'] : string[]
>'one' : string
>'two' : string
>'three' : string
>'length' : string

_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
>_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd') : Dictionary<number>
>_.countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }, Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }, Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
>[1, 2, 3, 4, 5] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>(num) => num % 2 == 0 ? 'even' : 'odd' : (num: number) => string
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
>num % 2 == 0 ? 'even' : 'odd' : string
>num % 2 == 0 : boolean
>num % 2 : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
>2 : number
>0 : number
>'even' : string
>'odd' : string

_.shuffle([1, 2, 3, 4, 5, 6]);
>_.shuffle([1, 2, 3, 4, 5, 6]) : number[]
>_.shuffle : { <T>(list: T[]): T[]; <T>(list: Dictionary<T>): T[]; }, Symbol(Underscore.Static.shuffle, Decl(underscoreTest1_underscore.ts, 487, 82), Decl(underscoreTest1_underscore.ts, 489, 35))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>shuffle : { <T>(list: T[]): T[]; <T>(list: Dictionary<T>): T[]; }, Symbol(Underscore.Static.shuffle, Decl(underscoreTest1_underscore.ts, 487, 82), Decl(underscoreTest1_underscore.ts, 489, 35))
>[1, 2, 3, 4, 5, 6] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>6 : number

// (function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);

_.size({ one: 1, two: 2, three: 3 });
>_.size({ one: 1, two: 2, three: 3 }) : number
>_.size : { <T>(list: T[]): number; <T>(list: Dictionary<T>): number; }, Symbol(Underscore.Static.size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>size : { <T>(list: T[]): number; <T>(list: Dictionary<T>): number; }, Symbol(Underscore.Static.size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
>{ one: 1, two: 2, three: 3 } : { [x: string]: number; one: number; two: number; three: number; }
>one : number, Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 55, 8))
>1 : number
>two : number, Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 55, 16))
>2 : number
>three : number, Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 55, 24))
>3 : number

///////////////////////////////////////////////////////////////////////////////////////

_.first([5, 4, 3, 2, 1]);
>_.first([5, 4, 3, 2, 1]) : number
>_.first : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(Underscore.Static.first, Decl(underscoreTest1_underscore.ts, 496, 45), Decl(underscoreTest1_underscore.ts, 498, 31))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>first : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(Underscore.Static.first, Decl(underscoreTest1_underscore.ts, 496, 45), Decl(underscoreTest1_underscore.ts, 498, 31))
>[5, 4, 3, 2, 1] : number[]
>5 : number
>4 : number
>3 : number
>2 : number
>1 : number

_.initial([5, 4, 3, 2, 1]);
>_.initial([5, 4, 3, 2, 1]) : number
>_.initial : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(Underscore.Static.initial, Decl(underscoreTest1_underscore.ts, 503, 47), Decl(underscoreTest1_underscore.ts, 505, 33))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>initial : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(Underscore.Static.initial, Decl(underscoreTest1_underscore.ts, 503, 47), Decl(underscoreTest1_underscore.ts, 505, 33))
>[5, 4, 3, 2, 1] : number[]
>5 : number
>4 : number
>3 : number
>2 : number
>1 : number

_.last([5, 4, 3, 2, 1]);
>_.last([5, 4, 3, 2, 1]) : number
>_.last : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(Underscore.Static.last, Decl(underscoreTest1_underscore.ts, 506, 50), Decl(underscoreTest1_underscore.ts, 508, 30))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>last : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(Underscore.Static.last, Decl(underscoreTest1_underscore.ts, 506, 50), Decl(underscoreTest1_underscore.ts, 508, 30))
>[5, 4, 3, 2, 1] : number[]
>5 : number
>4 : number
>3 : number
>2 : number
>1 : number

_.rest([5, 4, 3, 2, 1]);
>_.rest([5, 4, 3, 2, 1]) : number[]
>_.rest : <T>(list: T[], index?: number) => T[], Symbol(Underscore.Static.rest, Decl(underscoreTest1_underscore.ts, 509, 47))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>rest : <T>(list: T[], index?: number) => T[], Symbol(Underscore.Static.rest, Decl(underscoreTest1_underscore.ts, 509, 47))
>[5, 4, 3, 2, 1] : number[]
>5 : number
>4 : number
>3 : number
>2 : number
>1 : number

_.compact([0, 1, false, 2, '', 3]);
>_.compact([0, 1, false, 2, '', 3]) : (string | number | boolean)[]
>_.compact : <T>(list: T[]) => T[], Symbol(Underscore.Static.compact, Decl(underscoreTest1_underscore.ts, 511, 48))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>compact : <T>(list: T[]) => T[], Symbol(Underscore.Static.compact, Decl(underscoreTest1_underscore.ts, 511, 48))
>[0, 1, false, 2, '', 3] : (string | number | boolean)[]
>0 : number
>1 : number
>false : boolean
>2 : number
>'' : string
>3 : number

_.flatten([1, 2, 3, 4]);
>_.flatten([1, 2, 3, 4]) : {}[]
>_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>[1, 2, 3, 4] : number[]
>1 : number
>2 : number
>3 : number
>4 : number

_.flatten([1, [2]]);
>_.flatten([1, [2]]) : {}[]
>_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>[1, [2]] : (number | number[])[]
>1 : number
>[2] : number[]
>2 : number

// typescript doesn't like the elements being different
_.flatten([1, [2], [3, [[4]]]]);
>_.flatten([1, [2], [3, [[4]]]]) : {}[]
>_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>[1, [2], [3, [[4]]]] : (number | (number | number[][])[])[]
>1 : number
>[2] : number[]
>2 : number
>[3, [[4]]] : (number | number[][])[]
>3 : number
>[[4]] : number[][]
>[4] : number[]
>4 : number

_.flatten([1, [2], [3, [[4]]]], true);
>_.flatten([1, [2], [3, [[4]]]], true) : {}[]
>_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(Underscore.Static.flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>[1, [2], [3, [[4]]]] : (number | (number | number[][])[])[]
>1 : number
>[2] : number[]
>2 : number
>[3, [[4]]] : (number | number[][])[]
>3 : number
>[[4]] : number[][]
>[4] : number[]
>4 : number
>true : boolean

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
>_.without([1, 2, 1, 0, 3, 1, 4], 0, 1) : number[]
>_.without : <T>(list: T[], ...values: T[]) => T[], Symbol(Underscore.Static.without, Decl(underscoreTest1_underscore.ts, 516, 57))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>without : <T>(list: T[], ...values: T[]) => T[], Symbol(Underscore.Static.without, Decl(underscoreTest1_underscore.ts, 516, 57))
>[1, 2, 1, 0, 3, 1, 4] : number[]
>1 : number
>2 : number
>1 : number
>0 : number
>3 : number
>1 : number
>4 : number
>0 : number
>1 : number

_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
>_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]) : number[]
>_.union : <T>(...arrays: T[][]) => T[], Symbol(Underscore.Static.union, Decl(underscoreTest1_underscore.ts, 518, 51))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>union : <T>(...arrays: T[][]) => T[], Symbol(Underscore.Static.union, Decl(underscoreTest1_underscore.ts, 518, 51))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>[101, 2, 1, 10] : number[]
>101 : number
>2 : number
>1 : number
>10 : number
>[2, 1] : number[]
>2 : number
>1 : number

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
>_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]) : number[]
>_.intersection : <T>(...arrays: T[][]) => T[], Symbol(Underscore.Static.intersection, Decl(underscoreTest1_underscore.ts, 520, 40))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>intersection : <T>(...arrays: T[][]) => T[], Symbol(Underscore.Static.intersection, Decl(underscoreTest1_underscore.ts, 520, 40))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>[101, 2, 1, 10] : number[]
>101 : number
>2 : number
>1 : number
>10 : number
>[2, 1] : number[]
>2 : number
>1 : number

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
>_.difference([1, 2, 3, 4, 5], [5, 2, 10]) : number[]
>_.difference : <T>(list: T[], ...others: T[][]) => T[], Symbol(Underscore.Static.difference, Decl(underscoreTest1_underscore.ts, 522, 47))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>difference : <T>(list: T[], ...others: T[][]) => T[], Symbol(Underscore.Static.difference, Decl(underscoreTest1_underscore.ts, 522, 47))
>[1, 2, 3, 4, 5] : number[]
>1 : number
>2 : number
>3 : number
>4 : number
>5 : number
>[5, 2, 10] : number[]
>5 : number
>2 : number
>10 : number

_.uniq([1, 2, 1, 3, 1, 4]);
>_.uniq([1, 2, 1, 3, 1, 4]) : number[]
>_.uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(Underscore.Static.uniq, Decl(underscoreTest1_underscore.ts, 524, 56), Decl(underscoreTest1_underscore.ts, 526, 52))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(Underscore.Static.uniq, Decl(underscoreTest1_underscore.ts, 524, 56), Decl(underscoreTest1_underscore.ts, 526, 52))
>[1, 2, 1, 3, 1, 4] : number[]
>1 : number
>2 : number
>1 : number
>3 : number
>1 : number
>4 : number

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
>_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]) : Tuple3<string, number, boolean>[]
>_.zip : { <T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[]; <T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[]; <T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[]; (...arrays: any[][]): any[][]; }, Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 529, 97), Decl(underscoreTest1_underscore.ts, 531, 58), Decl(underscoreTest1_underscore.ts, 532, 76), Decl(underscoreTest1_underscore.ts, 533, 94))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>zip : { <T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[]; <T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[]; <T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[]; (...arrays: any[][]): any[][]; }, Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 529, 97), Decl(underscoreTest1_underscore.ts, 531, 58), Decl(underscoreTest1_underscore.ts, 532, 76), Decl(underscoreTest1_underscore.ts, 533, 94))
>['moe', 'larry', 'curly'] : string[]
>'moe' : string
>'larry' : string
>'curly' : string
>[30, 40, 50] : number[]
>30 : number
>40 : number
>50 : number
>[true, false, false] : boolean[]
>true : boolean
>false : boolean
>false : boolean

_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
>_.object(['moe', 'larry', 'curly'], [30, 40, 50]) : any
>_.object : { (list: any[][]): any; (keys: string[], values: any[]): any; }, Symbol(Underscore.Static.object, Decl(underscoreTest1_underscore.ts, 534, 41), Decl(underscoreTest1_underscore.ts, 536, 35))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>object : { (list: any[][]): any; (keys: string[], values: any[]): any; }, Symbol(Underscore.Static.object, Decl(underscoreTest1_underscore.ts, 534, 41), Decl(underscoreTest1_underscore.ts, 536, 35))
>['moe', 'larry', 'curly'] : string[]
>'moe' : string
>'larry' : string
>'curly' : string
>[30, 40, 50] : number[]
>30 : number
>40 : number
>50 : number

_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
>_.object([['moe', 30], ['larry', 40], ['curly', 50]]) : any
>_.object : { (list: any[][]): any; (keys: string[], values: any[]): any; }, Symbol(Underscore.Static.object, Decl(underscoreTest1_underscore.ts, 534, 41), Decl(underscoreTest1_underscore.ts, 536, 35))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>object : { (list: any[][]): any; (keys: string[], values: any[]): any; }, Symbol(Underscore.Static.object, Decl(underscoreTest1_underscore.ts, 534, 41), Decl(underscoreTest1_underscore.ts, 536, 35))
>[['moe', 30], ['larry', 40], ['curly', 50]] : (string | number)[][]
>['moe', 30] : (string | number)[]
>'moe' : string
>30 : number
>['larry', 40] : (string | number)[]
>'larry' : string
>40 : number
>['curly', 50] : (string | number)[]
>'curly' : string
>50 : number

_.indexOf([1, 2, 3], 2);
>_.indexOf([1, 2, 3], 2) : number
>_.indexOf : <T>(list: T[], value: T, isSorted?: boolean) => number, Symbol(Underscore.Static.indexOf, Decl(underscoreTest1_underscore.ts, 537, 51))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>indexOf : <T>(list: T[], value: T, isSorted?: boolean) => number, Symbol(Underscore.Static.indexOf, Decl(underscoreTest1_underscore.ts, 537, 51))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>2 : number

_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
>_.lastIndexOf([1, 2, 3, 1, 2, 3], 2) : number
>_.lastIndexOf : <T>(list: T[], value: T, fromIndex?: number) => number, Symbol(Underscore.Static.lastIndexOf, Decl(underscoreTest1_underscore.ts, 539, 68))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>lastIndexOf : <T>(list: T[], value: T, fromIndex?: number) => number, Symbol(Underscore.Static.lastIndexOf, Decl(underscoreTest1_underscore.ts, 539, 68))
>[1, 2, 3, 1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
>1 : number
>2 : number
>3 : number
>2 : number

_.sortedIndex([10, 20, 30, 40, 50], 35);
>_.sortedIndex([10, 20, 30, 40, 50], 35) : number
>_.sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }, Symbol(Underscore.Static.sortedIndex, Decl(underscoreTest1_underscore.ts, 541, 72), Decl(underscoreTest1_underscore.ts, 543, 72))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }, Symbol(Underscore.Static.sortedIndex, Decl(underscoreTest1_underscore.ts, 541, 72), Decl(underscoreTest1_underscore.ts, 543, 72))
>[10, 20, 30, 40, 50] : number[]
>10 : number
>20 : number
>30 : number
>40 : number
>50 : number
>35 : number

_.range(10);
>_.range(10) : number[]
>_.range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>10 : number

_.range(1, 11);
>_.range(1, 11) : number[]
>_.range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>1 : number
>11 : number

_.range(0, 30, 5);
>_.range(0, 30, 5) : number[]
>_.range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>0 : number
>30 : number
>5 : number

_.range(0, 30, 5);
>_.range(0, 30, 5) : number[]
>_.range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>0 : number
>30 : number
>5 : number

_.range(0);
>_.range(0) : number[]
>_.range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>0 : number

///////////////////////////////////////////////////////////////////////////////////////

var func = function (greeting) { return greeting + ': ' + this.name };
>func : (greeting: any) => string, Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 90, 3))
>function (greeting) { return greeting + ': ' + this.name } : (greeting: any) => string
>greeting : any, Symbol(greeting, Decl(underscoreTest1_underscoreTests.ts, 90, 21))
>greeting + ': ' + this.name : string
>greeting + ': ' : string
>greeting : any, Symbol(greeting, Decl(underscoreTest1_underscoreTests.ts, 90, 21))
>': ' : string
>this.name : any
>this : any
>name : any

// need a second var otherwise typescript thinks func signature is the above func type,
// instead of the newly returned _bind => func type.
var func2 = _.bind(func, { name: 'moe' }, 'hi');
>func2 : Function, Symbol(func2, Decl(underscoreTest1_underscoreTests.ts, 93, 3))
>_.bind(func, { name: 'moe' }, 'hi') : Function
>_.bind : { <T extends Function>(func: T, object: any): T; (func: Function, object: any, ...args: any[]): Function; }, Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>bind : { <T extends Function>(func: T, object: any): T; (func: Function, object: any, ...args: any[]): Function; }, Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
>func : (greeting: any) => string, Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 90, 3))
>{ name: 'moe' } : { name: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 93, 26))
>'moe' : string
>'hi' : string

func2();
>func2() : any
>func2 : Function, Symbol(func2, Decl(underscoreTest1_underscoreTests.ts, 93, 3))

var buttonView = {
>buttonView : { label: string; onClick: () => void; onHover: () => void; }, Symbol(buttonView, Decl(underscoreTest1_underscoreTests.ts, 96, 3))
>{    label: 'underscore',    onClick: function () { alert('clicked: ' + this.label); },    onHover: function () { alert('hovering: ' + this.label); }} : { label: string; onClick: () => void; onHover: () => void; }

    label: 'underscore',
>label : string, Symbol(label, Decl(underscoreTest1_underscoreTests.ts, 96, 18))
>'underscore' : string

    onClick: function () { alert('clicked: ' + this.label); },
>onClick : () => void, Symbol(onClick, Decl(underscoreTest1_underscoreTests.ts, 97, 24))
>function () { alert('clicked: ' + this.label); } : () => void
>alert('clicked: ' + this.label) : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>'clicked: ' + this.label : string
>'clicked: ' : string
>this.label : any
>this : any
>label : any

    onHover: function () { alert('hovering: ' + this.label); }
>onHover : () => void, Symbol(onHover, Decl(underscoreTest1_underscoreTests.ts, 98, 62))
>function () { alert('hovering: ' + this.label); } : () => void
>alert('hovering: ' + this.label) : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>'hovering: ' + this.label : string
>'hovering: ' : string
>this.label : any
>this : any
>label : any

};
_.bindAll(buttonView);
>_.bindAll(buttonView) : { label: string; onClick: () => void; onHover: () => void; }
>_.bindAll : <T>(object: T, ...methodNames: string[]) => T, Symbol(Underscore.Static.bindAll, Decl(underscoreTest1_underscore.ts, 550, 68))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>bindAll : <T>(object: T, ...methodNames: string[]) => T, Symbol(Underscore.Static.bindAll, Decl(underscoreTest1_underscore.ts, 550, 68))
>buttonView : { label: string; onClick: () => void; onHover: () => void; }, Symbol(buttonView, Decl(underscoreTest1_underscoreTests.ts, 96, 3))

$('#underscore_button').bind('click', buttonView.onClick);
>$('#underscore_button').bind('click', buttonView.onClick) : any
>$('#underscore_button').bind : any
>$('#underscore_button') : any
>$ : any, Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
>'#underscore_button' : string
>bind : any
>'click' : string
>buttonView.onClick : () => void, Symbol(onClick, Decl(underscoreTest1_underscoreTests.ts, 97, 24))
>buttonView : { label: string; onClick: () => void; onHover: () => void; }, Symbol(buttonView, Decl(underscoreTest1_underscoreTests.ts, 96, 3))
>onClick : () => void, Symbol(onClick, Decl(underscoreTest1_underscoreTests.ts, 97, 24))

var fibonacci = _.memoize(function (n) {
>fibonacci : (n: any) => any, Symbol(fibonacci, Decl(underscoreTest1_underscoreTests.ts, 104, 3))
>_.memoize(function (n) {    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);}) : (n: any) => any
>_.memoize : <T extends Function>(func: T, hashFunction?: Function) => T, Symbol(Underscore.Static.memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>memoize : <T extends Function>(func: T, hashFunction?: Function) => T, Symbol(Underscore.Static.memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
>function (n) {    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);} : (n: any) => any
>n : any, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))

    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
>n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2) : any
>n < 2 : boolean
>n : any, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))
>2 : number
>n : any, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))
>fibonacci(n - 1) + fibonacci(n - 2) : any
>fibonacci(n - 1) : any
>fibonacci : (n: any) => any, Symbol(fibonacci, Decl(underscoreTest1_underscoreTests.ts, 104, 3))
>n - 1 : number
>n : any, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))
>1 : number
>fibonacci(n - 2) : any
>fibonacci : (n: any) => any, Symbol(fibonacci, Decl(underscoreTest1_underscoreTests.ts, 104, 3))
>n - 2 : number
>n : any, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 104, 36))
>2 : number

});

var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
>log : (message?: string, ...rest: string[]) => void, Symbol(log, Decl(underscoreTest1_underscoreTests.ts, 108, 3))
>_.bind((message?: string, ...rest: string[]) => { }, Date) : (message?: string, ...rest: string[]) => void
>_.bind : { <T extends Function>(func: T, object: any): T; (func: Function, object: any, ...args: any[]): Function; }, Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>bind : { <T extends Function>(func: T, object: any): T; (func: Function, object: any, ...args: any[]): Function; }, Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
>(message?: string, ...rest: string[]) => { } : (message?: string, ...rest: string[]) => void
>message : string, Symbol(message, Decl(underscoreTest1_underscoreTests.ts, 108, 18))
>rest : string[], Symbol(rest, Decl(underscoreTest1_underscoreTests.ts, 108, 35))
>Date : DateConstructor, Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))

_.delay(log, 1000, 'logged later');
>_.delay(log, 1000, 'logged later') : number
>_.delay : (func: Function, wait: number, ...args: any[]) => number, Symbol(Underscore.Static.delay, Decl(underscoreTest1_underscore.ts, 556, 73))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>delay : (func: Function, wait: number, ...args: any[]) => number, Symbol(Underscore.Static.delay, Decl(underscoreTest1_underscore.ts, 556, 73))
>log : (message?: string, ...rest: string[]) => void, Symbol(log, Decl(underscoreTest1_underscoreTests.ts, 108, 3))
>1000 : number
>'logged later' : string

_.defer(function () { alert('deferred'); });
>_.defer(function () { alert('deferred'); }) : number
>_.defer : (func: Function, ...args: any[]) => number, Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 558, 68))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>defer : (func: Function, ...args: any[]) => number, Symbol(Underscore.Static.defer, Decl(underscoreTest1_underscore.ts, 558, 68))
>function () { alert('deferred'); } : () => void
>alert('deferred') : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>'deferred' : string

var updatePosition = () => alert('updating position...');
>updatePosition : () => void, Symbol(updatePosition, Decl(underscoreTest1_underscoreTests.ts, 113, 3))
>() => alert('updating position...') : () => void
>alert('updating position...') : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>'updating position...' : string

var throttled = _.throttle(updatePosition, 100);
>throttled : () => void, Symbol(throttled, Decl(underscoreTest1_underscoreTests.ts, 114, 3))
>_.throttle(updatePosition, 100) : () => void
>_.throttle : <T extends Function>(func: T, wait: number) => T, Symbol(Underscore.Static.throttle, Decl(underscoreTest1_underscore.ts, 560, 54))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>throttle : <T extends Function>(func: T, wait: number) => T, Symbol(Underscore.Static.throttle, Decl(underscoreTest1_underscore.ts, 560, 54))
>updatePosition : () => void, Symbol(updatePosition, Decl(underscoreTest1_underscoreTests.ts, 113, 3))
>100 : number

$(null).scroll(throttled);
>$(null).scroll(throttled) : any
>$(null).scroll : any
>$(null) : any
>$ : any, Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
>null : null
>scroll : any
>throttled : () => void, Symbol(throttled, Decl(underscoreTest1_underscoreTests.ts, 114, 3))

var calculateLayout = () => alert('calculating layout...');
>calculateLayout : () => void, Symbol(calculateLayout, Decl(underscoreTest1_underscoreTests.ts, 117, 3))
>() => alert('calculating layout...') : () => void
>alert('calculating layout...') : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>'calculating layout...' : string

var lazyLayout = _.debounce(calculateLayout, 300);
>lazyLayout : () => void, Symbol(lazyLayout, Decl(underscoreTest1_underscoreTests.ts, 118, 3))
>_.debounce(calculateLayout, 300) : () => void
>_.debounce : <T extends Function>(func: T, wait: number, immediate?: boolean) => T, Symbol(Underscore.Static.debounce, Decl(underscoreTest1_underscore.ts, 562, 63))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>debounce : <T extends Function>(func: T, wait: number, immediate?: boolean) => T, Symbol(Underscore.Static.debounce, Decl(underscoreTest1_underscore.ts, 562, 63))
>calculateLayout : () => void, Symbol(calculateLayout, Decl(underscoreTest1_underscoreTests.ts, 117, 3))
>300 : number

$(null).resize(lazyLayout);
>$(null).resize(lazyLayout) : any
>$(null).resize : any
>$(null) : any
>$ : any, Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
>null : null
>resize : any
>lazyLayout : () => void, Symbol(lazyLayout, Decl(underscoreTest1_underscoreTests.ts, 118, 3))

var createApplication = () => alert('creating application...');
>createApplication : () => void, Symbol(createApplication, Decl(underscoreTest1_underscoreTests.ts, 121, 3))
>() => alert('creating application...') : () => void
>alert('creating application...') : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>'creating application...' : string

var initialize = _.once(createApplication);
>initialize : () => void, Symbol(initialize, Decl(underscoreTest1_underscoreTests.ts, 122, 3))
>_.once(createApplication) : () => void
>_.once : <T extends Function>(func: T) => T, Symbol(Underscore.Static.once, Decl(underscoreTest1_underscore.ts, 564, 84))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>once : <T extends Function>(func: T) => T, Symbol(Underscore.Static.once, Decl(underscoreTest1_underscore.ts, 564, 84))
>createApplication : () => void, Symbol(createApplication, Decl(underscoreTest1_underscoreTests.ts, 121, 3))

initialize();
>initialize() : void
>initialize : () => void, Symbol(initialize, Decl(underscoreTest1_underscoreTests.ts, 122, 3))

initialize();
>initialize() : void
>initialize : () => void, Symbol(initialize, Decl(underscoreTest1_underscoreTests.ts, 122, 3))

var notes: any[];
>notes : any[], Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))

var render = () => alert("rendering...");
>render : () => void, Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))
>() => alert("rendering...") : () => void
>alert("rendering...") : void
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
>"rendering..." : string

var renderNotes = _.after(notes.length, render);
>renderNotes : () => void, Symbol(renderNotes, Decl(underscoreTest1_underscoreTests.ts, 128, 3))
>_.after(notes.length, render) : () => void
>_.after : <T extends Function>(count: number, func: T) => T, Symbol(Underscore.Static.after, Decl(underscoreTest1_underscore.ts, 566, 45))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>after : <T extends Function>(count: number, func: T) => T, Symbol(Underscore.Static.after, Decl(underscoreTest1_underscore.ts, 566, 45))
>notes.length : number, Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
>notes : any[], Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))
>length : number, Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
>render : () => void, Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))

_.each(notes, (note) => note.asyncSave({ success: renderNotes }));
>_.each(notes, (note) => note.asyncSave({ success: renderNotes })) : void
>_.each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>notes : any[], Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))
>(note) => note.asyncSave({ success: renderNotes }) : (note: any) => any
>note : any, Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
>note.asyncSave({ success: renderNotes }) : any
>note.asyncSave : any
>note : any, Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
>asyncSave : any
>{ success: renderNotes } : { success: () => void; }
>success : () => void, Symbol(success, Decl(underscoreTest1_underscoreTests.ts, 129, 40))
>renderNotes : () => void, Symbol(renderNotes, Decl(underscoreTest1_underscoreTests.ts, 128, 3))

var hello = function (name) { return "hello: " + name; };
>hello : (name: any) => string, Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
>function (name) { return "hello: " + name; } : (name: any) => string
>name : any, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 131, 22))
>"hello: " + name : string
>"hello: " : string
>name : any, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 131, 22))

hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"; });
>hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"; }) : (name: any) => string
>hello : (name: any) => string, Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
>_.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"; }) : (name: any) => string
>_.wrap : <T extends Function>(func: T, wrapper: (func: T, ...args: any[]) => any) => T, Symbol(Underscore.Static.wrap, Decl(underscoreTest1_underscore.ts, 568, 61))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>wrap : <T extends Function>(func: T, wrapper: (func: T, ...args: any[]) => any) => T, Symbol(Underscore.Static.wrap, Decl(underscoreTest1_underscore.ts, 568, 61))
>hello : (name: any) => string, Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
>(func, arg) => { return "before, " + func(arg) + ", after"; } : (func: (name: any) => string, arg: any) => string
>func : (name: any) => string, Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 132, 23))
>arg : any, Symbol(arg, Decl(underscoreTest1_underscoreTests.ts, 132, 28))
>"before, " + func(arg) + ", after" : string
>"before, " + func(arg) : string
>"before, " : string
>func(arg) : string
>func : (name: any) => string, Symbol(func, Decl(underscoreTest1_underscoreTests.ts, 132, 23))
>arg : any, Symbol(arg, Decl(underscoreTest1_underscoreTests.ts, 132, 28))
>", after" : string

hello("moe");
>hello("moe") : string
>hello : (name: any) => string, Symbol(hello, Decl(underscoreTest1_underscoreTests.ts, 131, 3))
>"moe" : string

var greet = function (name) { return "hi: " + name; };
>greet : (name: any) => string, Symbol(greet, Decl(underscoreTest1_underscoreTests.ts, 135, 3))
>function (name) { return "hi: " + name; } : (name: any) => string
>name : any, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 135, 22))
>"hi: " + name : string
>"hi: " : string
>name : any, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 135, 22))

var exclaim = function (statement) { return statement + "!"; };
>exclaim : (statement: any) => string, Symbol(exclaim, Decl(underscoreTest1_underscoreTests.ts, 136, 3))
>function (statement) { return statement + "!"; } : (statement: any) => string
>statement : any, Symbol(statement, Decl(underscoreTest1_underscoreTests.ts, 136, 24))
>statement + "!" : string
>statement : any, Symbol(statement, Decl(underscoreTest1_underscoreTests.ts, 136, 24))
>"!" : string

var welcome = _.compose(exclaim, greet);
>welcome : Function, Symbol(welcome, Decl(underscoreTest1_underscoreTests.ts, 137, 3))
>_.compose(exclaim, greet) : Function
>_.compose : (...funcs: Function[]) => Function, Symbol(Underscore.Static.compose, Decl(underscoreTest1_underscore.ts, 570, 88))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>compose : (...funcs: Function[]) => Function, Symbol(Underscore.Static.compose, Decl(underscoreTest1_underscore.ts, 570, 88))
>exclaim : (statement: any) => string, Symbol(exclaim, Decl(underscoreTest1_underscoreTests.ts, 136, 3))
>greet : (name: any) => string, Symbol(greet, Decl(underscoreTest1_underscoreTests.ts, 135, 3))

welcome('moe');
>welcome('moe') : any
>welcome : Function, Symbol(welcome, Decl(underscoreTest1_underscoreTests.ts, 137, 3))
>'moe' : string

///////////////////////////////////////////////////////////////////////////////////////

_.keys({ one: 1, two: 2, three: 3 });
>_.keys({ one: 1, two: 2, three: 3 }) : string[]
>_.keys : (object: any) => string[], Symbol(Underscore.Static.keys, Decl(underscoreTest1_underscore.ts, 572, 48))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>keys : (object: any) => string[], Symbol(Underscore.Static.keys, Decl(underscoreTest1_underscore.ts, 572, 48))
>{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; }
>one : number, Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 142, 8))
>1 : number
>two : number, Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 142, 16))
>2 : number
>three : number, Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 142, 24))
>3 : number

_.values({ one: 1, two: 2, three: 3 });
>_.values({ one: 1, two: 2, three: 3 }) : any[]
>_.values : (object: any) => any[], Symbol(Underscore.Static.values, Decl(underscoreTest1_underscore.ts, 574, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>values : (object: any) => any[], Symbol(Underscore.Static.values, Decl(underscoreTest1_underscore.ts, 574, 36))
>{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; }
>one : number, Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 143, 10))
>1 : number
>two : number, Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 143, 18))
>2 : number
>three : number, Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 143, 26))
>3 : number

_.pairs({ one: 1, two: 2, three: 3 });
>_.pairs({ one: 1, two: 2, three: 3 }) : any[][]
>_.pairs : (object: any) => any[][], Symbol(Underscore.Static.pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>pairs : (object: any) => any[][], Symbol(Underscore.Static.pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
>{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; }
>one : number, Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 144, 9))
>1 : number
>two : number, Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 144, 17))
>2 : number
>three : number, Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 144, 25))
>3 : number

_.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" });
>_.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" }) : any
>_.invert : (object: any) => any, Symbol(Underscore.Static.invert, Decl(underscoreTest1_underscore.ts, 578, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>invert : (object: any) => any, Symbol(Underscore.Static.invert, Decl(underscoreTest1_underscore.ts, 578, 36))
>{ Moe: "Moses", Larry: "Louis", Curly: "Jerome" } : { Moe: string; Larry: string; Curly: string; }
>Moe : string, Symbol(Moe, Decl(underscoreTest1_underscoreTests.ts, 145, 10))
>"Moses" : string
>Larry : string, Symbol(Larry, Decl(underscoreTest1_underscoreTests.ts, 145, 24))
>"Louis" : string
>Curly : string, Symbol(Curly, Decl(underscoreTest1_underscoreTests.ts, 145, 40))
>"Jerome" : string

_.functions(_);
>_.functions(_) : string[]
>_.functions : (object: any) => string[], Symbol(Underscore.Static.functions, Decl(underscoreTest1_underscore.ts, 580, 33))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>functions : (object: any) => string[], Symbol(Underscore.Static.functions, Decl(underscoreTest1_underscore.ts, 580, 33))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))

_.extend({ name: 'moe' }, { age: 50 });
>_.extend({ name: 'moe' }, { age: 50 }) : { name: string; }
>_.extend : <T>(destination: T, ...sources: any[]) => T, Symbol(Underscore.Static.extend, Decl(underscoreTest1_underscore.ts, 583, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>extend : <T>(destination: T, ...sources: any[]) => T, Symbol(Underscore.Static.extend, Decl(underscoreTest1_underscore.ts, 583, 39))
>{ name: 'moe' } : { name: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 147, 10))
>'moe' : string
>{ age: 50 } : { age: number; }
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 147, 27))
>50 : number

_.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age');
>_.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age') : { name: string; age: number; userid: string; }
>_.pick : <T>(object: T, ...keys: string[]) => T, Symbol(Underscore.Static.pick, Decl(underscoreTest1_underscore.ts, 585, 56))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>pick : <T>(object: T, ...keys: string[]) => T, Symbol(Underscore.Static.pick, Decl(underscoreTest1_underscore.ts, 585, 56))
>{ name: 'moe', age: 50, userid: 'moe1' } : { name: string; age: number; userid: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 148, 8))
>'moe' : string
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 148, 21))
>50 : number
>userid : string, Symbol(userid, Decl(underscoreTest1_underscoreTests.ts, 148, 30))
>'moe1' : string
>'name' : string
>'age' : string

_.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid');
>_.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid') : { name: string; age: number; userid: string; }
>_.omit : <T>(object: T, ...keys: string[]) => T, Symbol(Underscore.Static.omit, Decl(underscoreTest1_underscore.ts, 587, 49))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>omit : <T>(object: T, ...keys: string[]) => T, Symbol(Underscore.Static.omit, Decl(underscoreTest1_underscore.ts, 587, 49))
>{ name: 'moe', age: 50, userid: 'moe1' } : { name: string; age: number; userid: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 149, 8))
>'moe' : string
>age : number, Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 149, 21))
>50 : number
>userid : string, Symbol(userid, Decl(underscoreTest1_underscoreTests.ts, 149, 30))
>'moe1' : string
>'userid' : string

var iceCream = { flavor: "chocolate" };
>iceCream : { flavor: string; }, Symbol(iceCream, Decl(underscoreTest1_underscoreTests.ts, 151, 3))
>{ flavor: "chocolate" } : { flavor: string; }
>flavor : string, Symbol(flavor, Decl(underscoreTest1_underscoreTests.ts, 151, 16))
>"chocolate" : string

_.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
>_.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" }) : { flavor: string; }
>_.defaults : <T>(object: T, ...defaults: any[]) => T, Symbol(Underscore.Static.defaults, Decl(underscoreTest1_underscore.ts, 589, 49))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>defaults : <T>(object: T, ...defaults: any[]) => T, Symbol(Underscore.Static.defaults, Decl(underscoreTest1_underscore.ts, 589, 49))
>iceCream : { flavor: string; }, Symbol(iceCream, Decl(underscoreTest1_underscoreTests.ts, 151, 3))
>{ flavor: "vanilla", sprinkles: "lots" } : { flavor: string; sprinkles: string; }
>flavor : string, Symbol(flavor, Decl(underscoreTest1_underscoreTests.ts, 152, 22))
>"vanilla" : string
>sprinkles : string, Symbol(sprinkles, Decl(underscoreTest1_underscoreTests.ts, 152, 41))
>"lots" : string

_.clone({ name: 'moe' });
>_.clone({ name: 'moe' }) : { name: string; }
>_.clone : <T>(object: T) => T, Symbol(Underscore.Static.clone, Decl(underscoreTest1_underscore.ts, 591, 54))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>clone : <T>(object: T) => T, Symbol(Underscore.Static.clone, Decl(underscoreTest1_underscore.ts, 591, 54))
>{ name: 'moe' } : { name: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 154, 9))
>'moe' : string

_.chain([1, 2, 3, 200])
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num })    .value() : number[]
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num })    .value : () => number[], Symbol(Underscore.ChainedObject.value, Decl(underscoreTest1_underscore.ts, 234, 46))
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num }) : Underscore.ChainedArray<number>
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map : <U>(iterator: Iterator<number, U>, context?: any) => Underscore.ChainedArray<U>, Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert) : Underscore.ChainedArray<number>
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray<number>, Symbol(Underscore.ChainedArray.tap, Decl(underscoreTest1_underscore.ts, 325, 33))
>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; }) : Underscore.ChainedArray<number>
>_.chain([1, 2, 3, 200])    .filter : (iterator: Iterator<number, boolean>, context?: any) => Underscore.ChainedArray<number>, Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
>_.chain([1, 2, 3, 200]) : Underscore.ChainedArray<number>
>_.chain : { <T>(list: T[]): Underscore.ChainedArray<T>; <T>(list: Dictionary<T>): Underscore.ChainedDictionary<T>; <T>(obj: T): Underscore.ChainedObject<T>; }, Symbol(Underscore.Static.chain, Decl(underscoreTest1_underscore.ts, 390, 38), Decl(underscoreTest1_underscore.ts, 392, 45), Decl(underscoreTest1_underscore.ts, 393, 60))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>chain : { <T>(list: T[]): Underscore.ChainedArray<T>; <T>(list: Dictionary<T>): Underscore.ChainedDictionary<T>; <T>(obj: T): Underscore.ChainedObject<T>; }, Symbol(Underscore.Static.chain, Decl(underscoreTest1_underscore.ts, 390, 38), Decl(underscoreTest1_underscore.ts, 392, 45), Decl(underscoreTest1_underscore.ts, 393, 60))
>[1, 2, 3, 200] : number[]
>1 : number
>2 : number
>3 : number
>200 : number

    .filter(function (num) { return num % 2 == 0; })
>filter : (iterator: Iterator<number, boolean>, context?: any) => Underscore.ChainedArray<number>, Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
>function (num) { return num % 2 == 0; } : (num: number) => boolean
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
>num % 2 == 0 : boolean
>num % 2 : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
>2 : number
>0 : number

    .tap(<any>alert)
>tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray<number>, Symbol(Underscore.ChainedArray.tap, Decl(underscoreTest1_underscore.ts, 325, 33))
><any>alert : any
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))

    .map(function (num) { return num * num })
>map : <U>(iterator: Iterator<number, U>, context?: any) => Underscore.ChainedArray<U>, Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
>function (num) { return num * num } : (num: number) => number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
>num * num : number
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
>num : number, Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))

    .value();
>value : () => number[], Symbol(Underscore.ChainedObject.value, Decl(underscoreTest1_underscore.ts, 234, 46))

_.has({ a: 1, b: 2, c: 3 }, "b");
>_.has({ a: 1, b: 2, c: 3 }, "b") : boolean
>_.has : (object: any, key: string) => boolean, Symbol(Underscore.Static.has, Decl(underscoreTest1_underscore.ts, 595, 63))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>has : (object: any, key: string) => boolean, Symbol(Underscore.Static.has, Decl(underscoreTest1_underscore.ts, 595, 63))
>{ a: 1, b: 2, c: 3 } : { a: number; b: number; c: number; }
>a : number, Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 162, 7))
>1 : number
>b : number, Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 162, 13))
>2 : number
>c : number, Symbol(c, Decl(underscoreTest1_underscoreTests.ts, 162, 19))
>3 : number
>"b" : string

var moe = { name: 'moe', luckyNumbers: [13, 27, 34] };
>moe : { name: string; luckyNumbers: number[]; }, Symbol(moe, Decl(underscoreTest1_underscoreTests.ts, 164, 3))
>{ name: 'moe', luckyNumbers: [13, 27, 34] } : { name: string; luckyNumbers: number[]; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 164, 11))
>'moe' : string
>luckyNumbers : number[], Symbol(luckyNumbers, Decl(underscoreTest1_underscoreTests.ts, 164, 24))
>[13, 27, 34] : number[]
>13 : number
>27 : number
>34 : number

var clone = { name: 'moe', luckyNumbers: [13, 27, 34] };
>clone : { name: string; luckyNumbers: number[]; }, Symbol(clone, Decl(underscoreTest1_underscoreTests.ts, 165, 3))
>{ name: 'moe', luckyNumbers: [13, 27, 34] } : { name: string; luckyNumbers: number[]; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 165, 13))
>'moe' : string
>luckyNumbers : number[], Symbol(luckyNumbers, Decl(underscoreTest1_underscoreTests.ts, 165, 26))
>[13, 27, 34] : number[]
>13 : number
>27 : number
>34 : number

moe == clone;
>moe == clone : boolean
>moe : { name: string; luckyNumbers: number[]; }, Symbol(moe, Decl(underscoreTest1_underscoreTests.ts, 164, 3))
>clone : { name: string; luckyNumbers: number[]; }, Symbol(clone, Decl(underscoreTest1_underscoreTests.ts, 165, 3))

_.isEqual(moe, clone);
>_.isEqual(moe, clone) : boolean
>_.isEqual : <T>(object: T, other: T) => boolean, Symbol(Underscore.Static.isEqual, Decl(underscoreTest1_underscore.ts, 597, 47))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isEqual : <T>(object: T, other: T) => boolean, Symbol(Underscore.Static.isEqual, Decl(underscoreTest1_underscore.ts, 597, 47))
>moe : { name: string; luckyNumbers: number[]; }, Symbol(moe, Decl(underscoreTest1_underscoreTests.ts, 164, 3))
>clone : { name: string; luckyNumbers: number[]; }, Symbol(clone, Decl(underscoreTest1_underscoreTests.ts, 165, 3))

_.isEmpty([1, 2, 3]);
>_.isEmpty([1, 2, 3]) : boolean
>_.isEmpty : (object: any) => boolean, Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isEmpty : (object: any) => boolean, Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number

_.isEmpty({});
>_.isEmpty({}) : boolean
>_.isEmpty : (object: any) => boolean, Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isEmpty : (object: any) => boolean, Symbol(Underscore.Static.isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
>{} : {}

_.isElement($('body')[0]);
>_.isElement($('body')[0]) : boolean
>_.isElement : (object: any) => boolean, Symbol(Underscore.Static.isElement, Decl(underscoreTest1_underscore.ts, 601, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isElement : (object: any) => boolean, Symbol(Underscore.Static.isElement, Decl(underscoreTest1_underscore.ts, 601, 38))
>$('body')[0] : any
>$('body') : any
>$ : any, Symbol($, Decl(underscoreTest1_underscoreTests.ts, 2, 11))
>'body' : string
>0 : number

(function () { return _.isArray(arguments); })();
>(function () { return _.isArray(arguments); })() : boolean
>(function () { return _.isArray(arguments); }) : () => boolean
>function () { return _.isArray(arguments); } : () => boolean
>_.isArray(arguments) : boolean
>_.isArray : (object: any) => boolean, Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isArray : (object: any) => boolean, Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
>arguments : IArguments, Symbol(arguments)

_.isArray([1, 2, 3]);
>_.isArray([1, 2, 3]) : boolean
>_.isArray : (object: any) => boolean, Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isArray : (object: any) => boolean, Symbol(Underscore.Static.isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number

_.isObject({});
>_.isObject({}) : boolean
>_.isObject : (value: any) => boolean, Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isObject : (value: any) => boolean, Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
>{} : {}

_.isObject(1);
>_.isObject(1) : boolean
>_.isObject : (value: any) => boolean, Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isObject : (value: any) => boolean, Symbol(Underscore.Static.isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
>1 : number


// (() => { return _.isArguments(arguments); })(1, 2, 3);
_.isArguments([1, 2, 3]);
>_.isArguments([1, 2, 3]) : boolean
>_.isArguments : (object: any) => boolean, Symbol(Underscore.Static.isArguments, Decl(underscoreTest1_underscore.ts, 604, 38))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isArguments : (object: any) => boolean, Symbol(Underscore.Static.isArguments, Decl(underscoreTest1_underscore.ts, 604, 38))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number

_.isFunction(alert);
>_.isFunction(alert) : boolean
>_.isFunction : (object: any) => boolean, Symbol(Underscore.Static.isFunction, Decl(underscoreTest1_underscore.ts, 605, 42))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isFunction : (object: any) => boolean, Symbol(Underscore.Static.isFunction, Decl(underscoreTest1_underscore.ts, 605, 42))
>alert : (x: string) => void, Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))

_.isString("moe");
>_.isString("moe") : boolean
>_.isString : (object: any) => boolean, Symbol(Underscore.Static.isString, Decl(underscoreTest1_underscore.ts, 606, 41))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isString : (object: any) => boolean, Symbol(Underscore.Static.isString, Decl(underscoreTest1_underscore.ts, 606, 41))
>"moe" : string

_.isNumber(8.4 * 5);
>_.isNumber(8.4 * 5) : boolean
>_.isNumber : (object: any) => boolean, Symbol(Underscore.Static.isNumber, Decl(underscoreTest1_underscore.ts, 607, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isNumber : (object: any) => boolean, Symbol(Underscore.Static.isNumber, Decl(underscoreTest1_underscore.ts, 607, 39))
>8.4 * 5 : number
>8.4 : number
>5 : number

_.isFinite(-101);
>_.isFinite(-101) : boolean
>_.isFinite : (object: any) => boolean, Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 608, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isFinite : (object: any) => boolean, Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 608, 39))
>-101 : number
>101 : number

_.isFinite(-Infinity);
>_.isFinite(-Infinity) : boolean
>_.isFinite : (object: any) => boolean, Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 608, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isFinite : (object: any) => boolean, Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 608, 39))
>-Infinity : number
>Infinity : number, Symbol(Infinity, Decl(lib.d.ts, 22, 11))

_.isBoolean(null);
>_.isBoolean(null) : boolean
>_.isBoolean : (object: any) => boolean, Symbol(Underscore.Static.isBoolean, Decl(underscoreTest1_underscore.ts, 609, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isBoolean : (object: any) => boolean, Symbol(Underscore.Static.isBoolean, Decl(underscoreTest1_underscore.ts, 609, 39))
>null : null

_.isDate(new Date());
>_.isDate(new Date()) : boolean
>_.isDate : (object: any) => boolean, Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 610, 40))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isDate : (object: any) => boolean, Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 610, 40))
>new Date() : Date
>Date : DateConstructor, Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))

_.isRegExp(/moe/);
>_.isRegExp(/moe/) : boolean
>_.isRegExp : (object: any) => boolean, Symbol(Underscore.Static.isRegExp, Decl(underscoreTest1_underscore.ts, 611, 37))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isRegExp : (object: any) => boolean, Symbol(Underscore.Static.isRegExp, Decl(underscoreTest1_underscore.ts, 611, 37))
>/moe/ : RegExp

_.isNaN(NaN);
>_.isNaN(NaN) : boolean
>_.isNaN : (object: any) => boolean, Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 612, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isNaN : (object: any) => boolean, Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 612, 39))
>NaN : number, Symbol(NaN, Decl(lib.d.ts, 21, 11))

isNaN(undefined);
>isNaN(undefined) : boolean
>isNaN : (number: number) => boolean, Symbol(isNaN, Decl(lib.d.ts, 43, 52))
>undefined : undefined, Symbol(undefined)

_.isNaN(undefined);
>_.isNaN(undefined) : boolean
>_.isNaN : (object: any) => boolean, Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 612, 39))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isNaN : (object: any) => boolean, Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 612, 39))
>undefined : undefined, Symbol(undefined)

_.isNull(null);
>_.isNull(null) : boolean
>_.isNull : (object: any) => boolean, Symbol(Underscore.Static.isNull, Decl(underscoreTest1_underscore.ts, 613, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isNull : (object: any) => boolean, Symbol(Underscore.Static.isNull, Decl(underscoreTest1_underscore.ts, 613, 36))
>null : null

_.isNull(undefined);
>_.isNull(undefined) : boolean
>_.isNull : (object: any) => boolean, Symbol(Underscore.Static.isNull, Decl(underscoreTest1_underscore.ts, 613, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isNull : (object: any) => boolean, Symbol(Underscore.Static.isNull, Decl(underscoreTest1_underscore.ts, 613, 36))
>undefined : undefined, Symbol(undefined)

_.isUndefined((<any>null).missingVariable);
>_.isUndefined((<any>null).missingVariable) : boolean
>_.isUndefined : (value: any) => boolean, Symbol(Underscore.Static.isUndefined, Decl(underscoreTest1_underscore.ts, 614, 37))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>isUndefined : (value: any) => boolean, Symbol(Underscore.Static.isUndefined, Decl(underscoreTest1_underscore.ts, 614, 37))
>(<any>null).missingVariable : any
>(<any>null) : any
><any>null : any
>null : null
>missingVariable : any

///////////////////////////////////////////////////////////////////////////////////////

var underscore = _.noConflict();
>underscore : Underscore.Static, Symbol(underscore, Decl(underscoreTest1_underscoreTests.ts, 211, 3))
>_.noConflict() : Underscore.Static
>_.noConflict : () => Underscore.Static, Symbol(Underscore.Static.noConflict, Decl(underscoreTest1_underscore.ts, 615, 41))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>noConflict : () => Underscore.Static, Symbol(Underscore.Static.noConflict, Decl(underscoreTest1_underscore.ts, 615, 41))

var moe2 = { name: 'moe' };
>moe2 : { name: string; }, Symbol(moe2, Decl(underscoreTest1_underscoreTests.ts, 213, 3))
>{ name: 'moe' } : { name: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 213, 12))
>'moe' : string

moe2 === _.identity(moe);
>moe2 === _.identity(moe) : boolean
>moe2 : { name: string; }, Symbol(moe2, Decl(underscoreTest1_underscoreTests.ts, 213, 3))
>_.identity(moe) : { name: string; luckyNumbers: number[]; }
>_.identity : <T>(value: T) => T, Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 617, 29))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>identity : <T>(value: T) => T, Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 617, 29))
>moe : { name: string; luckyNumbers: number[]; }, Symbol(moe, Decl(underscoreTest1_underscoreTests.ts, 164, 3))

var genie;
>genie : any, Symbol(genie, Decl(underscoreTest1_underscoreTests.ts, 216, 3))

_.times(3, function (n) { genie.grantWishNumber(n); });
>_.times(3, function (n) { genie.grantWishNumber(n); }) : void[]
>_.times : <U>(n: number, iterator: Iterator<number, U>, context?: any) => U[], Symbol(Underscore.Static.times, Decl(underscoreTest1_underscore.ts, 619, 33))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>times : <U>(n: number, iterator: Iterator<number, U>, context?: any) => U[], Symbol(Underscore.Static.times, Decl(underscoreTest1_underscore.ts, 619, 33))
>3 : number
>function (n) { genie.grantWishNumber(n); } : (n: number) => void
>n : number, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))
>genie.grantWishNumber(n) : any
>genie.grantWishNumber : any
>genie : any, Symbol(genie, Decl(underscoreTest1_underscoreTests.ts, 216, 3))
>grantWishNumber : any
>n : number, Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))

_.random(0, 100);
>_.random(0, 100) : number
>_.random : { (max: number): number; (min: number, max: number): number; }, Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 621, 79), Decl(underscoreTest1_underscore.ts, 623, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>random : { (max: number): number; (min: number, max: number): number; }, Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 621, 79), Decl(underscoreTest1_underscore.ts, 623, 36))
>0 : number
>100 : number

_.mixin({
>_.mixin({    capitalize: function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    }}) : void
>_.mixin : (object: any) => void, Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>mixin : (object: any) => void, Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
>{    capitalize: function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    }} : { capitalize: (string: any) => any; }

    capitalize: function (string) {
>capitalize : (string: any) => any, Symbol(capitalize, Decl(underscoreTest1_underscoreTests.ts, 222, 9))
>function (string) {        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();    } : (string: any) => any
>string : any, Symbol(string, Decl(underscoreTest1_underscoreTests.ts, 223, 26))

        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
>string.charAt(0).toUpperCase() + string.substring(1).toLowerCase() : any
>string.charAt(0).toUpperCase() : any
>string.charAt(0).toUpperCase : any
>string.charAt(0) : any
>string.charAt : any
>string : any, Symbol(string, Decl(underscoreTest1_underscoreTests.ts, 223, 26))
>charAt : any
>0 : number
>toUpperCase : any
>string.substring(1).toLowerCase() : any
>string.substring(1).toLowerCase : any
>string.substring(1) : any
>string.substring : any
>string : any, Symbol(string, Decl(underscoreTest1_underscoreTests.ts, 223, 26))
>substring : any
>1 : number
>toLowerCase : any
    }
});
(<any>_("fabio")).capitalize();
>(<any>_("fabio")).capitalize() : any
>(<any>_("fabio")).capitalize : any
>(<any>_("fabio")) : any
><any>_("fabio") : any
>_("fabio") : Underscore.WrappedObject<string>
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>"fabio" : string
>capitalize : any

_.uniqueId('contact_');
>_.uniqueId('contact_') : string
>_.uniqueId : { (): number; (prefix: string): string; }, Symbol(Underscore.Static.uniqueId, Decl(underscoreTest1_underscore.ts, 626, 33), Decl(underscoreTest1_underscore.ts, 628, 27))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>uniqueId : { (): number; (prefix: string): string; }, Symbol(Underscore.Static.uniqueId, Decl(underscoreTest1_underscore.ts, 626, 33), Decl(underscoreTest1_underscore.ts, 628, 27))
>'contact_' : string

_.escape('Curly, Larry & Moe');
>_.escape('Curly, Larry & Moe') : string
>_.escape : (s: string) => string, Symbol(Underscore.Static.escape, Decl(underscoreTest1_underscore.ts, 629, 41))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>escape : (s: string) => string, Symbol(Underscore.Static.escape, Decl(underscoreTest1_underscore.ts, 629, 41))
>'Curly, Larry & Moe' : string

var object = { cheese: 'crumpets', stuff: function () { return 'nonsense'; } };
>object : { cheese: string; stuff: () => string; }, Symbol(object, Decl(underscoreTest1_underscoreTests.ts, 233, 3))
>{ cheese: 'crumpets', stuff: function () { return 'nonsense'; } } : { cheese: string; stuff: () => string; }
>cheese : string, Symbol(cheese, Decl(underscoreTest1_underscoreTests.ts, 233, 14))
>'crumpets' : string
>stuff : () => string, Symbol(stuff, Decl(underscoreTest1_underscoreTests.ts, 233, 34))
>function () { return 'nonsense'; } : () => string
>'nonsense' : string

_.result(object, 'cheese');
>_.result(object, 'cheese') : any
>_.result : (object: any, property: string) => any, Symbol(Underscore.Static.result, Decl(underscoreTest1_underscore.ts, 633, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>result : (object: any, property: string) => any, Symbol(Underscore.Static.result, Decl(underscoreTest1_underscore.ts, 633, 36))
>object : { cheese: string; stuff: () => string; }, Symbol(object, Decl(underscoreTest1_underscoreTests.ts, 233, 3))
>'cheese' : string

_.result(object, 'stuff');
>_.result(object, 'stuff') : any
>_.result : (object: any, property: string) => any, Symbol(Underscore.Static.result, Decl(underscoreTest1_underscore.ts, 633, 36))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>result : (object: any, property: string) => any, Symbol(Underscore.Static.result, Decl(underscoreTest1_underscore.ts, 633, 36))
>object : { cheese: string; stuff: () => string; }, Symbol(object, Decl(underscoreTest1_underscoreTests.ts, 233, 3))
>'stuff' : string

var compiled = _.template("hello: <%= name %>");
>compiled : (data: any) => string, Symbol(compiled, Decl(underscoreTest1_underscoreTests.ts, 238, 3))
>_.template("hello: <%= name %>") : (data: any) => string
>_.template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>"hello: <%= name %>" : string

compiled({ name: 'moe' });
>compiled({ name: 'moe' }) : string
>compiled : (data: any) => string, Symbol(compiled, Decl(underscoreTest1_underscoreTests.ts, 238, 3))
>{ name: 'moe' } : { name: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 239, 10))
>'moe' : string

var list2 = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
>list2 : string, Symbol(list2, Decl(underscoreTest1_underscoreTests.ts, 240, 3))
>"<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>" : string

_.template(list2, { people: ['moe', 'curly', 'larry'] });
>_.template(list2, { people: ['moe', 'curly', 'larry'] }) : string
>_.template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>list2 : string, Symbol(list2, Decl(underscoreTest1_underscoreTests.ts, 240, 3))
>{ people: ['moe', 'curly', 'larry'] } : { people: string[]; }
>people : string[], Symbol(people, Decl(underscoreTest1_underscoreTests.ts, 241, 19))
>['moe', 'curly', 'larry'] : string[]
>'moe' : string
>'curly' : string
>'larry' : string

var template = _.template("<b><%- value %></b>");
>template : (data: any) => string, Symbol(template, Decl(underscoreTest1_underscoreTests.ts, 242, 3))
>_.template("<b><%- value %></b>") : (data: any) => string
>_.template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>"<b><%- value %></b>" : string

template({ value: '<script>' });
>template({ value: '<script>' }) : string
>template : (data: any) => string, Symbol(template, Decl(underscoreTest1_underscoreTests.ts, 242, 3))
>{ value: '<script>' } : { value: string; }
>value : string, Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 243, 10))
>'<script>' : string

var compiled2 = _.template("<% print('Hello ' + epithet); %>");
>compiled2 : (data: any) => string, Symbol(compiled2, Decl(underscoreTest1_underscoreTests.ts, 244, 3))
>_.template("<% print('Hello ' + epithet); %>") : (data: any) => string
>_.template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>"<% print('Hello ' + epithet); %>" : string

compiled2({ epithet: "stooge" });
>compiled2({ epithet: "stooge" }) : string
>compiled2 : (data: any) => string, Symbol(compiled2, Decl(underscoreTest1_underscoreTests.ts, 244, 3))
>{ epithet: "stooge" } : { epithet: string; }
>epithet : string, Symbol(epithet, Decl(underscoreTest1_underscoreTests.ts, 245, 11))
>"stooge" : string

_.templateSettings = {
>_.templateSettings = {    interpolate: /\{\{(.+?)\}\}/g} : { interpolate: RegExp; }
>_.templateSettings : Underscore.TemplateSettings, Symbol(Underscore.Static.templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>templateSettings : Underscore.TemplateSettings, Symbol(Underscore.Static.templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
>{    interpolate: /\{\{(.+?)\}\}/g} : { interpolate: RegExp; }

    interpolate: /\{\{(.+?)\}\}/g
>interpolate : RegExp, Symbol(interpolate, Decl(underscoreTest1_underscoreTests.ts, 246, 22))
>/\{\{(.+?)\}\}/g : RegExp

};
var template2 = _.template("Hello {{ name }}!");
>template2 : (data: any) => string, Symbol(template2, Decl(underscoreTest1_underscoreTests.ts, 249, 3))
>_.template("Hello {{ name }}!") : (data: any) => string
>_.template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>"Hello {{ name }}!" : string

template2({ name: "Mustache" });
>template2({ name: "Mustache" }) : string
>template2 : (data: any) => string, Symbol(template2, Decl(underscoreTest1_underscoreTests.ts, 249, 3))
>{ name: "Mustache" } : { name: string; }
>name : string, Symbol(name, Decl(underscoreTest1_underscoreTests.ts, 250, 11))
>"Mustache" : string

_.template("Using 'with': <%= data.answer %>", { answer: 'no' }, { variable: 'data' });
>_.template("Using 'with': <%= data.answer %>", { answer: 'no' }, { variable: 'data' }) : string
>_.template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: Underscore.TemplateSettings): string; }, Symbol(Underscore.Static.template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>"Using 'with': <%= data.answer %>" : string
>{ answer: 'no' } : { answer: string; }
>answer : string, Symbol(answer, Decl(underscoreTest1_underscoreTests.ts, 251, 48))
>'no' : string
>{ variable: 'data' } : { variable: string; }
>variable : string, Symbol(variable, Decl(underscoreTest1_underscoreTests.ts, 251, 66))
>'data' : string

=== tests/cases/compiler/underscoreTest1_underscore.ts ===
interface Dictionary<T> {
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 0, 21))

    [x: string]: T;
>x : string, Symbol(x, Decl(underscoreTest1_underscore.ts, 1, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 0, 21))
}

interface Iterator<T, U> {
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 19))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 21))

    (value: T, index: any, list: any): U;
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 5, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 19))
>index : any, Symbol(index, Decl(underscoreTest1_underscore.ts, 5, 14))
>list : any, Symbol(list, Decl(underscoreTest1_underscore.ts, 5, 26))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 21))
}

interface Reducer<T, U> {
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 8, 18))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 20))

    (accumulator: U, value: T, index: any, list: any): U;
>accumulator : U, Symbol(accumulator, Decl(underscoreTest1_underscore.ts, 9, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 20))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 9, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 8, 18))
>index : any, Symbol(index, Decl(underscoreTest1_underscore.ts, 9, 30))
>list : any, Symbol(list, Decl(underscoreTest1_underscore.ts, 9, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 20))
}

interface Tuple2<T0, T1> extends Array<any> {
>Tuple2 : Tuple2<T0, T1>, Symbol(Tuple2, Decl(underscoreTest1_underscore.ts, 10, 1))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 12, 17))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 12, 20))
>Array : T[], Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))

    0: T0;
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 12, 17))

    1: T1;
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 12, 20))
}

interface Tuple3<T0, T1, T2> extends Array<any> {
>Tuple3 : Tuple3<T0, T1, T2>, Symbol(Tuple3, Decl(underscoreTest1_underscore.ts, 15, 1))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 17, 17))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 17, 20))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 17, 24))
>Array : T[], Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))

    0: T0;
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 17, 17))

    1: T1;
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 17, 20))

    2: T2;
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 17, 24))
}

interface Tuple4<T0, T1, T2, T3> extends Array<any> {
>Tuple4 : Tuple4<T0, T1, T2, T3>, Symbol(Tuple4, Decl(underscoreTest1_underscore.ts, 21, 1))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 23, 17))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 23, 20))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 23, 24))
>T3 : T3, Symbol(T3, Decl(underscoreTest1_underscore.ts, 23, 28))
>Array : T[], Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))

    0: T0;
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 23, 17))

    1: T1;
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 23, 20))

    2: T2;
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 23, 24))

    3: T3;
>T3 : T3, Symbol(T3, Decl(underscoreTest1_underscore.ts, 23, 28))
}

module Underscore {
>Underscore : any, Symbol(Underscore, Decl(underscoreTest1_underscore.ts, 28, 1))

    export interface WrappedObject<T> {
>WrappedObject : WrappedObject<T>, Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        keys(): string[];
>keys : () => string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 31, 39))

        values(): any[];
>values : () => any[], Symbol(values, Decl(underscoreTest1_underscore.ts, 32, 25))

        pairs(): any[][];
>pairs : () => any[][], Symbol(pairs, Decl(underscoreTest1_underscore.ts, 33, 24))

        invert(): any;
>invert : () => any, Symbol(invert, Decl(underscoreTest1_underscore.ts, 34, 25))

        functions(): string[];
>functions : () => string[], Symbol(functions, Decl(underscoreTest1_underscore.ts, 35, 22))

        methods(): string[];
>methods : () => string[], Symbol(methods, Decl(underscoreTest1_underscore.ts, 36, 30))

        extend(...sources: any[]): T;
>extend : (...sources: any[]) => T, Symbol(extend, Decl(underscoreTest1_underscore.ts, 37, 28))
>sources : any[], Symbol(sources, Decl(underscoreTest1_underscore.ts, 38, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        pick(...keys: string[]): T;
>pick : (...keys: string[]) => T, Symbol(pick, Decl(underscoreTest1_underscore.ts, 38, 37))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 39, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        omit(...keys: string[]): T;
>omit : (...keys: string[]) => T, Symbol(omit, Decl(underscoreTest1_underscore.ts, 39, 35))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 40, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        defaults(...defaults: any[]): T;
>defaults : (...defaults: any[]) => T, Symbol(defaults, Decl(underscoreTest1_underscore.ts, 40, 35))
>defaults : any[], Symbol(defaults, Decl(underscoreTest1_underscore.ts, 41, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        clone(): T;
>clone : () => T, Symbol(clone, Decl(underscoreTest1_underscore.ts, 41, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        tap(interceptor: (object: T) => void): T;
>tap : (interceptor: (object: T) => void) => T, Symbol(tap, Decl(underscoreTest1_underscore.ts, 42, 19))
>interceptor : (object: T) => void, Symbol(interceptor, Decl(underscoreTest1_underscore.ts, 43, 12))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 43, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        has(key: string): boolean;
>has : (key: string) => boolean, Symbol(has, Decl(underscoreTest1_underscore.ts, 43, 49))
>key : string, Symbol(key, Decl(underscoreTest1_underscore.ts, 44, 12))

        isEqual(other: T): boolean;
>isEqual : (other: T) => boolean, Symbol(isEqual, Decl(underscoreTest1_underscore.ts, 44, 34))
>other : T, Symbol(other, Decl(underscoreTest1_underscore.ts, 45, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))

        isEmpty(): boolean;
>isEmpty : () => boolean, Symbol(isEmpty, Decl(underscoreTest1_underscore.ts, 45, 35))

        isElement(): boolean;
>isElement : () => boolean, Symbol(isElement, Decl(underscoreTest1_underscore.ts, 46, 27))

        isArray(): boolean;
>isArray : () => boolean, Symbol(isArray, Decl(underscoreTest1_underscore.ts, 47, 29))

        isObject(): boolean;
>isObject : () => boolean, Symbol(isObject, Decl(underscoreTest1_underscore.ts, 48, 27))

        isArguments(): boolean;
>isArguments : () => boolean, Symbol(isArguments, Decl(underscoreTest1_underscore.ts, 49, 28))

        isFunction(): boolean;
>isFunction : () => boolean, Symbol(isFunction, Decl(underscoreTest1_underscore.ts, 50, 31))

        isString(): boolean;
>isString : () => boolean, Symbol(isString, Decl(underscoreTest1_underscore.ts, 51, 30))

        isNumber(): boolean;
>isNumber : () => boolean, Symbol(isNumber, Decl(underscoreTest1_underscore.ts, 52, 28))

        isFinite(): boolean;
>isFinite : () => boolean, Symbol(isFinite, Decl(underscoreTest1_underscore.ts, 53, 28))

        isBoolean(): boolean;
>isBoolean : () => boolean, Symbol(isBoolean, Decl(underscoreTest1_underscore.ts, 54, 28))

        isDate(): boolean;
>isDate : () => boolean, Symbol(isDate, Decl(underscoreTest1_underscore.ts, 55, 29))

        isRegExp(): boolean;
>isRegExp : () => boolean, Symbol(isRegExp, Decl(underscoreTest1_underscore.ts, 56, 26))

        isNaN(): boolean;
>isNaN : () => boolean, Symbol(isNaN, Decl(underscoreTest1_underscore.ts, 57, 28))

        isNull(): boolean;
>isNull : () => boolean, Symbol(isNull, Decl(underscoreTest1_underscore.ts, 58, 25))

        isUndefined(): boolean;
>isUndefined : () => boolean, Symbol(isUndefined, Decl(underscoreTest1_underscore.ts, 59, 26))

        value(): T;
>value : () => T, Symbol(value, Decl(underscoreTest1_underscore.ts, 60, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 31, 35))
    }

    export interface WrappedFunction<T extends Function> extends WrappedObject<T> {
>WrappedFunction : WrappedFunction<T>, Symbol(WrappedFunction, Decl(underscoreTest1_underscore.ts, 62, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>WrappedObject : WrappedObject<T>, Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        bind(object: any): T;
>bind : { (object: any): T; (object: any, ...args: any[]): Function; }, Symbol(bind, Decl(underscoreTest1_underscore.ts, 64, 83), Decl(underscoreTest1_underscore.ts, 65, 29))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 65, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        bind(object: any, ...args: any[]): Function;
>bind : { (object: any): T; (object: any, ...args: any[]): Function; }, Symbol(bind, Decl(underscoreTest1_underscore.ts, 64, 83), Decl(underscoreTest1_underscore.ts, 65, 29))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 66, 13))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 66, 25))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))

        bindAll(...methodNames: string[]): T;
>bindAll : (...methodNames: string[]) => T, Symbol(bindAll, Decl(underscoreTest1_underscore.ts, 66, 52))
>methodNames : string[], Symbol(methodNames, Decl(underscoreTest1_underscore.ts, 67, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        partial(...args: any[]): Function;
>partial : (...args: any[]) => Function, Symbol(partial, Decl(underscoreTest1_underscore.ts, 67, 45))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 68, 16))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))

        memoize(hashFunction?: Function): T;
>memoize : (hashFunction?: Function) => T, Symbol(memoize, Decl(underscoreTest1_underscore.ts, 68, 42))
>hashFunction : Function, Symbol(hashFunction, Decl(underscoreTest1_underscore.ts, 69, 16))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        delay(wait: number, ...args: any[]): number;
>delay : (wait: number, ...args: any[]) => number, Symbol(delay, Decl(underscoreTest1_underscore.ts, 69, 44))
>wait : number, Symbol(wait, Decl(underscoreTest1_underscore.ts, 70, 14))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 70, 27))

        defer(...args: any[]): number;
>defer : (...args: any[]) => number, Symbol(defer, Decl(underscoreTest1_underscore.ts, 70, 52))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 71, 14))

        throttle(wait: number): T;
>throttle : (wait: number) => T, Symbol(throttle, Decl(underscoreTest1_underscore.ts, 71, 38))
>wait : number, Symbol(wait, Decl(underscoreTest1_underscore.ts, 72, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        debounce(wait: number, immediate?: boolean): T;
>debounce : (wait: number, immediate?: boolean) => T, Symbol(debounce, Decl(underscoreTest1_underscore.ts, 72, 34))
>wait : number, Symbol(wait, Decl(underscoreTest1_underscore.ts, 73, 17))
>immediate : boolean, Symbol(immediate, Decl(underscoreTest1_underscore.ts, 73, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        once(): T;
>once : () => T, Symbol(once, Decl(underscoreTest1_underscore.ts, 73, 55))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        wrap(wrapper: (func: T, ...args: any[]) => any): T;
>wrap : (wrapper: (func: T, ...args: any[]) => any) => T, Symbol(wrap, Decl(underscoreTest1_underscore.ts, 74, 18))
>wrapper : (func: T, ...args: any[]) => any, Symbol(wrapper, Decl(underscoreTest1_underscore.ts, 75, 13))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 75, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 75, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))

        compose(...funcs: Function[]): Function;
>compose : (...funcs: Function[]) => Function, Symbol(compose, Decl(underscoreTest1_underscore.ts, 75, 59))
>funcs : Function[], Symbol(funcs, Decl(underscoreTest1_underscore.ts, 76, 16))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
    }

    export interface WrappedArray<T> extends WrappedObject<Array<T>> {
>WrappedArray : WrappedArray<T>, Symbol(WrappedArray, Decl(underscoreTest1_underscore.ts, 77, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>WrappedObject : WrappedObject<T>, Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
>Array : T[], Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        each(iterator: Iterator<T, void>, context?: any): void;
>each : (iterator: Iterator<T, void>, context?: any) => void, Symbol(each, Decl(underscoreTest1_underscore.ts, 79, 70))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 80, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 80, 41))

        forEach(iterator: Iterator<T, void>, context?: any): void;
>forEach : (iterator: Iterator<T, void>, context?: any) => void, Symbol(forEach, Decl(underscoreTest1_underscore.ts, 80, 63))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 81, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 81, 44))

        map<U>(iterator: Iterator<T, U>, context?: any): U[];
>map : <U>(iterator: Iterator<T, U>, context?: any) => U[], Symbol(map, Decl(underscoreTest1_underscore.ts, 81, 66))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 82, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 82, 40))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12))

        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
>collect : <U>(iterator: Iterator<T, U>, context?: any) => U[], Symbol(collect, Decl(underscoreTest1_underscore.ts, 82, 61))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 83, 19))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 83, 44))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16))

        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 83, 65), Decl(underscoreTest1_underscore.ts, 84, 76))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 84, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 84, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 84, 57))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 83, 65), Decl(underscoreTest1_underscore.ts, 84, 76))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 85, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 85, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 85, 59))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))

        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 85, 78), Decl(underscoreTest1_underscore.ts, 86, 75))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 86, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 86, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 86, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 85, 78), Decl(underscoreTest1_underscore.ts, 86, 75))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 87, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 87, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 87, 58))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))

        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 87, 77), Decl(underscoreTest1_underscore.ts, 88, 76))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 88, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 88, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 88, 57))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 87, 77), Decl(underscoreTest1_underscore.ts, 88, 76))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 89, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 89, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 89, 59))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))

        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 89, 78), Decl(underscoreTest1_underscore.ts, 90, 81))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 90, 20))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 90, 44))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 90, 62))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 89, 78), Decl(underscoreTest1_underscore.ts, 90, 81))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 91, 23))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 91, 47))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 91, 64))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))

        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 91, 83), Decl(underscoreTest1_underscore.ts, 92, 75))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 92, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 92, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 92, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 91, 83), Decl(underscoreTest1_underscore.ts, 92, 75))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 93, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 93, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 93, 58))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))

        find(iterator: Iterator<T, boolean>, context?: any): T;
>find : (iterator: Iterator<T, boolean>, context?: any) => T, Symbol(find, Decl(underscoreTest1_underscore.ts, 93, 77))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 94, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 94, 44))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        detect(iterator: Iterator<T, boolean>, context?: any): T;
>detect : (iterator: Iterator<T, boolean>, context?: any) => T, Symbol(detect, Decl(underscoreTest1_underscore.ts, 94, 63))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 95, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 95, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        filter(iterator: Iterator<T, boolean>, context?: any): T[];
>filter : (iterator: Iterator<T, boolean>, context?: any) => T[], Symbol(filter, Decl(underscoreTest1_underscore.ts, 95, 65))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 96, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 96, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        select(iterator: Iterator<T, boolean>, context?: any): T[];
>select : (iterator: Iterator<T, boolean>, context?: any) => T[], Symbol(select, Decl(underscoreTest1_underscore.ts, 96, 67))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 97, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 97, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        where(properties: Object): T[];
>where : (properties: Object) => T[], Symbol(where, Decl(underscoreTest1_underscore.ts, 97, 67))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 98, 14))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        findWhere(properties: Object): T;
>findWhere : (properties: Object) => T, Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 98, 39))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 99, 18))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        reject(iterator: Iterator<T, boolean>, context?: any): T[];
>reject : (iterator: Iterator<T, boolean>, context?: any) => T[], Symbol(reject, Decl(underscoreTest1_underscore.ts, 99, 41))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 100, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 100, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
>every : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(every, Decl(underscoreTest1_underscore.ts, 100, 67))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 101, 14))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 101, 46))

        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
>all : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(all, Decl(underscoreTest1_underscore.ts, 101, 71))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 102, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 102, 44))

        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
>some : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(some, Decl(underscoreTest1_underscore.ts, 102, 69))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 103, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 103, 45))

        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
>any : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(any, Decl(underscoreTest1_underscore.ts, 103, 70))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 104, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 104, 44))

        contains(value: T): boolean;
>contains : (value: T) => boolean, Symbol(contains, Decl(underscoreTest1_underscore.ts, 104, 69))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 105, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        include(value: T): boolean;
>include : (value: T) => boolean, Symbol(include, Decl(underscoreTest1_underscore.ts, 105, 36))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 106, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        invoke(methodName: string, ...args: any[]): any[];
>invoke : (methodName: string, ...args: any[]) => any[], Symbol(invoke, Decl(underscoreTest1_underscore.ts, 106, 35))
>methodName : string, Symbol(methodName, Decl(underscoreTest1_underscore.ts, 107, 15))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 107, 34))

        pluck(propertyName: string): any[];
>pluck : (propertyName: string) => any[], Symbol(pluck, Decl(underscoreTest1_underscore.ts, 107, 58))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 108, 14))

        max(iterator?: Iterator<T, any>, context?: any): T;
>max : (iterator?: Iterator<T, any>, context?: any) => T, Symbol(max, Decl(underscoreTest1_underscore.ts, 108, 43))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 109, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 109, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        min(iterator?: Iterator<T, any>, context?: any): T;
>min : (iterator?: Iterator<T, any>, context?: any) => T, Symbol(min, Decl(underscoreTest1_underscore.ts, 109, 59))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 110, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 110, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        sortBy(iterator: Iterator<T, any>, context?: any): T[];
>sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 110, 59), Decl(underscoreTest1_underscore.ts, 111, 63))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 111, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 111, 42))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        sortBy(propertyName: string): T[];
>sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 110, 59), Decl(underscoreTest1_underscore.ts, 111, 63))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 112, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 113, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 113, 44))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        groupBy(propertyName: string): Dictionary<T[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 114, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 80))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 115, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 115, 44))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        countBy(propertyName: string): Dictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 80))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 116, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        shuffle(): T[];
>shuffle : () => T[], Symbol(shuffle, Decl(underscoreTest1_underscore.ts, 116, 58))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        toArray(): T[];
>toArray : () => T[], Symbol(toArray, Decl(underscoreTest1_underscore.ts, 117, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        size(): number;
>size : () => number, Symbol(size, Decl(underscoreTest1_underscore.ts, 118, 23))

        first(): T;
>first : { (): T; (count: number): T[]; }, Symbol(first, Decl(underscoreTest1_underscore.ts, 119, 23), Decl(underscoreTest1_underscore.ts, 120, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        first(count: number): T[];
>first : { (): T; (count: number): T[]; }, Symbol(first, Decl(underscoreTest1_underscore.ts, 119, 23), Decl(underscoreTest1_underscore.ts, 120, 19))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 121, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        head(): T;
>head : { (): T; (count: number): T[]; }, Symbol(head, Decl(underscoreTest1_underscore.ts, 121, 34), Decl(underscoreTest1_underscore.ts, 122, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        head(count: number): T[];
>head : { (): T; (count: number): T[]; }, Symbol(head, Decl(underscoreTest1_underscore.ts, 121, 34), Decl(underscoreTest1_underscore.ts, 122, 18))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 123, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        take(): T;
>take : { (): T; (count: number): T[]; }, Symbol(take, Decl(underscoreTest1_underscore.ts, 123, 33), Decl(underscoreTest1_underscore.ts, 124, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        take(count: number): T[];
>take : { (): T; (count: number): T[]; }, Symbol(take, Decl(underscoreTest1_underscore.ts, 123, 33), Decl(underscoreTest1_underscore.ts, 124, 18))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 125, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        initial(): T;
>initial : { (): T; (count: number): T[]; }, Symbol(initial, Decl(underscoreTest1_underscore.ts, 125, 33), Decl(underscoreTest1_underscore.ts, 126, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        initial(count: number): T[];
>initial : { (): T; (count: number): T[]; }, Symbol(initial, Decl(underscoreTest1_underscore.ts, 125, 33), Decl(underscoreTest1_underscore.ts, 126, 21))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 127, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        last(): T;
>last : { (): T; (count: number): T[]; }, Symbol(last, Decl(underscoreTest1_underscore.ts, 127, 36), Decl(underscoreTest1_underscore.ts, 128, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        last(count: number): T[];
>last : { (): T; (count: number): T[]; }, Symbol(last, Decl(underscoreTest1_underscore.ts, 127, 36), Decl(underscoreTest1_underscore.ts, 128, 18))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 129, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        rest(index?: number): T[];
>rest : (index?: number) => T[], Symbol(rest, Decl(underscoreTest1_underscore.ts, 129, 33))
>index : number, Symbol(index, Decl(underscoreTest1_underscore.ts, 130, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        compact(): T[];
>compact : () => T[], Symbol(compact, Decl(underscoreTest1_underscore.ts, 130, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        flatten<U>(shallow?: boolean): U[];
>flatten : <U>(shallow?: boolean) => U[], Symbol(flatten, Decl(underscoreTest1_underscore.ts, 131, 23))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 132, 16))
>shallow : boolean, Symbol(shallow, Decl(underscoreTest1_underscore.ts, 132, 19))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 132, 16))

        without(...values: T[]): T[];
>without : (...values: T[]) => T[], Symbol(without, Decl(underscoreTest1_underscore.ts, 132, 43))
>values : T[], Symbol(values, Decl(underscoreTest1_underscore.ts, 133, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        union(...arrays: T[][]): T[];
>union : (...arrays: T[][]) => T[], Symbol(union, Decl(underscoreTest1_underscore.ts, 133, 37))
>arrays : T[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 134, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        intersection(...arrays: T[][]): T[];
>intersection : (...arrays: T[][]) => T[], Symbol(intersection, Decl(underscoreTest1_underscore.ts, 134, 37))
>arrays : T[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 135, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        difference(...others: T[][]): T[];
>difference : (...others: T[][]) => T[], Symbol(difference, Decl(underscoreTest1_underscore.ts, 135, 44))
>others : T[][], Symbol(others, Decl(underscoreTest1_underscore.ts, 136, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        uniq(isSorted?: boolean): T[];
>uniq : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(uniq, Decl(underscoreTest1_underscore.ts, 136, 42), Decl(underscoreTest1_underscore.ts, 137, 38))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 137, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
>uniq : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(uniq, Decl(underscoreTest1_underscore.ts, 136, 42), Decl(underscoreTest1_underscore.ts, 137, 38))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 138, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 138, 34))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 138, 60))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13))

        unique(isSorted?: boolean): T[];
>unique : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(unique, Decl(underscoreTest1_underscore.ts, 138, 81), Decl(underscoreTest1_underscore.ts, 139, 40))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 139, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
>unique : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(unique, Decl(underscoreTest1_underscore.ts, 138, 81), Decl(underscoreTest1_underscore.ts, 139, 40))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 140, 18))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 140, 36))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 140, 62))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15))

        zip(...arrays: any[][]): any[][];
>zip : (...arrays: any[][]) => any[][], Symbol(zip, Decl(underscoreTest1_underscore.ts, 140, 83))
>arrays : any[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 141, 12))

        object(): any;
>object : { (): any; (values: any[]): any; }, Symbol(object, Decl(underscoreTest1_underscore.ts, 141, 41), Decl(underscoreTest1_underscore.ts, 142, 22))

        object(values: any[]): any;
>object : { (): any; (values: any[]): any; }, Symbol(object, Decl(underscoreTest1_underscore.ts, 141, 41), Decl(underscoreTest1_underscore.ts, 142, 22))
>values : any[], Symbol(values, Decl(underscoreTest1_underscore.ts, 143, 15))

        indexOf(value: T, isSorted?: boolean): number;
>indexOf : (value: T, isSorted?: boolean) => number, Symbol(indexOf, Decl(underscoreTest1_underscore.ts, 143, 35))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 144, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 144, 25))

        lastIndexOf(value: T, fromIndex?: number): number;
>lastIndexOf : (value: T, fromIndex?: number) => number, Symbol(lastIndexOf, Decl(underscoreTest1_underscore.ts, 144, 54))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 145, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>fromIndex : number, Symbol(fromIndex, Decl(underscoreTest1_underscore.ts, 145, 29))

        sortedIndex(obj: T, propertyName: string): number;
>sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator<T, any>, context?: any): number; }, Symbol(sortedIndex, Decl(underscoreTest1_underscore.ts, 145, 58), Decl(underscoreTest1_underscore.ts, 146, 58))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 146, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 146, 27))

        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): number;
>sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator<T, any>, context?: any): number; }, Symbol(sortedIndex, Decl(underscoreTest1_underscore.ts, 145, 58), Decl(underscoreTest1_underscore.ts, 146, 58))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 147, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 147, 27))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 147, 56))

        // Methods from Array
        concat(...items: T[]): T[];
>concat : (...items: T[]) => T[], Symbol(concat, Decl(underscoreTest1_underscore.ts, 147, 80))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 149, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        join(separator?: string): string;
>join : (separator?: string) => string, Symbol(join, Decl(underscoreTest1_underscore.ts, 149, 35))
>separator : string, Symbol(separator, Decl(underscoreTest1_underscore.ts, 150, 13))

        pop(): T;
>pop : () => T, Symbol(pop, Decl(underscoreTest1_underscore.ts, 150, 41))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        push(...items: T[]): number;
>push : (...items: T[]) => number, Symbol(push, Decl(underscoreTest1_underscore.ts, 151, 17))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 152, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        reverse(): T[];
>reverse : () => T[], Symbol(reverse, Decl(underscoreTest1_underscore.ts, 152, 36))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        shift(): T;
>shift : () => T, Symbol(shift, Decl(underscoreTest1_underscore.ts, 153, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        slice(start: number, end?: number): T[];
>slice : (start: number, end?: number) => T[], Symbol(slice, Decl(underscoreTest1_underscore.ts, 154, 19))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 155, 14))
>end : number, Symbol(end, Decl(underscoreTest1_underscore.ts, 155, 28))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        sort(compareFn?: (a: T, b: T) => number): T[];
>sort : (compareFn?: (a: T, b: T) => number) => T[], Symbol(sort, Decl(underscoreTest1_underscore.ts, 155, 48))
>compareFn : (a: T, b: T) => number, Symbol(compareFn, Decl(underscoreTest1_underscore.ts, 156, 13))
>a : T, Symbol(a, Decl(underscoreTest1_underscore.ts, 156, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>b : T, Symbol(b, Decl(underscoreTest1_underscore.ts, 156, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        splice(start: number): T[];
>splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }, Symbol(splice, Decl(underscoreTest1_underscore.ts, 156, 54), Decl(underscoreTest1_underscore.ts, 157, 35))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 157, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        splice(start: number, deleteCount: number, ...items: T[]): T[];
>splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }, Symbol(splice, Decl(underscoreTest1_underscore.ts, 156, 54), Decl(underscoreTest1_underscore.ts, 157, 35))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 158, 15))
>deleteCount : number, Symbol(deleteCount, Decl(underscoreTest1_underscore.ts, 158, 29))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 158, 50))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))

        unshift(...items: T[]): number;
>unshift : (...items: T[]) => number, Symbol(unshift, Decl(underscoreTest1_underscore.ts, 158, 71))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 159, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
    }

    export interface WrappedDictionary<T> extends WrappedObject<Dictionary<T>> {
>WrappedDictionary : WrappedDictionary<T>, Symbol(WrappedDictionary, Decl(underscoreTest1_underscore.ts, 160, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>WrappedObject : WrappedObject<T>, Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        each(iterator: Iterator<T, void>, context?: any): void;
>each : (iterator: Iterator<T, void>, context?: any) => void, Symbol(each, Decl(underscoreTest1_underscore.ts, 162, 80))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 163, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 163, 41))

        forEach(iterator: Iterator<T, void>, context?: any): void;
>forEach : (iterator: Iterator<T, void>, context?: any) => void, Symbol(forEach, Decl(underscoreTest1_underscore.ts, 163, 63))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 164, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 164, 44))

        map<U>(iterator: Iterator<T, U>, context?: any): U[];
>map : <U>(iterator: Iterator<T, U>, context?: any) => U[], Symbol(map, Decl(underscoreTest1_underscore.ts, 164, 66))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 165, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 165, 40))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12))

        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
>collect : <U>(iterator: Iterator<T, U>, context?: any) => U[], Symbol(collect, Decl(underscoreTest1_underscore.ts, 165, 61))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 166, 19))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 166, 44))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16))

        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 166, 65), Decl(underscoreTest1_underscore.ts, 167, 76))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 167, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 167, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 167, 57))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 166, 65), Decl(underscoreTest1_underscore.ts, 167, 76))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 168, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 168, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 168, 59))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))

        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 168, 78), Decl(underscoreTest1_underscore.ts, 169, 75))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 169, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 169, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 169, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 168, 78), Decl(underscoreTest1_underscore.ts, 169, 75))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 170, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 170, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 170, 58))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))

        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 170, 77), Decl(underscoreTest1_underscore.ts, 171, 76))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 171, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 171, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 171, 57))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 170, 77), Decl(underscoreTest1_underscore.ts, 171, 76))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 172, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 172, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 172, 59))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))

        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 172, 78), Decl(underscoreTest1_underscore.ts, 173, 81))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 173, 20))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 173, 44))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 173, 62))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 172, 78), Decl(underscoreTest1_underscore.ts, 173, 81))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 174, 23))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 174, 47))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 174, 64))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))

        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 174, 83), Decl(underscoreTest1_underscore.ts, 175, 75))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 175, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 175, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 175, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 174, 83), Decl(underscoreTest1_underscore.ts, 175, 75))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 176, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 176, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 176, 58))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))

        find(iterator: Iterator<T, boolean>, context?: any): T;
>find : (iterator: Iterator<T, boolean>, context?: any) => T, Symbol(find, Decl(underscoreTest1_underscore.ts, 176, 77))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 177, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 177, 44))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        detect(iterator: Iterator<T, boolean>, context?: any): T;
>detect : (iterator: Iterator<T, boolean>, context?: any) => T, Symbol(detect, Decl(underscoreTest1_underscore.ts, 177, 63))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 178, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 178, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        filter(iterator: Iterator<T, boolean>, context?: any): T[];
>filter : (iterator: Iterator<T, boolean>, context?: any) => T[], Symbol(filter, Decl(underscoreTest1_underscore.ts, 178, 65))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 179, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 179, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        select(iterator: Iterator<T, boolean>, context?: any): T[];
>select : (iterator: Iterator<T, boolean>, context?: any) => T[], Symbol(select, Decl(underscoreTest1_underscore.ts, 179, 67))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 180, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 180, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        where(properties: Object): T[];
>where : (properties: Object) => T[], Symbol(where, Decl(underscoreTest1_underscore.ts, 180, 67))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 181, 14))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        findWhere(properties: Object): T;
>findWhere : (properties: Object) => T, Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 181, 39))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 182, 18))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        reject(iterator: Iterator<T, boolean>, context?: any): T[];
>reject : (iterator: Iterator<T, boolean>, context?: any) => T[], Symbol(reject, Decl(underscoreTest1_underscore.ts, 182, 41))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 183, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 183, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
>every : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(every, Decl(underscoreTest1_underscore.ts, 183, 67))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 184, 14))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 184, 46))

        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
>all : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(all, Decl(underscoreTest1_underscore.ts, 184, 71))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 185, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 185, 44))

        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
>some : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(some, Decl(underscoreTest1_underscore.ts, 185, 69))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 186, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 186, 45))

        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
>any : (iterator?: Iterator<T, boolean>, context?: any) => boolean, Symbol(any, Decl(underscoreTest1_underscore.ts, 186, 70))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 187, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 187, 44))

        contains(value: T): boolean;
>contains : (value: T) => boolean, Symbol(contains, Decl(underscoreTest1_underscore.ts, 187, 69))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 188, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        include(value: T): boolean;
>include : (value: T) => boolean, Symbol(include, Decl(underscoreTest1_underscore.ts, 188, 36))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 189, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        invoke(methodName: string, ...args: any[]): any[];
>invoke : (methodName: string, ...args: any[]) => any[], Symbol(invoke, Decl(underscoreTest1_underscore.ts, 189, 35))
>methodName : string, Symbol(methodName, Decl(underscoreTest1_underscore.ts, 190, 15))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 190, 34))

        pluck(propertyName: string): any[];
>pluck : (propertyName: string) => any[], Symbol(pluck, Decl(underscoreTest1_underscore.ts, 190, 58))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 191, 14))

        max(iterator?: Iterator<T, any>, context?: any): T;
>max : (iterator?: Iterator<T, any>, context?: any) => T, Symbol(max, Decl(underscoreTest1_underscore.ts, 191, 43))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 192, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 192, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        min(iterator?: Iterator<T, any>, context?: any): T;
>min : (iterator?: Iterator<T, any>, context?: any) => T, Symbol(min, Decl(underscoreTest1_underscore.ts, 192, 59))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 193, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 193, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        sortBy(iterator: Iterator<T, any>, context?: any): T[];
>sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 193, 59), Decl(underscoreTest1_underscore.ts, 194, 63))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 194, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 194, 42))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        sortBy(propertyName: string): T[];
>sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 193, 59), Decl(underscoreTest1_underscore.ts, 194, 63))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 195, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 77))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 196, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 196, 44))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        groupBy(propertyName: string): Dictionary<T[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 77))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 197, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 80))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 198, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 198, 44))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        countBy(propertyName: string): Dictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 80))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 199, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        shuffle(): T[];
>shuffle : () => T[], Symbol(shuffle, Decl(underscoreTest1_underscore.ts, 199, 58))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        toArray(): T[];
>toArray : () => T[], Symbol(toArray, Decl(underscoreTest1_underscore.ts, 200, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))

        size(): number;
>size : () => number, Symbol(size, Decl(underscoreTest1_underscore.ts, 201, 23))
    }

    export interface ChainedObject<T> {
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        keys(): ChainedArray<string>;
>keys : () => ChainedArray<string>, Symbol(keys, Decl(underscoreTest1_underscore.ts, 205, 39))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        values(): ChainedArray<any>;
>values : () => ChainedArray<any>, Symbol(values, Decl(underscoreTest1_underscore.ts, 206, 37))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        pairs(): ChainedArray<any[]>;
>pairs : () => ChainedArray<any[]>, Symbol(pairs, Decl(underscoreTest1_underscore.ts, 207, 36))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        invert(): ChainedObject<any>;
>invert : () => ChainedObject<any>, Symbol(invert, Decl(underscoreTest1_underscore.ts, 208, 37))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        functions(): ChainedArray<string>;
>functions : () => ChainedArray<string>, Symbol(functions, Decl(underscoreTest1_underscore.ts, 209, 37))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        methods(): ChainedArray<string>;
>methods : () => ChainedArray<string>, Symbol(methods, Decl(underscoreTest1_underscore.ts, 210, 42))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        extend(...sources: any[]): ChainedObject<T>;
>extend : (...sources: any[]) => ChainedObject<T>, Symbol(extend, Decl(underscoreTest1_underscore.ts, 211, 40))
>sources : any[], Symbol(sources, Decl(underscoreTest1_underscore.ts, 212, 15))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        pick(...keys: string[]): ChainedObject<T>;
>pick : (...keys: string[]) => ChainedObject<T>, Symbol(pick, Decl(underscoreTest1_underscore.ts, 212, 52))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 213, 13))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        omit(...keys: string[]): ChainedObject<T>;
>omit : (...keys: string[]) => ChainedObject<T>, Symbol(omit, Decl(underscoreTest1_underscore.ts, 213, 50))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 214, 13))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        defaults(...defaults: any[]): ChainedObject<T>;
>defaults : (...defaults: any[]) => ChainedObject<T>, Symbol(defaults, Decl(underscoreTest1_underscore.ts, 214, 50))
>defaults : any[], Symbol(defaults, Decl(underscoreTest1_underscore.ts, 215, 17))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        clone(): ChainedObject<T>;
>clone : () => ChainedObject<T>, Symbol(clone, Decl(underscoreTest1_underscore.ts, 215, 55))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        tap(interceptor: (object: T) => void): ChainedObject<T>;
>tap : (interceptor: (object: T) => void) => ChainedObject<T>, Symbol(tap, Decl(underscoreTest1_underscore.ts, 216, 34))
>interceptor : (object: T) => void, Symbol(interceptor, Decl(underscoreTest1_underscore.ts, 217, 12))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 217, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))

        has(key: string): ChainedObject<boolean>;
>has : (key: string) => ChainedObject<boolean>, Symbol(has, Decl(underscoreTest1_underscore.ts, 217, 64))
>key : string, Symbol(key, Decl(underscoreTest1_underscore.ts, 218, 12))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isEqual(other: T): ChainedObject<boolean>;
>isEqual : (other: T) => ChainedObject<boolean>, Symbol(isEqual, Decl(underscoreTest1_underscore.ts, 218, 49))
>other : T, Symbol(other, Decl(underscoreTest1_underscore.ts, 219, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isEmpty(): ChainedObject<boolean>;
>isEmpty : () => ChainedObject<boolean>, Symbol(isEmpty, Decl(underscoreTest1_underscore.ts, 219, 50))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isElement(): ChainedObject<boolean>;
>isElement : () => ChainedObject<boolean>, Symbol(isElement, Decl(underscoreTest1_underscore.ts, 220, 42))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isArray(): ChainedObject<boolean>;
>isArray : () => ChainedObject<boolean>, Symbol(isArray, Decl(underscoreTest1_underscore.ts, 221, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isObject(): ChainedObject<boolean>;
>isObject : () => ChainedObject<boolean>, Symbol(isObject, Decl(underscoreTest1_underscore.ts, 222, 42))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isArguments(): ChainedObject<boolean>;
>isArguments : () => ChainedObject<boolean>, Symbol(isArguments, Decl(underscoreTest1_underscore.ts, 223, 43))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isFunction(): ChainedObject<boolean>;
>isFunction : () => ChainedObject<boolean>, Symbol(isFunction, Decl(underscoreTest1_underscore.ts, 224, 46))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isString(): ChainedObject<boolean>;
>isString : () => ChainedObject<boolean>, Symbol(isString, Decl(underscoreTest1_underscore.ts, 225, 45))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isNumber(): ChainedObject<boolean>;
>isNumber : () => ChainedObject<boolean>, Symbol(isNumber, Decl(underscoreTest1_underscore.ts, 226, 43))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isFinite(): ChainedObject<boolean>;
>isFinite : () => ChainedObject<boolean>, Symbol(isFinite, Decl(underscoreTest1_underscore.ts, 227, 43))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isBoolean(): ChainedObject<boolean>;
>isBoolean : () => ChainedObject<boolean>, Symbol(isBoolean, Decl(underscoreTest1_underscore.ts, 228, 43))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isDate(): ChainedObject<boolean>;
>isDate : () => ChainedObject<boolean>, Symbol(isDate, Decl(underscoreTest1_underscore.ts, 229, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isRegExp(): ChainedObject<boolean>;
>isRegExp : () => ChainedObject<boolean>, Symbol(isRegExp, Decl(underscoreTest1_underscore.ts, 230, 41))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isNaN(): ChainedObject<boolean>;
>isNaN : () => ChainedObject<boolean>, Symbol(isNaN, Decl(underscoreTest1_underscore.ts, 231, 43))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isNull(): ChainedObject<boolean>;
>isNull : () => ChainedObject<boolean>, Symbol(isNull, Decl(underscoreTest1_underscore.ts, 232, 40))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        isUndefined(): ChainedObject<boolean>;
>isUndefined : () => ChainedObject<boolean>, Symbol(isUndefined, Decl(underscoreTest1_underscore.ts, 233, 41))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        value(): T;
>value : () => T, Symbol(value, Decl(underscoreTest1_underscore.ts, 234, 46))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 205, 35))
    }

    export interface ChainedArray<T> extends ChainedObject<Array<T>> {
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>Array : T[], Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
>each : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>, Symbol(each, Decl(underscoreTest1_underscore.ts, 238, 70))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 239, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 239, 41))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
>forEach : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>, Symbol(forEach, Decl(underscoreTest1_underscore.ts, 239, 78))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 240, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 240, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
>map : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>, Symbol(map, Decl(underscoreTest1_underscore.ts, 240, 81))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 241, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 241, 40))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12))

        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
>collect : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>, Symbol(collect, Decl(underscoreTest1_underscore.ts, 241, 73))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 242, 19))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 242, 44))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16))

        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 242, 77), Decl(underscoreTest1_underscore.ts, 243, 91))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 243, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 243, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 243, 57))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 242, 77), Decl(underscoreTest1_underscore.ts, 243, 91))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 244, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 244, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 244, 59))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))

        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 244, 93), Decl(underscoreTest1_underscore.ts, 245, 90))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 245, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 245, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 245, 56))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 244, 93), Decl(underscoreTest1_underscore.ts, 245, 90))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 246, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 246, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 246, 58))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))

        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 246, 92), Decl(underscoreTest1_underscore.ts, 247, 91))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 247, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 247, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 247, 57))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 246, 92), Decl(underscoreTest1_underscore.ts, 247, 91))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 248, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 248, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 248, 59))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))

        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 248, 93), Decl(underscoreTest1_underscore.ts, 249, 96))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 249, 20))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 249, 44))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 249, 62))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 248, 93), Decl(underscoreTest1_underscore.ts, 249, 96))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 250, 23))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 250, 47))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 250, 64))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))

        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 250, 98), Decl(underscoreTest1_underscore.ts, 251, 90))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 251, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 251, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 251, 56))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 250, 98), Decl(underscoreTest1_underscore.ts, 251, 90))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 252, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 252, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 252, 58))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))

        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
>find : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>, Symbol(find, Decl(underscoreTest1_underscore.ts, 252, 92))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 253, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 253, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
>detect : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>, Symbol(detect, Decl(underscoreTest1_underscore.ts, 253, 78))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 254, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 254, 46))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
>filter : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>, Symbol(filter, Decl(underscoreTest1_underscore.ts, 254, 80))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 255, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 255, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
>select : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>, Symbol(select, Decl(underscoreTest1_underscore.ts, 255, 79))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 256, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 256, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        where(properties: Object): ChainedArray<T>;
>where : (properties: Object) => ChainedArray<T>, Symbol(where, Decl(underscoreTest1_underscore.ts, 256, 79))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 257, 14))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        findWhere(properties: Object): ChainedObject<T>;
>findWhere : (properties: Object) => ChainedObject<T>, Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 257, 51))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 258, 18))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
>reject : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>, Symbol(reject, Decl(underscoreTest1_underscore.ts, 258, 56))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 259, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 259, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>every : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(every, Decl(underscoreTest1_underscore.ts, 259, 79))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 260, 14))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 260, 46))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>all : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(all, Decl(underscoreTest1_underscore.ts, 260, 86))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 261, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 261, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>some : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(some, Decl(underscoreTest1_underscore.ts, 261, 84))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 262, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 262, 45))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>any : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(any, Decl(underscoreTest1_underscore.ts, 262, 85))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 263, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 263, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        contains(value: T): ChainedObject<boolean>;
>contains : (value: T) => ChainedObject<boolean>, Symbol(contains, Decl(underscoreTest1_underscore.ts, 263, 84))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 264, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        include(value: T): ChainedObject<boolean>;
>include : (value: T) => ChainedObject<boolean>, Symbol(include, Decl(underscoreTest1_underscore.ts, 264, 51))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 265, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        invoke(methodName: string, ...args: any[]): ChainedArray<any>;
>invoke : (methodName: string, ...args: any[]) => ChainedArray<any>, Symbol(invoke, Decl(underscoreTest1_underscore.ts, 265, 50))
>methodName : string, Symbol(methodName, Decl(underscoreTest1_underscore.ts, 266, 15))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 266, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        pluck(propertyName: string): ChainedArray<any>;
>pluck : (propertyName: string) => ChainedArray<any>, Symbol(pluck, Decl(underscoreTest1_underscore.ts, 266, 70))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 267, 14))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
>max : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>, Symbol(max, Decl(underscoreTest1_underscore.ts, 267, 55))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 268, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 268, 40))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
>min : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>, Symbol(min, Decl(underscoreTest1_underscore.ts, 268, 74))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 269, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 269, 40))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
>sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 269, 74), Decl(underscoreTest1_underscore.ts, 270, 75))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 270, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 270, 42))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        sortBy(propertyName: string): ChainedArray<T>;
>sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 269, 74), Decl(underscoreTest1_underscore.ts, 270, 75))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 271, 15))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 86))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 273, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 273, 44))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        groupBy(propertyName: string): ChainedDictionary<any[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 86))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 274, 16))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 87))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 275, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 275, 44))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        countBy(propertyName: string): ChainedDictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 87))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 276, 16))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        shuffle(): ChainedArray<T>;
>shuffle : () => ChainedArray<T>, Symbol(shuffle, Decl(underscoreTest1_underscore.ts, 276, 65))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        toArray(): ChainedArray<T>;
>toArray : () => ChainedArray<T>, Symbol(toArray, Decl(underscoreTest1_underscore.ts, 277, 35))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        size(): ChainedObject<number>;
>size : () => ChainedObject<number>, Symbol(size, Decl(underscoreTest1_underscore.ts, 278, 35))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        first(): ChainedObject<T>;
>first : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(first, Decl(underscoreTest1_underscore.ts, 279, 38), Decl(underscoreTest1_underscore.ts, 280, 34))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        first(count: number): ChainedArray<T>;
>first : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(first, Decl(underscoreTest1_underscore.ts, 279, 38), Decl(underscoreTest1_underscore.ts, 280, 34))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 281, 14))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        head(): ChainedObject<T>;
>head : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(head, Decl(underscoreTest1_underscore.ts, 281, 46), Decl(underscoreTest1_underscore.ts, 282, 33))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        head(count: number): ChainedArray<T>;
>head : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(head, Decl(underscoreTest1_underscore.ts, 281, 46), Decl(underscoreTest1_underscore.ts, 282, 33))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 283, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        take(): ChainedObject<T>;
>take : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(take, Decl(underscoreTest1_underscore.ts, 283, 45), Decl(underscoreTest1_underscore.ts, 284, 33))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        take(count: number): ChainedArray<T>;
>take : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(take, Decl(underscoreTest1_underscore.ts, 283, 45), Decl(underscoreTest1_underscore.ts, 284, 33))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 285, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        initial(): ChainedObject<T>;
>initial : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(initial, Decl(underscoreTest1_underscore.ts, 285, 45), Decl(underscoreTest1_underscore.ts, 286, 36))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        initial(count: number): ChainedArray<T>;
>initial : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(initial, Decl(underscoreTest1_underscore.ts, 285, 45), Decl(underscoreTest1_underscore.ts, 286, 36))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 287, 16))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        last(): ChainedObject<T>;
>last : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(last, Decl(underscoreTest1_underscore.ts, 287, 48), Decl(underscoreTest1_underscore.ts, 288, 33))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        last(count: number): ChainedArray<T>;
>last : { (): ChainedObject<T>; (count: number): ChainedArray<T>; }, Symbol(last, Decl(underscoreTest1_underscore.ts, 287, 48), Decl(underscoreTest1_underscore.ts, 288, 33))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 289, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        rest(index?: number): ChainedArray<T>;
>rest : (index?: number) => ChainedArray<T>, Symbol(rest, Decl(underscoreTest1_underscore.ts, 289, 45))
>index : number, Symbol(index, Decl(underscoreTest1_underscore.ts, 290, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        compact(): ChainedArray<T>;
>compact : () => ChainedArray<T>, Symbol(compact, Decl(underscoreTest1_underscore.ts, 290, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        flatten<U>(shallow?: boolean): ChainedArray<U>;
>flatten : <U>(shallow?: boolean) => ChainedArray<U>, Symbol(flatten, Decl(underscoreTest1_underscore.ts, 291, 35))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 292, 16))
>shallow : boolean, Symbol(shallow, Decl(underscoreTest1_underscore.ts, 292, 19))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 292, 16))

        without(...values: T[]): ChainedArray<T>;
>without : (...values: T[]) => ChainedArray<T>, Symbol(without, Decl(underscoreTest1_underscore.ts, 292, 55))
>values : T[], Symbol(values, Decl(underscoreTest1_underscore.ts, 293, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        union(...arrays: T[][]): ChainedArray<T>;
>union : (...arrays: T[][]) => ChainedArray<T>, Symbol(union, Decl(underscoreTest1_underscore.ts, 293, 49))
>arrays : T[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 294, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        intersection(...arrays: T[][]): ChainedArray<T>;
>intersection : (...arrays: T[][]) => ChainedArray<T>, Symbol(intersection, Decl(underscoreTest1_underscore.ts, 294, 49))
>arrays : T[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 295, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        difference(...others: T[][]): ChainedArray<T>;
>difference : (...others: T[][]) => ChainedArray<T>, Symbol(difference, Decl(underscoreTest1_underscore.ts, 295, 56))
>others : T[][], Symbol(others, Decl(underscoreTest1_underscore.ts, 296, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        uniq(isSorted?: boolean): ChainedArray<T>;
>uniq : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }, Symbol(uniq, Decl(underscoreTest1_underscore.ts, 296, 54), Decl(underscoreTest1_underscore.ts, 297, 50))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 297, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
>uniq : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }, Symbol(uniq, Decl(underscoreTest1_underscore.ts, 296, 54), Decl(underscoreTest1_underscore.ts, 297, 50))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 298, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 298, 34))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 298, 60))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13))

        unique(isSorted?: boolean): ChainedArray<T>;
>unique : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }, Symbol(unique, Decl(underscoreTest1_underscore.ts, 298, 93), Decl(underscoreTest1_underscore.ts, 299, 52))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 299, 15))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
>unique : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }, Symbol(unique, Decl(underscoreTest1_underscore.ts, 298, 93), Decl(underscoreTest1_underscore.ts, 299, 52))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 300, 18))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 300, 36))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 300, 62))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15))

        zip(...arrays: any[][]): ChainedArray<any[]>;
>zip : (...arrays: any[][]) => ChainedArray<any[]>, Symbol(zip, Decl(underscoreTest1_underscore.ts, 300, 95))
>arrays : any[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 301, 12))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        object(): ChainedObject<any>;
>object : { (): ChainedObject<any>; (values: any[]): ChainedObject<any>; }, Symbol(object, Decl(underscoreTest1_underscore.ts, 301, 53), Decl(underscoreTest1_underscore.ts, 302, 37))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        object(values: any[]): ChainedObject<any>;
>object : { (): ChainedObject<any>; (values: any[]): ChainedObject<any>; }, Symbol(object, Decl(underscoreTest1_underscore.ts, 301, 53), Decl(underscoreTest1_underscore.ts, 302, 37))
>values : any[], Symbol(values, Decl(underscoreTest1_underscore.ts, 303, 15))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        indexOf(value: T, isSorted?: boolean): ChainedObject<number>;
>indexOf : (value: T, isSorted?: boolean) => ChainedObject<number>, Symbol(indexOf, Decl(underscoreTest1_underscore.ts, 303, 50))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 304, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 304, 25))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        lastIndexOf(value: T, fromIndex?: number): ChainedObject<number>;
>lastIndexOf : (value: T, fromIndex?: number) => ChainedObject<number>, Symbol(lastIndexOf, Decl(underscoreTest1_underscore.ts, 304, 69))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 305, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>fromIndex : number, Symbol(fromIndex, Decl(underscoreTest1_underscore.ts, 305, 29))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        sortedIndex(obj: T, propertyName: string): ChainedObject<number>;
>sortedIndex : { (obj: T, propertyName: string): ChainedObject<number>; (obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>; }, Symbol(sortedIndex, Decl(underscoreTest1_underscore.ts, 305, 73), Decl(underscoreTest1_underscore.ts, 306, 73))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 306, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 306, 27))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>;
>sortedIndex : { (obj: T, propertyName: string): ChainedObject<number>; (obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>; }, Symbol(sortedIndex, Decl(underscoreTest1_underscore.ts, 305, 73), Decl(underscoreTest1_underscore.ts, 306, 73))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 307, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 307, 27))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 307, 56))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        // Methods from Array
        concat(...items: T[]): ChainedArray<T>;
>concat : (...items: T[]) => ChainedArray<T>, Symbol(concat, Decl(underscoreTest1_underscore.ts, 307, 95))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 309, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        join(separator?: string): ChainedObject<string>;
>join : (separator?: string) => ChainedObject<string>, Symbol(join, Decl(underscoreTest1_underscore.ts, 309, 47))
>separator : string, Symbol(separator, Decl(underscoreTest1_underscore.ts, 310, 13))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        pop(): ChainedObject<T>;
>pop : () => ChainedObject<T>, Symbol(pop, Decl(underscoreTest1_underscore.ts, 310, 56))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        push(...items: T[]): ChainedObject<number>;
>push : (...items: T[]) => ChainedObject<number>, Symbol(push, Decl(underscoreTest1_underscore.ts, 311, 32))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 312, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        reverse(): ChainedArray<T>;
>reverse : () => ChainedArray<T>, Symbol(reverse, Decl(underscoreTest1_underscore.ts, 312, 51))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        shift(): ChainedObject<T>;
>shift : () => ChainedObject<T>, Symbol(shift, Decl(underscoreTest1_underscore.ts, 313, 35))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        slice(start: number, end?: number): ChainedArray<T>;
>slice : (start: number, end?: number) => ChainedArray<T>, Symbol(slice, Decl(underscoreTest1_underscore.ts, 314, 34))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 315, 14))
>end : number, Symbol(end, Decl(underscoreTest1_underscore.ts, 315, 28))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        sort(compareFn?: (a: T, b: T) => number): ChainedArray<T>;
>sort : (compareFn?: (a: T, b: T) => number) => ChainedArray<T>, Symbol(sort, Decl(underscoreTest1_underscore.ts, 315, 60))
>compareFn : (a: T, b: T) => number, Symbol(compareFn, Decl(underscoreTest1_underscore.ts, 316, 13))
>a : T, Symbol(a, Decl(underscoreTest1_underscore.ts, 316, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>b : T, Symbol(b, Decl(underscoreTest1_underscore.ts, 316, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        splice(start: number): ChainedArray<T>;
>splice : { (start: number): ChainedArray<T>; (start: number, deleteCount: number, ...items: T[]): ChainedArray<T>; }, Symbol(splice, Decl(underscoreTest1_underscore.ts, 316, 66), Decl(underscoreTest1_underscore.ts, 317, 47))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 317, 15))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        splice(start: number, deleteCount: number, ...items: T[]): ChainedArray<T>;
>splice : { (start: number): ChainedArray<T>; (start: number, deleteCount: number, ...items: T[]): ChainedArray<T>; }, Symbol(splice, Decl(underscoreTest1_underscore.ts, 316, 66), Decl(underscoreTest1_underscore.ts, 317, 47))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 318, 15))
>deleteCount : number, Symbol(deleteCount, Decl(underscoreTest1_underscore.ts, 318, 29))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 318, 50))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        unshift(...items: T[]): ChainedObject<number>;
>unshift : (...items: T[]) => ChainedObject<number>, Symbol(unshift, Decl(underscoreTest1_underscore.ts, 318, 83))
>items : T[], Symbol(items, Decl(underscoreTest1_underscore.ts, 319, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        // Methods from ChainedObject with promoted return types
        extend(...sources: any[]): ChainedArray<T>;
>extend : (...sources: any[]) => ChainedArray<T>, Symbol(extend, Decl(underscoreTest1_underscore.ts, 319, 54))
>sources : any[], Symbol(sources, Decl(underscoreTest1_underscore.ts, 321, 15))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        pick(...keys: string[]): ChainedArray<T>;
>pick : (...keys: string[]) => ChainedArray<T>, Symbol(pick, Decl(underscoreTest1_underscore.ts, 321, 51))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 322, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        omit(...keys: string[]): ChainedArray<T>;
>omit : (...keys: string[]) => ChainedArray<T>, Symbol(omit, Decl(underscoreTest1_underscore.ts, 322, 49))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 323, 13))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        defaults(...defaults: any[]): ChainedArray<T>;
>defaults : (...defaults: any[]) => ChainedArray<T>, Symbol(defaults, Decl(underscoreTest1_underscore.ts, 323, 49))
>defaults : any[], Symbol(defaults, Decl(underscoreTest1_underscore.ts, 324, 17))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        clone(): ChainedArray<T>;
>clone : () => ChainedArray<T>, Symbol(clone, Decl(underscoreTest1_underscore.ts, 324, 54))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))

        tap(interceptor: (object: T[]) => void): ChainedArray<T>;
>tap : (interceptor: (object: T[]) => void) => ChainedArray<T>, Symbol(tap, Decl(underscoreTest1_underscore.ts, 325, 33))
>interceptor : (object: T[]) => void, Symbol(interceptor, Decl(underscoreTest1_underscore.ts, 326, 12))
>object : T[], Symbol(object, Decl(underscoreTest1_underscore.ts, 326, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
    }

    export interface ChainedDictionary<T> extends ChainedObject<Dictionary<T>> {
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
>each : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>, Symbol(each, Decl(underscoreTest1_underscore.ts, 329, 80))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 330, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 330, 41))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
>forEach : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>, Symbol(forEach, Decl(underscoreTest1_underscore.ts, 330, 78))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 331, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 331, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
>map : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>, Symbol(map, Decl(underscoreTest1_underscore.ts, 331, 81))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 332, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 332, 40))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12))

        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
>collect : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>, Symbol(collect, Decl(underscoreTest1_underscore.ts, 332, 73))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 333, 19))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 333, 44))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16))

        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 333, 77), Decl(underscoreTest1_underscore.ts, 334, 91))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 334, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 334, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 334, 57))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 333, 77), Decl(underscoreTest1_underscore.ts, 334, 91))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 335, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 335, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 335, 59))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))

        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 335, 93), Decl(underscoreTest1_underscore.ts, 336, 90))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 336, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 336, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 336, 56))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 335, 93), Decl(underscoreTest1_underscore.ts, 336, 90))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 337, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 337, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 337, 58))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))

        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 337, 92), Decl(underscoreTest1_underscore.ts, 338, 91))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 338, 15))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 338, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 338, 57))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 337, 92), Decl(underscoreTest1_underscore.ts, 338, 91))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 339, 18))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 339, 42))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 339, 59))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))

        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 339, 93), Decl(underscoreTest1_underscore.ts, 340, 96))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 340, 20))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 340, 44))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 340, 62))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 339, 93), Decl(underscoreTest1_underscore.ts, 340, 96))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 341, 23))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 341, 47))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 341, 64))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))

        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 341, 98), Decl(underscoreTest1_underscore.ts, 342, 90))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 342, 14))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 342, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 342, 56))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
>foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 341, 98), Decl(underscoreTest1_underscore.ts, 342, 90))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 343, 17))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 343, 41))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 343, 58))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))

        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
>find : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>, Symbol(find, Decl(underscoreTest1_underscore.ts, 343, 92))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 344, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 344, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
>detect : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>, Symbol(detect, Decl(underscoreTest1_underscore.ts, 344, 78))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 345, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 345, 46))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
>filter : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>, Symbol(filter, Decl(underscoreTest1_underscore.ts, 345, 80))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 346, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 346, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
>select : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>, Symbol(select, Decl(underscoreTest1_underscore.ts, 346, 79))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 347, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 347, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        where(properties: Object): ChainedArray<T>;
>where : (properties: Object) => ChainedArray<T>, Symbol(where, Decl(underscoreTest1_underscore.ts, 347, 79))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 348, 14))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        findWhere(properties: Object): ChainedObject<T>;
>findWhere : (properties: Object) => ChainedObject<T>, Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 348, 51))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 349, 18))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
>reject : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>, Symbol(reject, Decl(underscoreTest1_underscore.ts, 349, 56))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 350, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 350, 46))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>every : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(every, Decl(underscoreTest1_underscore.ts, 350, 79))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 351, 14))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 351, 46))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>all : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(all, Decl(underscoreTest1_underscore.ts, 351, 86))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 352, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 352, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>some : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(some, Decl(underscoreTest1_underscore.ts, 352, 84))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 353, 13))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 353, 45))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
>any : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>, Symbol(any, Decl(underscoreTest1_underscore.ts, 353, 85))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 354, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 354, 44))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        contains(value: T): ChainedObject<boolean>;
>contains : (value: T) => ChainedObject<boolean>, Symbol(contains, Decl(underscoreTest1_underscore.ts, 354, 84))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 355, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        include(value: T): ChainedObject<boolean>;
>include : (value: T) => ChainedObject<boolean>, Symbol(include, Decl(underscoreTest1_underscore.ts, 355, 51))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 356, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        invoke(methodName: string, ...args: any[]): ChainedArray<any>;
>invoke : (methodName: string, ...args: any[]) => ChainedArray<any>, Symbol(invoke, Decl(underscoreTest1_underscore.ts, 356, 50))
>methodName : string, Symbol(methodName, Decl(underscoreTest1_underscore.ts, 357, 15))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 357, 34))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        pluck(propertyName: string): ChainedArray<any>;
>pluck : (propertyName: string) => ChainedArray<any>, Symbol(pluck, Decl(underscoreTest1_underscore.ts, 357, 70))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 358, 14))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))

        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
>max : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>, Symbol(max, Decl(underscoreTest1_underscore.ts, 358, 55))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 359, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 359, 40))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
>min : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>, Symbol(min, Decl(underscoreTest1_underscore.ts, 359, 74))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 360, 12))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 360, 40))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
>sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 360, 74), Decl(underscoreTest1_underscore.ts, 361, 75))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 361, 15))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 361, 42))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        sortBy(propertyName: string): ChainedArray<T>;
>sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 360, 74), Decl(underscoreTest1_underscore.ts, 361, 75))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 362, 15))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 86))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 364, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 364, 44))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        groupBy(propertyName: string): ChainedDictionary<any[]>;
>groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 86))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 365, 16))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 87))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 366, 16))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 366, 44))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        countBy(propertyName: string): ChainedDictionary<number>;
>countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 87))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 367, 16))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))

        shuffle(): ChainedArray<T>;
>shuffle : () => ChainedArray<T>, Symbol(shuffle, Decl(underscoreTest1_underscore.ts, 367, 65))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        toArray(): ChainedArray<T>;
>toArray : () => ChainedArray<T>, Symbol(toArray, Decl(underscoreTest1_underscore.ts, 368, 35))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        size(): ChainedObject<number>;
>size : () => ChainedObject<number>, Symbol(size, Decl(underscoreTest1_underscore.ts, 369, 35))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))

        // Methods from ChainedObject with promoted return types
        extend(...sources: any[]): ChainedDictionary<T>;
>extend : (...sources: any[]) => ChainedDictionary<T>, Symbol(extend, Decl(underscoreTest1_underscore.ts, 370, 38))
>sources : any[], Symbol(sources, Decl(underscoreTest1_underscore.ts, 372, 15))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        pick(...keys: string[]): ChainedDictionary<T>;
>pick : (...keys: string[]) => ChainedDictionary<T>, Symbol(pick, Decl(underscoreTest1_underscore.ts, 372, 56))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 373, 13))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        omit(...keys: string[]): ChainedDictionary<T>;
>omit : (...keys: string[]) => ChainedDictionary<T>, Symbol(omit, Decl(underscoreTest1_underscore.ts, 373, 54))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 374, 13))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        defaults(...defaults: any[]): ChainedDictionary<T>;
>defaults : (...defaults: any[]) => ChainedDictionary<T>, Symbol(defaults, Decl(underscoreTest1_underscore.ts, 374, 54))
>defaults : any[], Symbol(defaults, Decl(underscoreTest1_underscore.ts, 375, 17))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        clone(): ChainedDictionary<T>;
>clone : () => ChainedDictionary<T>, Symbol(clone, Decl(underscoreTest1_underscore.ts, 375, 59))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))

        tap(interceptor: (object: Dictionary<T>) => void): ChainedDictionary<T>;
>tap : (interceptor: (object: Dictionary<T>) => void) => ChainedDictionary<T>, Symbol(tap, Decl(underscoreTest1_underscore.ts, 376, 38))
>interceptor : (object: Dictionary<T>) => void, Symbol(interceptor, Decl(underscoreTest1_underscore.ts, 377, 12))
>object : Dictionary<T>, Symbol(object, Decl(underscoreTest1_underscore.ts, 377, 26))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
    }

    export interface TemplateSettings {
>TemplateSettings : TemplateSettings, Symbol(TemplateSettings, Decl(underscoreTest1_underscore.ts, 378, 5))

        evaluate?: RegExp;
>evaluate : RegExp, Symbol(evaluate, Decl(underscoreTest1_underscore.ts, 380, 39))
>RegExp : RegExp, Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))

        interpolate?: RegExp;
>interpolate : RegExp, Symbol(interpolate, Decl(underscoreTest1_underscore.ts, 381, 26))
>RegExp : RegExp, Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))

        escape?: RegExp;
>escape : RegExp, Symbol(escape, Decl(underscoreTest1_underscore.ts, 382, 29))
>RegExp : RegExp, Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
    }

    export interface Static {
>Static : Static, Symbol(Static, Decl(underscoreTest1_underscore.ts, 384, 5))

        <T>(list: T[]): WrappedArray<T>;
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 387, 9))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 387, 12))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 387, 9))
>WrappedArray : WrappedArray<T>, Symbol(WrappedArray, Decl(underscoreTest1_underscore.ts, 77, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 387, 9))

        <T>(list: Dictionary<T>): WrappedDictionary<T>;
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 388, 9))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 388, 12))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 388, 9))
>WrappedDictionary : WrappedDictionary<T>, Symbol(WrappedDictionary, Decl(underscoreTest1_underscore.ts, 160, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 388, 9))

        <T extends Function>(func: T): WrappedFunction<T>;
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 389, 9))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 389, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 389, 9))
>WrappedFunction : WrappedFunction<T>, Symbol(WrappedFunction, Decl(underscoreTest1_underscore.ts, 62, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 389, 9))

        <T>(obj: T): WrappedObject<T>;
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 390, 12))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9))
>WrappedObject : WrappedObject<T>, Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9))

        chain<T>(list: T[]): ChainedArray<T>;
>chain : { <T>(list: T[]): ChainedArray<T>; <T>(list: Dictionary<T>): ChainedDictionary<T>; <T>(obj: T): ChainedObject<T>; }, Symbol(chain, Decl(underscoreTest1_underscore.ts, 390, 38), Decl(underscoreTest1_underscore.ts, 392, 45), Decl(underscoreTest1_underscore.ts, 393, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 392, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 392, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 392, 14))
>ChainedArray : ChainedArray<T>, Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 392, 14))

        chain<T>(list: Dictionary<T>): ChainedDictionary<T>;
>chain : { <T>(list: T[]): ChainedArray<T>; <T>(list: Dictionary<T>): ChainedDictionary<T>; <T>(obj: T): ChainedObject<T>; }, Symbol(chain, Decl(underscoreTest1_underscore.ts, 390, 38), Decl(underscoreTest1_underscore.ts, 392, 45), Decl(underscoreTest1_underscore.ts, 393, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 393, 14))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 393, 17))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 393, 14))
>ChainedDictionary : ChainedDictionary<T>, Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 393, 14))

        chain<T>(obj: T): ChainedObject<T>;
>chain : { <T>(list: T[]): ChainedArray<T>; <T>(list: Dictionary<T>): ChainedDictionary<T>; <T>(obj: T): ChainedObject<T>; }, Symbol(chain, Decl(underscoreTest1_underscore.ts, 390, 38), Decl(underscoreTest1_underscore.ts, 392, 45), Decl(underscoreTest1_underscore.ts, 393, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 394, 14))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 394, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 394, 14))
>ChainedObject : ChainedObject<T>, Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 394, 14))

        each<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
>each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 396, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 396, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 396, 13))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 396, 26))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 396, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 396, 55))

        each<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
>each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(each, Decl(underscoreTest1_underscore.ts, 394, 43), Decl(underscoreTest1_underscore.ts, 396, 77))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 397, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 397, 36))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 397, 65))

        forEach<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
>forEach : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(forEach, Decl(underscoreTest1_underscore.ts, 397, 87), Decl(underscoreTest1_underscore.ts, 398, 80))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 398, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 16))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 398, 29))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 398, 58))

        forEach<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
>forEach : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }, Symbol(forEach, Decl(underscoreTest1_underscore.ts, 397, 87), Decl(underscoreTest1_underscore.ts, 398, 80))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 399, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16))
>iterator : Iterator<T, void>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 399, 39))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 399, 68))

        map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
>map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 401, 12))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 401, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 401, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 401, 12))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 401, 28))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 401, 12))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 401, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 401, 54))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 401, 14))

        map<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
>map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(map, Decl(underscoreTest1_underscore.ts, 399, 90), Decl(underscoreTest1_underscore.ts, 401, 75))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 402, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 402, 38))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 402, 64))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14))

        collect<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
>collect : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(collect, Decl(underscoreTest1_underscore.ts, 402, 85), Decl(underscoreTest1_underscore.ts, 403, 79))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 16))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 18))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 403, 22))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 403, 32))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 16))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 18))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 403, 58))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 18))

        collect<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
>collect : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(collect, Decl(underscoreTest1_underscore.ts, 402, 85), Decl(underscoreTest1_underscore.ts, 403, 79))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 404, 22))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 404, 42))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 404, 68))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18))

        reduce<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 406, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 406, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 406, 15))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 406, 28))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 406, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 406, 15))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 406, 53))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 406, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 406, 71))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 406, 15))

        reduce<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 407, 17))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 407, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 407, 31))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 407, 17))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 407, 56))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 407, 17))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 407, 73))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 407, 17))

        reduce<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 408, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 408, 38))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 408, 63))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 408, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))

        reduce<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduce, Decl(underscoreTest1_underscore.ts, 404, 89), Decl(underscoreTest1_underscore.ts, 406, 90), Decl(underscoreTest1_underscore.ts, 407, 92), Decl(underscoreTest1_underscore.ts, 408, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 409, 17))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 409, 21))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 409, 41))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 409, 17))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 409, 66))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 409, 17))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 409, 83))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 409, 17))

        foldl<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 409, 102), Decl(underscoreTest1_underscore.ts, 410, 89), Decl(underscoreTest1_underscore.ts, 411, 91), Decl(underscoreTest1_underscore.ts, 412, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 410, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 14))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 410, 27))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 14))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 410, 52))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 410, 70))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 14))

        foldl<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 409, 102), Decl(underscoreTest1_underscore.ts, 410, 89), Decl(underscoreTest1_underscore.ts, 411, 91), Decl(underscoreTest1_underscore.ts, 412, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 411, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 411, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 411, 30))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 411, 16))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 411, 55))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 411, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 411, 72))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 411, 16))

        foldl<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 409, 102), Decl(underscoreTest1_underscore.ts, 410, 89), Decl(underscoreTest1_underscore.ts, 411, 91), Decl(underscoreTest1_underscore.ts, 412, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 412, 17))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 412, 37))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 412, 62))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 412, 80))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))

        foldl<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldl, Decl(underscoreTest1_underscore.ts, 409, 102), Decl(underscoreTest1_underscore.ts, 410, 89), Decl(underscoreTest1_underscore.ts, 411, 91), Decl(underscoreTest1_underscore.ts, 412, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 413, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 413, 20))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 413, 40))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 413, 16))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 413, 65))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 413, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 413, 82))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 413, 16))

        inject<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 413, 101), Decl(underscoreTest1_underscore.ts, 414, 90), Decl(underscoreTest1_underscore.ts, 415, 92), Decl(underscoreTest1_underscore.ts, 416, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 414, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 15))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 414, 28))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 15))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 414, 53))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 414, 71))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 15))

        inject<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 413, 101), Decl(underscoreTest1_underscore.ts, 414, 90), Decl(underscoreTest1_underscore.ts, 415, 92), Decl(underscoreTest1_underscore.ts, 416, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 415, 17))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 415, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 415, 31))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 415, 17))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 415, 56))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 415, 17))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 415, 73))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 415, 17))

        inject<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 413, 101), Decl(underscoreTest1_underscore.ts, 414, 90), Decl(underscoreTest1_underscore.ts, 415, 92), Decl(underscoreTest1_underscore.ts, 416, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 416, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 416, 38))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 416, 63))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 416, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))

        inject<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(inject, Decl(underscoreTest1_underscore.ts, 413, 101), Decl(underscoreTest1_underscore.ts, 414, 90), Decl(underscoreTest1_underscore.ts, 415, 92), Decl(underscoreTest1_underscore.ts, 416, 100))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 417, 17))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 417, 21))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 417, 41))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 417, 17))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 417, 66))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 417, 17))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 417, 83))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 417, 17))

        reduceRight<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 419, 20))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 419, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 419, 20))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 419, 33))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 419, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 419, 20))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 419, 58))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 419, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 419, 76))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 419, 20))

        reduceRight<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 420, 22))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 420, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 420, 36))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 420, 22))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 420, 61))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 420, 22))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 420, 78))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 420, 22))

        reduceRight<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 421, 23))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 421, 43))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 421, 68))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 421, 86))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))

        reduceRight<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(reduceRight, Decl(underscoreTest1_underscore.ts, 417, 102), Decl(underscoreTest1_underscore.ts, 419, 95), Decl(underscoreTest1_underscore.ts, 420, 97), Decl(underscoreTest1_underscore.ts, 421, 105))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 422, 22))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 422, 26))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 422, 46))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 422, 22))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 422, 71))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 422, 22))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 422, 88))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 422, 22))

        foldr<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 422, 107), Decl(underscoreTest1_underscore.ts, 423, 89), Decl(underscoreTest1_underscore.ts, 424, 91), Decl(underscoreTest1_underscore.ts, 425, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 423, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 14))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 423, 27))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 14))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 423, 52))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 423, 70))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 14))

        foldr<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 422, 107), Decl(underscoreTest1_underscore.ts, 423, 89), Decl(underscoreTest1_underscore.ts, 424, 91), Decl(underscoreTest1_underscore.ts, 425, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 424, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 424, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 424, 30))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 424, 16))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 424, 55))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 424, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 424, 72))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 424, 16))

        foldr<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
>foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 422, 107), Decl(underscoreTest1_underscore.ts, 423, 89), Decl(underscoreTest1_underscore.ts, 424, 91), Decl(underscoreTest1_underscore.ts, 425, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 425, 17))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
>iterator : Reducer<T, T>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 425, 37))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
>initialValue : T, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 425, 62))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 425, 80))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))

        foldr<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
>foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }, Symbol(foldr, Decl(underscoreTest1_underscore.ts, 422, 107), Decl(underscoreTest1_underscore.ts, 423, 89), Decl(underscoreTest1_underscore.ts, 424, 91), Decl(underscoreTest1_underscore.ts, 425, 99))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 426, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 426, 20))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
>iterator : Reducer<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 426, 40))
>Reducer : Reducer<T, U>, Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 426, 16))
>initialValue : U, Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 426, 65))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 426, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 426, 82))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 426, 16))

        find<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
>find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }, Symbol(find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 428, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 428, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 428, 13))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 428, 26))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 428, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 428, 58))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 428, 13))

        find<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
>find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }, Symbol(find, Decl(underscoreTest1_underscore.ts, 426, 101), Decl(underscoreTest1_underscore.ts, 428, 77))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 429, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 429, 36))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 429, 68))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))

        detect<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
>detect : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }, Symbol(detect, Decl(underscoreTest1_underscore.ts, 429, 87), Decl(underscoreTest1_underscore.ts, 430, 79))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 430, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 430, 28))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 430, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 15))

        detect<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
>detect : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }, Symbol(detect, Decl(underscoreTest1_underscore.ts, 429, 87), Decl(underscoreTest1_underscore.ts, 430, 79))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 431, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 431, 38))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 431, 70))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))

        filter<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
>filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 433, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 433, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 433, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 433, 28))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 433, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 433, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 433, 15))

        filter<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
>filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(filter, Decl(underscoreTest1_underscore.ts, 431, 89), Decl(underscoreTest1_underscore.ts, 433, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 434, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 434, 38))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 434, 70))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))

        select<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
>select : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(select, Decl(underscoreTest1_underscore.ts, 434, 91), Decl(underscoreTest1_underscore.ts, 435, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 435, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 435, 28))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 435, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))

        select<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
>select : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(select, Decl(underscoreTest1_underscore.ts, 434, 91), Decl(underscoreTest1_underscore.ts, 435, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 436, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 436, 38))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 436, 70))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))

        where<T>(list: T[], properties: Object): T[];
>where : { <T>(list: T[], properties: Object): T[]; <T>(list: Dictionary<T>, properties: Object): T[]; }, Symbol(where, Decl(underscoreTest1_underscore.ts, 436, 91), Decl(underscoreTest1_underscore.ts, 438, 53))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 438, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 438, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 438, 14))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 438, 27))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 438, 14))

        where<T>(list: Dictionary<T>, properties: Object): T[];
>where : { <T>(list: T[], properties: Object): T[]; <T>(list: Dictionary<T>, properties: Object): T[]; }, Symbol(where, Decl(underscoreTest1_underscore.ts, 436, 91), Decl(underscoreTest1_underscore.ts, 438, 53))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 439, 17))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 439, 37))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))

        findWhere<T>(list: T[], properties: Object): T;
>findWhere : { <T>(list: T[], properties: Object): T; <T>(list: Dictionary<T>, properties: Object): T; }, Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 439, 63), Decl(underscoreTest1_underscore.ts, 441, 55))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 441, 18))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 441, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 441, 18))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 441, 31))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 441, 18))

        findWhere<T>(list: Dictionary<T>, properties: Object): T;
>findWhere : { <T>(list: T[], properties: Object): T; <T>(list: Dictionary<T>, properties: Object): T; }, Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 439, 63), Decl(underscoreTest1_underscore.ts, 441, 55))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 442, 21))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18))
>properties : Object, Symbol(properties, Decl(underscoreTest1_underscore.ts, 442, 41))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18))

        reject<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
>reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 444, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 444, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 444, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 444, 28))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 444, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 444, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 444, 15))

        reject<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
>reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }, Symbol(reject, Decl(underscoreTest1_underscore.ts, 442, 65), Decl(underscoreTest1_underscore.ts, 444, 81))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 445, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 445, 38))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 445, 70))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))

        every<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
>every : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(every, Decl(underscoreTest1_underscore.ts, 445, 91), Decl(underscoreTest1_underscore.ts, 447, 85))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 447, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 447, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 447, 14))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 447, 27))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 447, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 447, 60))

        every<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
>every : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(every, Decl(underscoreTest1_underscore.ts, 445, 91), Decl(underscoreTest1_underscore.ts, 447, 85))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 448, 17))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 448, 37))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 448, 70))

        all<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
>all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(all, Decl(underscoreTest1_underscore.ts, 448, 95), Decl(underscoreTest1_underscore.ts, 449, 83))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 12))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 449, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 12))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 449, 25))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 449, 58))

        all<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
>all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(all, Decl(underscoreTest1_underscore.ts, 448, 95), Decl(underscoreTest1_underscore.ts, 449, 83))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 450, 15))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 450, 35))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 450, 68))

        some<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
>some : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(some, Decl(underscoreTest1_underscore.ts, 450, 93), Decl(underscoreTest1_underscore.ts, 452, 84))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 452, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 452, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 452, 13))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 452, 26))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 452, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 452, 59))

        some<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
>some : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(some, Decl(underscoreTest1_underscore.ts, 450, 93), Decl(underscoreTest1_underscore.ts, 452, 84))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 453, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 453, 36))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 453, 69))

        any<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
>any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(any, Decl(underscoreTest1_underscore.ts, 453, 94), Decl(underscoreTest1_underscore.ts, 454, 83))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 12))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 454, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 12))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 454, 25))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 454, 58))

        any<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
>any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }, Symbol(any, Decl(underscoreTest1_underscore.ts, 453, 94), Decl(underscoreTest1_underscore.ts, 454, 83))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 455, 15))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12))
>iterator : Iterator<T, boolean>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 455, 35))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 455, 68))

        contains<T>(list: T[], value: T): boolean;
>contains : { <T>(list: T[], value: T): boolean; <T>(list: Dictionary<T>, value: T): boolean; }, Symbol(contains, Decl(underscoreTest1_underscore.ts, 455, 93), Decl(underscoreTest1_underscore.ts, 457, 50))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 457, 17))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 457, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 457, 17))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 457, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 457, 17))

        contains<T>(list: Dictionary<T>, value: T): boolean;
>contains : { <T>(list: T[], value: T): boolean; <T>(list: Dictionary<T>, value: T): boolean; }, Symbol(contains, Decl(underscoreTest1_underscore.ts, 455, 93), Decl(underscoreTest1_underscore.ts, 457, 50))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 458, 20))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 458, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17))

        include<T>(list: T[], value: T): boolean;
>include : { <T>(list: T[], value: T): boolean; <T>(list: Dictionary<T>, value: T): boolean; }, Symbol(include, Decl(underscoreTest1_underscore.ts, 458, 60), Decl(underscoreTest1_underscore.ts, 459, 49))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 459, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 459, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 459, 16))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 459, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 459, 16))

        include<T>(list: Dictionary<T>, value: T): boolean;
>include : { <T>(list: T[], value: T): boolean; <T>(list: Dictionary<T>, value: T): boolean; }, Symbol(include, Decl(underscoreTest1_underscore.ts, 458, 60), Decl(underscoreTest1_underscore.ts, 459, 49))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 460, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 460, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 460, 16))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 460, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 460, 16))

        invoke(list: any[], methodName: string, ...args: any[]): any[];
>invoke : { (list: any[], methodName: string, ...args: any[]): any[]; (list: Dictionary<any>, methodName: string, ...args: any[]): any[]; }, Symbol(invoke, Decl(underscoreTest1_underscore.ts, 460, 59), Decl(underscoreTest1_underscore.ts, 462, 71))
>list : any[], Symbol(list, Decl(underscoreTest1_underscore.ts, 462, 15))
>methodName : string, Symbol(methodName, Decl(underscoreTest1_underscore.ts, 462, 27))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 462, 47))

        invoke(list: Dictionary<any>, methodName: string, ...args: any[]): any[];
>invoke : { (list: any[], methodName: string, ...args: any[]): any[]; (list: Dictionary<any>, methodName: string, ...args: any[]): any[]; }, Symbol(invoke, Decl(underscoreTest1_underscore.ts, 460, 59), Decl(underscoreTest1_underscore.ts, 462, 71))
>list : Dictionary<any>, Symbol(list, Decl(underscoreTest1_underscore.ts, 463, 15))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>methodName : string, Symbol(methodName, Decl(underscoreTest1_underscore.ts, 463, 37))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 463, 57))

        pluck(list: any[], propertyName: string): any[];
>pluck : { (list: any[], propertyName: string): any[]; (list: Dictionary<any>, propertyName: string): any[]; }, Symbol(pluck, Decl(underscoreTest1_underscore.ts, 463, 81), Decl(underscoreTest1_underscore.ts, 465, 56))
>list : any[], Symbol(list, Decl(underscoreTest1_underscore.ts, 465, 14))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 465, 26))

        pluck(list: Dictionary<any>, propertyName: string): any[];
>pluck : { (list: any[], propertyName: string): any[]; (list: Dictionary<any>, propertyName: string): any[]; }, Symbol(pluck, Decl(underscoreTest1_underscore.ts, 463, 81), Decl(underscoreTest1_underscore.ts, 465, 56))
>list : Dictionary<any>, Symbol(list, Decl(underscoreTest1_underscore.ts, 466, 14))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 466, 36))

        max<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
>max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(max, Decl(underscoreTest1_underscore.ts, 466, 66), Decl(underscoreTest1_underscore.ts, 468, 73))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 468, 12))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 468, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 468, 12))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 468, 25))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 468, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 468, 54))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 468, 12))

        max<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
>max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(max, Decl(underscoreTest1_underscore.ts, 466, 66), Decl(underscoreTest1_underscore.ts, 468, 73))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 469, 15))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 469, 35))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 469, 64))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))

        min<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
>min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(min, Decl(underscoreTest1_underscore.ts, 469, 83), Decl(underscoreTest1_underscore.ts, 471, 73))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 471, 12))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 471, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 471, 12))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 471, 25))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 471, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 471, 54))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 471, 12))

        min<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
>min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }, Symbol(min, Decl(underscoreTest1_underscore.ts, 469, 83), Decl(underscoreTest1_underscore.ts, 471, 73))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 472, 15))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 472, 35))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 472, 64))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))

        sortBy<T>(list: T[], iterator: Iterator<T, any>, context?: any): T[];
>sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 474, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 474, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 474, 15))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 474, 28))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 474, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 474, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 474, 15))

        sortBy<T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[];
>sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 475, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 475, 38))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 475, 66))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))

        sortBy<T>(list: T[], propertyName: string): T[];
>sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 476, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 476, 28))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))

        sortBy<T>(list: Dictionary<T>, propertyName: string): T[];
>sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }, Symbol(sortBy, Decl(underscoreTest1_underscore.ts, 472, 83), Decl(underscoreTest1_underscore.ts, 474, 77), Decl(underscoreTest1_underscore.ts, 475, 87), Decl(underscoreTest1_underscore.ts, 476, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 477, 18))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 477, 38))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15))

        groupBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
>groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 479, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 479, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 479, 16))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 479, 29))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 479, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 479, 58))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 479, 16))

        groupBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
>groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 480, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 480, 39))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 480, 68))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))

        groupBy<T>(list: T[], propertyName: string): Dictionary<T[]>;
>groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 481, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 481, 29))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))

        groupBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>;
>groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }, Symbol(groupBy, Decl(underscoreTest1_underscore.ts, 477, 66), Decl(underscoreTest1_underscore.ts, 479, 91), Decl(underscoreTest1_underscore.ts, 480, 101), Decl(underscoreTest1_underscore.ts, 481, 69))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 482, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 482, 39))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16))

        countBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
>countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 484, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 484, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 484, 16))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 484, 29))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 484, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 484, 58))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        countBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
>countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 485, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 485, 39))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 485, 68))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        countBy<T>(list: T[], propertyName: string): Dictionary<number>;
>countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 486, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 486, 29))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        countBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<number>;
>countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }, Symbol(countBy, Decl(underscoreTest1_underscore.ts, 482, 79), Decl(underscoreTest1_underscore.ts, 484, 94), Decl(underscoreTest1_underscore.ts, 485, 104), Decl(underscoreTest1_underscore.ts, 486, 72))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 487, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 487, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 487, 16))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 487, 39))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))

        shuffle<T>(list: T[]): T[];
>shuffle : { <T>(list: T[]): T[]; <T>(list: Dictionary<T>): T[]; }, Symbol(shuffle, Decl(underscoreTest1_underscore.ts, 487, 82), Decl(underscoreTest1_underscore.ts, 489, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 489, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 489, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 489, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 489, 16))

        shuffle<T>(list: Dictionary<T>): T[];
>shuffle : { <T>(list: T[]): T[]; <T>(list: Dictionary<T>): T[]; }, Symbol(shuffle, Decl(underscoreTest1_underscore.ts, 487, 82), Decl(underscoreTest1_underscore.ts, 489, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 490, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 490, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 490, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 490, 16))

        toArray<T>(list: T[]): T[];
>toArray : { <T>(list: T[]): T[]; <T>(list: Dictionary<T>): T[]; }, Symbol(toArray, Decl(underscoreTest1_underscore.ts, 490, 45), Decl(underscoreTest1_underscore.ts, 492, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 492, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 492, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 492, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 492, 16))

        toArray<T>(list: Dictionary<T>): T[];
>toArray : { <T>(list: T[]): T[]; <T>(list: Dictionary<T>): T[]; }, Symbol(toArray, Decl(underscoreTest1_underscore.ts, 490, 45), Decl(underscoreTest1_underscore.ts, 492, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 493, 16))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 493, 19))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 493, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 493, 16))

        size<T>(list: T[]): number;
>size : { <T>(list: T[]): number; <T>(list: Dictionary<T>): number; }, Symbol(size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 495, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 495, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 495, 13))

        size<T>(list: Dictionary<T>): number;
>size : { <T>(list: T[]): number; <T>(list: Dictionary<T>): number; }, Symbol(size, Decl(underscoreTest1_underscore.ts, 493, 45), Decl(underscoreTest1_underscore.ts, 495, 35))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 496, 13))
>list : Dictionary<T>, Symbol(list, Decl(underscoreTest1_underscore.ts, 496, 16))
>Dictionary : Dictionary<T>, Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 496, 13))

        first<T>(list: T[]): T;
>first : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(first, Decl(underscoreTest1_underscore.ts, 496, 45), Decl(underscoreTest1_underscore.ts, 498, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 498, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 498, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 498, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 498, 14))

        first<T>(list: T[], count: number): T[];
>first : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(first, Decl(underscoreTest1_underscore.ts, 496, 45), Decl(underscoreTest1_underscore.ts, 498, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 499, 14))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 499, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 499, 14))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 499, 27))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 499, 14))

        head<T>(list: T[]): T;
>head : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(head, Decl(underscoreTest1_underscore.ts, 499, 48), Decl(underscoreTest1_underscore.ts, 500, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 500, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 500, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 500, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 500, 13))

        head<T>(list: T[], count: number): T[];
>head : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(head, Decl(underscoreTest1_underscore.ts, 499, 48), Decl(underscoreTest1_underscore.ts, 500, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 501, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 501, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 501, 13))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 501, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 501, 13))

        take<T>(list: T[]): T;
>take : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(take, Decl(underscoreTest1_underscore.ts, 501, 47), Decl(underscoreTest1_underscore.ts, 502, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 502, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 502, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 502, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 502, 13))

        take<T>(list: T[], count: number): T[];
>take : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(take, Decl(underscoreTest1_underscore.ts, 501, 47), Decl(underscoreTest1_underscore.ts, 502, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 503, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 503, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 503, 13))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 503, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 503, 13))

        initial<T>(list: T[]): T;
>initial : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(initial, Decl(underscoreTest1_underscore.ts, 503, 47), Decl(underscoreTest1_underscore.ts, 505, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 505, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 505, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 505, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 505, 16))

        initial<T>(list: T[], count: number): T[];
>initial : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(initial, Decl(underscoreTest1_underscore.ts, 503, 47), Decl(underscoreTest1_underscore.ts, 505, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 506, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 506, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 506, 16))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 506, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 506, 16))

        last<T>(list: T[]): T;
>last : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(last, Decl(underscoreTest1_underscore.ts, 506, 50), Decl(underscoreTest1_underscore.ts, 508, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 508, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 508, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 508, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 508, 13))

        last<T>(list: T[], count: number): T[];
>last : { <T>(list: T[]): T; <T>(list: T[], count: number): T[]; }, Symbol(last, Decl(underscoreTest1_underscore.ts, 506, 50), Decl(underscoreTest1_underscore.ts, 508, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 509, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 509, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 509, 13))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 509, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 509, 13))

        rest<T>(list: T[], index?: number): T[];
>rest : <T>(list: T[], index?: number) => T[], Symbol(rest, Decl(underscoreTest1_underscore.ts, 509, 47))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 511, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 511, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 511, 13))
>index : number, Symbol(index, Decl(underscoreTest1_underscore.ts, 511, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 511, 13))

        compact<T>(list: T[]): T[];
>compact : <T>(list: T[]) => T[], Symbol(compact, Decl(underscoreTest1_underscore.ts, 511, 48))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 513, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 513, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 513, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 513, 16))

        flatten<T>(list: T[][]): T[];
>flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 515, 16))
>list : T[][], Symbol(list, Decl(underscoreTest1_underscore.ts, 515, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 515, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 515, 16))

        flatten<T>(array: any[], shallow?: boolean): T[];
>flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }, Symbol(flatten, Decl(underscoreTest1_underscore.ts, 513, 35), Decl(underscoreTest1_underscore.ts, 515, 37))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 516, 16))
>array : any[], Symbol(array, Decl(underscoreTest1_underscore.ts, 516, 19))
>shallow : boolean, Symbol(shallow, Decl(underscoreTest1_underscore.ts, 516, 32))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 516, 16))

        without<T>(list: T[], ...values: T[]): T[];
>without : <T>(list: T[], ...values: T[]) => T[], Symbol(without, Decl(underscoreTest1_underscore.ts, 516, 57))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 518, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 518, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 518, 16))
>values : T[], Symbol(values, Decl(underscoreTest1_underscore.ts, 518, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 518, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 518, 16))

        union<T>(...arrays: T[][]): T[];
>union : <T>(...arrays: T[][]) => T[], Symbol(union, Decl(underscoreTest1_underscore.ts, 518, 51))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 520, 14))
>arrays : T[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 520, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 520, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 520, 14))

        intersection<T>(...arrays: T[][]): T[];
>intersection : <T>(...arrays: T[][]) => T[], Symbol(intersection, Decl(underscoreTest1_underscore.ts, 520, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 522, 21))
>arrays : T[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 522, 24))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 522, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 522, 21))

        difference<T>(list: T[], ...others: T[][]): T[];
>difference : <T>(list: T[], ...others: T[][]) => T[], Symbol(difference, Decl(underscoreTest1_underscore.ts, 522, 47))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 524, 19))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 524, 22))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 524, 19))
>others : T[][], Symbol(others, Decl(underscoreTest1_underscore.ts, 524, 32))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 524, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 524, 19))

        uniq<T>(list: T[], isSorted?: boolean): T[];
>uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(uniq, Decl(underscoreTest1_underscore.ts, 524, 56), Decl(underscoreTest1_underscore.ts, 526, 52))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 526, 13))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 526, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 526, 13))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 526, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 526, 13))

        uniq<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
>uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(uniq, Decl(underscoreTest1_underscore.ts, 524, 56), Decl(underscoreTest1_underscore.ts, 526, 52))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 527, 13))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 527, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 527, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 527, 13))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 527, 29))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 527, 48))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 527, 13))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 527, 15))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 527, 74))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 527, 15))

        unique<T>(list: T[], isSorted?: boolean): T[];
>unique : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(unique, Decl(underscoreTest1_underscore.ts, 527, 95), Decl(underscoreTest1_underscore.ts, 528, 54))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 15))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 528, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 15))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 528, 28))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 15))

        unique<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
>unique : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }, Symbol(unique, Decl(underscoreTest1_underscore.ts, 527, 95), Decl(underscoreTest1_underscore.ts, 528, 54))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 529, 17))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 529, 21))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 529, 31))
>iterator : Iterator<T, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 529, 50))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 529, 17))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 529, 76))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 529, 17))

        zip<T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[];
>zip : { <T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[]; <T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[]; <T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[]; (...arrays: any[][]): any[][]; }, Symbol(zip, Decl(underscoreTest1_underscore.ts, 529, 97), Decl(underscoreTest1_underscore.ts, 531, 58), Decl(underscoreTest1_underscore.ts, 532, 76), Decl(underscoreTest1_underscore.ts, 533, 94))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 531, 12))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 531, 15))
>a0 : T0[], Symbol(a0, Decl(underscoreTest1_underscore.ts, 531, 20))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 531, 12))
>a1 : T1[], Symbol(a1, Decl(underscoreTest1_underscore.ts, 531, 29))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 531, 15))
>Tuple2 : Tuple2<T0, T1>, Symbol(Tuple2, Decl(underscoreTest1_underscore.ts, 10, 1))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 531, 12))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 531, 15))

        zip<T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[];
>zip : { <T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[]; <T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[]; <T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[]; (...arrays: any[][]): any[][]; }, Symbol(zip, Decl(underscoreTest1_underscore.ts, 529, 97), Decl(underscoreTest1_underscore.ts, 531, 58), Decl(underscoreTest1_underscore.ts, 532, 76), Decl(underscoreTest1_underscore.ts, 533, 94))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 532, 12))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 532, 19))
>a0 : T0[], Symbol(a0, Decl(underscoreTest1_underscore.ts, 532, 24))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 532, 12))
>a1 : T1[], Symbol(a1, Decl(underscoreTest1_underscore.ts, 532, 33))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15))
>a2 : T2[], Symbol(a2, Decl(underscoreTest1_underscore.ts, 532, 43))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 532, 19))
>Tuple3 : Tuple3<T0, T1, T2>, Symbol(Tuple3, Decl(underscoreTest1_underscore.ts, 15, 1))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 532, 12))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 532, 19))

        zip<T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[];
>zip : { <T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[]; <T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[]; <T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[]; (...arrays: any[][]): any[][]; }, Symbol(zip, Decl(underscoreTest1_underscore.ts, 529, 97), Decl(underscoreTest1_underscore.ts, 531, 58), Decl(underscoreTest1_underscore.ts, 532, 76), Decl(underscoreTest1_underscore.ts, 533, 94))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 533, 12))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 533, 15))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19))
>T3 : T3, Symbol(T3, Decl(underscoreTest1_underscore.ts, 533, 23))
>a0 : T0[], Symbol(a0, Decl(underscoreTest1_underscore.ts, 533, 28))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 533, 12))
>a1 : T1[], Symbol(a1, Decl(underscoreTest1_underscore.ts, 533, 37))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 533, 15))
>a2 : T2[], Symbol(a2, Decl(underscoreTest1_underscore.ts, 533, 47))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19))
>a3 : T3[], Symbol(a3, Decl(underscoreTest1_underscore.ts, 533, 57))
>T3 : T3, Symbol(T3, Decl(underscoreTest1_underscore.ts, 533, 23))
>Tuple4 : Tuple4<T0, T1, T2, T3>, Symbol(Tuple4, Decl(underscoreTest1_underscore.ts, 21, 1))
>T0 : T0, Symbol(T0, Decl(underscoreTest1_underscore.ts, 533, 12))
>T1 : T1, Symbol(T1, Decl(underscoreTest1_underscore.ts, 533, 15))
>T2 : T2, Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19))
>T3 : T3, Symbol(T3, Decl(underscoreTest1_underscore.ts, 533, 23))

        zip(...arrays: any[][]): any[][];
>zip : { <T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[]; <T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[]; <T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[]; (...arrays: any[][]): any[][]; }, Symbol(zip, Decl(underscoreTest1_underscore.ts, 529, 97), Decl(underscoreTest1_underscore.ts, 531, 58), Decl(underscoreTest1_underscore.ts, 532, 76), Decl(underscoreTest1_underscore.ts, 533, 94))
>arrays : any[][], Symbol(arrays, Decl(underscoreTest1_underscore.ts, 534, 12))

        object(list: any[][]): any;
>object : { (list: any[][]): any; (keys: string[], values: any[]): any; }, Symbol(object, Decl(underscoreTest1_underscore.ts, 534, 41), Decl(underscoreTest1_underscore.ts, 536, 35))
>list : any[][], Symbol(list, Decl(underscoreTest1_underscore.ts, 536, 15))

        object(keys: string[], values: any[]): any;
>object : { (list: any[][]): any; (keys: string[], values: any[]): any; }, Symbol(object, Decl(underscoreTest1_underscore.ts, 534, 41), Decl(underscoreTest1_underscore.ts, 536, 35))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 537, 15))
>values : any[], Symbol(values, Decl(underscoreTest1_underscore.ts, 537, 30))

        indexOf<T>(list: T[], value: T, isSorted?: boolean): number;
>indexOf : <T>(list: T[], value: T, isSorted?: boolean) => number, Symbol(indexOf, Decl(underscoreTest1_underscore.ts, 537, 51))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 539, 16))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 539, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 539, 16))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 539, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 539, 16))
>isSorted : boolean, Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 539, 39))

        lastIndexOf<T>(list: T[], value: T, fromIndex?: number): number;
>lastIndexOf : <T>(list: T[], value: T, fromIndex?: number) => number, Symbol(lastIndexOf, Decl(underscoreTest1_underscore.ts, 539, 68))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 541, 20))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 541, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 541, 20))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 541, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 541, 20))
>fromIndex : number, Symbol(fromIndex, Decl(underscoreTest1_underscore.ts, 541, 43))

        sortedIndex<T>(list: T[], obj: T, propertyName: string): number;
>sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }, Symbol(sortedIndex, Decl(underscoreTest1_underscore.ts, 541, 72), Decl(underscoreTest1_underscore.ts, 543, 72))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 543, 20))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 543, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 543, 20))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 543, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 543, 20))
>propertyName : string, Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 543, 41))

        sortedIndex<T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number;
>sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }, Symbol(sortedIndex, Decl(underscoreTest1_underscore.ts, 541, 72), Decl(underscoreTest1_underscore.ts, 543, 72))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 544, 20))
>list : T[], Symbol(list, Decl(underscoreTest1_underscore.ts, 544, 23))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 544, 20))
>obj : T, Symbol(obj, Decl(underscoreTest1_underscore.ts, 544, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 544, 20))
>iterator : Iterator<T, any>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 544, 41))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 544, 20))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 544, 70))

        range(stop: number): number[];
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>stop : number, Symbol(stop, Decl(underscoreTest1_underscore.ts, 546, 14))

        range(start: number, stop: number, step?: number): number[];
>range : { (stop: number): number[]; (start: number, stop: number, step?: number): number[]; }, Symbol(range, Decl(underscoreTest1_underscore.ts, 544, 94), Decl(underscoreTest1_underscore.ts, 546, 38))
>start : number, Symbol(start, Decl(underscoreTest1_underscore.ts, 547, 14))
>stop : number, Symbol(stop, Decl(underscoreTest1_underscore.ts, 547, 28))
>step : number, Symbol(step, Decl(underscoreTest1_underscore.ts, 547, 42))

        bind<T extends Function>(func: T, object: any): T;
>bind : { <T extends Function>(func: T, object: any): T; (func: Function, object: any, ...args: any[]): Function; }, Symbol(bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 549, 13))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 549, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 549, 13))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 549, 41))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 549, 13))

        bind(func: Function, object: any, ...args: any[]): Function;
>bind : { <T extends Function>(func: T, object: any): T; (func: Function, object: any, ...args: any[]): Function; }, Symbol(bind, Decl(underscoreTest1_underscore.ts, 547, 68), Decl(underscoreTest1_underscore.ts, 549, 58))
>func : Function, Symbol(func, Decl(underscoreTest1_underscore.ts, 550, 13))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 550, 28))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 550, 41))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))

        bindAll<T>(object: T, ...methodNames: string[]): T;
>bindAll : <T>(object: T, ...methodNames: string[]) => T, Symbol(bindAll, Decl(underscoreTest1_underscore.ts, 550, 68))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 552, 16))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 552, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 552, 16))
>methodNames : string[], Symbol(methodNames, Decl(underscoreTest1_underscore.ts, 552, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 552, 16))

        partial(func: Function, ...args: any[]): Function;
>partial : (func: Function, ...args: any[]) => Function, Symbol(partial, Decl(underscoreTest1_underscore.ts, 552, 59))
>func : Function, Symbol(func, Decl(underscoreTest1_underscore.ts, 554, 16))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 554, 31))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))

        memoize<T extends Function>(func: T, hashFunction?: Function): T;
>memoize : <T extends Function>(func: T, hashFunction?: Function) => T, Symbol(memoize, Decl(underscoreTest1_underscore.ts, 554, 58))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 556, 16))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 556, 36))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 556, 16))
>hashFunction : Function, Symbol(hashFunction, Decl(underscoreTest1_underscore.ts, 556, 44))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 556, 16))

        delay(func: Function, wait: number, ...args: any[]): number;
>delay : (func: Function, wait: number, ...args: any[]) => number, Symbol(delay, Decl(underscoreTest1_underscore.ts, 556, 73))
>func : Function, Symbol(func, Decl(underscoreTest1_underscore.ts, 558, 14))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>wait : number, Symbol(wait, Decl(underscoreTest1_underscore.ts, 558, 29))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 558, 43))

        defer(func: Function, ...args: any[]): number;
>defer : (func: Function, ...args: any[]) => number, Symbol(defer, Decl(underscoreTest1_underscore.ts, 558, 68))
>func : Function, Symbol(func, Decl(underscoreTest1_underscore.ts, 560, 14))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 560, 29))

        throttle<T extends Function>(func: T, wait: number): T;
>throttle : <T extends Function>(func: T, wait: number) => T, Symbol(throttle, Decl(underscoreTest1_underscore.ts, 560, 54))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 562, 17))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 562, 37))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 562, 17))
>wait : number, Symbol(wait, Decl(underscoreTest1_underscore.ts, 562, 45))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 562, 17))

        debounce<T extends Function>(func: T, wait: number, immediate?: boolean): T;
>debounce : <T extends Function>(func: T, wait: number, immediate?: boolean) => T, Symbol(debounce, Decl(underscoreTest1_underscore.ts, 562, 63))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 564, 17))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 564, 37))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 564, 17))
>wait : number, Symbol(wait, Decl(underscoreTest1_underscore.ts, 564, 45))
>immediate : boolean, Symbol(immediate, Decl(underscoreTest1_underscore.ts, 564, 59))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 564, 17))

        once<T extends Function>(func: T): T;
>once : <T extends Function>(func: T) => T, Symbol(once, Decl(underscoreTest1_underscore.ts, 564, 84))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 566, 13))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 566, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 566, 13))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 566, 13))

        after<T extends Function>(count: number, func: T): T;
>after : <T extends Function>(count: number, func: T) => T, Symbol(after, Decl(underscoreTest1_underscore.ts, 566, 45))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 568, 14))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>count : number, Symbol(count, Decl(underscoreTest1_underscore.ts, 568, 34))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 568, 48))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 568, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 568, 14))

        wrap<T extends Function>(func: T, wrapper: (func: T, ...args: any[]) => any): T;
>wrap : <T extends Function>(func: T, wrapper: (func: T, ...args: any[]) => any) => T, Symbol(wrap, Decl(underscoreTest1_underscore.ts, 568, 61))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 570, 13))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 570, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 570, 13))
>wrapper : (func: T, ...args: any[]) => any, Symbol(wrapper, Decl(underscoreTest1_underscore.ts, 570, 41))
>func : T, Symbol(func, Decl(underscoreTest1_underscore.ts, 570, 52))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 570, 13))
>args : any[], Symbol(args, Decl(underscoreTest1_underscore.ts, 570, 60))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 570, 13))

        compose(...funcs: Function[]): Function;
>compose : (...funcs: Function[]) => Function, Symbol(compose, Decl(underscoreTest1_underscore.ts, 570, 88))
>funcs : Function[], Symbol(funcs, Decl(underscoreTest1_underscore.ts, 572, 16))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
>Function : Function, Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))

        keys(object: any): string[];
>keys : (object: any) => string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 572, 48))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 574, 13))

        values(object: any): any[];
>values : (object: any) => any[], Symbol(values, Decl(underscoreTest1_underscore.ts, 574, 36))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 576, 15))

        pairs(object: any): any[][];
>pairs : (object: any) => any[][], Symbol(pairs, Decl(underscoreTest1_underscore.ts, 576, 35))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 578, 14))

        invert(object: any): any;
>invert : (object: any) => any, Symbol(invert, Decl(underscoreTest1_underscore.ts, 578, 36))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 580, 15))

        functions(object: any): string[];
>functions : (object: any) => string[], Symbol(functions, Decl(underscoreTest1_underscore.ts, 580, 33))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 582, 18))

        methods(object: any): string[];
>methods : (object: any) => string[], Symbol(methods, Decl(underscoreTest1_underscore.ts, 582, 41))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 583, 16))

        extend<T>(destination: T, ...sources: any[]): T;
>extend : <T>(destination: T, ...sources: any[]) => T, Symbol(extend, Decl(underscoreTest1_underscore.ts, 583, 39))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 585, 15))
>destination : T, Symbol(destination, Decl(underscoreTest1_underscore.ts, 585, 18))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 585, 15))
>sources : any[], Symbol(sources, Decl(underscoreTest1_underscore.ts, 585, 33))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 585, 15))

        pick<T>(object: T, ...keys: string[]): T;
>pick : <T>(object: T, ...keys: string[]) => T, Symbol(pick, Decl(underscoreTest1_underscore.ts, 585, 56))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 587, 13))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 587, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 587, 13))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 587, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 587, 13))

        omit<T>(object: T, ...keys: string[]): T;
>omit : <T>(object: T, ...keys: string[]) => T, Symbol(omit, Decl(underscoreTest1_underscore.ts, 587, 49))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 589, 13))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 589, 16))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 589, 13))
>keys : string[], Symbol(keys, Decl(underscoreTest1_underscore.ts, 589, 26))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 589, 13))

        defaults<T>(object: T, ...defaults: any[]): T;
>defaults : <T>(object: T, ...defaults: any[]) => T, Symbol(defaults, Decl(underscoreTest1_underscore.ts, 589, 49))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 591, 17))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 591, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 591, 17))
>defaults : any[], Symbol(defaults, Decl(underscoreTest1_underscore.ts, 591, 30))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 591, 17))

        clone<T>(object: T): T;
>clone : <T>(object: T) => T, Symbol(clone, Decl(underscoreTest1_underscore.ts, 591, 54))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 593, 14))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 593, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 593, 14))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 593, 14))

        tap<T>(object: T, interceptor: (object: T) => void): T;
>tap : <T>(object: T, interceptor: (object: T) => void) => T, Symbol(tap, Decl(underscoreTest1_underscore.ts, 593, 31))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 595, 12))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 595, 15))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 595, 12))
>interceptor : (object: T) => void, Symbol(interceptor, Decl(underscoreTest1_underscore.ts, 595, 25))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 595, 40))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 595, 12))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 595, 12))

        has(object: any, key: string): boolean;
>has : (object: any, key: string) => boolean, Symbol(has, Decl(underscoreTest1_underscore.ts, 595, 63))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 597, 12))
>key : string, Symbol(key, Decl(underscoreTest1_underscore.ts, 597, 24))

        isEqual<T>(object: T, other: T): boolean;
>isEqual : <T>(object: T, other: T) => boolean, Symbol(isEqual, Decl(underscoreTest1_underscore.ts, 597, 47))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 599, 16))
>object : T, Symbol(object, Decl(underscoreTest1_underscore.ts, 599, 19))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 599, 16))
>other : T, Symbol(other, Decl(underscoreTest1_underscore.ts, 599, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 599, 16))

        isEmpty(object: any): boolean;
>isEmpty : (object: any) => boolean, Symbol(isEmpty, Decl(underscoreTest1_underscore.ts, 599, 49))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 601, 16))

        isElement(object: any): boolean;
>isElement : (object: any) => boolean, Symbol(isElement, Decl(underscoreTest1_underscore.ts, 601, 38))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 602, 18))

        isArray(object: any): boolean;
>isArray : (object: any) => boolean, Symbol(isArray, Decl(underscoreTest1_underscore.ts, 602, 40))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 603, 16))

        isObject(value: any): boolean;
>isObject : (value: any) => boolean, Symbol(isObject, Decl(underscoreTest1_underscore.ts, 603, 38))
>value : any, Symbol(value, Decl(underscoreTest1_underscore.ts, 604, 17))

        isArguments(object: any): boolean;
>isArguments : (object: any) => boolean, Symbol(isArguments, Decl(underscoreTest1_underscore.ts, 604, 38))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 605, 20))

        isFunction(object: any): boolean;
>isFunction : (object: any) => boolean, Symbol(isFunction, Decl(underscoreTest1_underscore.ts, 605, 42))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 606, 19))

        isString(object: any): boolean;
>isString : (object: any) => boolean, Symbol(isString, Decl(underscoreTest1_underscore.ts, 606, 41))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 607, 17))

        isNumber(object: any): boolean;
>isNumber : (object: any) => boolean, Symbol(isNumber, Decl(underscoreTest1_underscore.ts, 607, 39))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 608, 17))

        isFinite(object: any): boolean;
>isFinite : (object: any) => boolean, Symbol(isFinite, Decl(underscoreTest1_underscore.ts, 608, 39))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 609, 17))

        isBoolean(object: any): boolean;
>isBoolean : (object: any) => boolean, Symbol(isBoolean, Decl(underscoreTest1_underscore.ts, 609, 39))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 610, 18))

        isDate(object: any): boolean;
>isDate : (object: any) => boolean, Symbol(isDate, Decl(underscoreTest1_underscore.ts, 610, 40))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 611, 15))

        isRegExp(object: any): boolean;
>isRegExp : (object: any) => boolean, Symbol(isRegExp, Decl(underscoreTest1_underscore.ts, 611, 37))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 612, 17))

        isNaN(object: any): boolean;
>isNaN : (object: any) => boolean, Symbol(isNaN, Decl(underscoreTest1_underscore.ts, 612, 39))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 613, 14))

        isNull(object: any): boolean;
>isNull : (object: any) => boolean, Symbol(isNull, Decl(underscoreTest1_underscore.ts, 613, 36))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 614, 15))

        isUndefined(value: any): boolean;
>isUndefined : (value: any) => boolean, Symbol(isUndefined, Decl(underscoreTest1_underscore.ts, 614, 37))
>value : any, Symbol(value, Decl(underscoreTest1_underscore.ts, 615, 20))

        noConflict(): Static;
>noConflict : () => Static, Symbol(noConflict, Decl(underscoreTest1_underscore.ts, 615, 41))
>Static : Static, Symbol(Static, Decl(underscoreTest1_underscore.ts, 384, 5))

        identity<T>(value: T): T;
>identity : <T>(value: T) => T, Symbol(identity, Decl(underscoreTest1_underscore.ts, 617, 29))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 619, 17))
>value : T, Symbol(value, Decl(underscoreTest1_underscore.ts, 619, 20))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 619, 17))
>T : T, Symbol(T, Decl(underscoreTest1_underscore.ts, 619, 17))

        times<U>(n: number, iterator: Iterator<number, U>, context?: any): U[];
>times : <U>(n: number, iterator: Iterator<number, U>, context?: any) => U[], Symbol(times, Decl(underscoreTest1_underscore.ts, 619, 33))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 621, 14))
>n : number, Symbol(n, Decl(underscoreTest1_underscore.ts, 621, 17))
>iterator : Iterator<number, U>, Symbol(iterator, Decl(underscoreTest1_underscore.ts, 621, 27))
>Iterator : Iterator<T, U>, Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 621, 14))
>context : any, Symbol(context, Decl(underscoreTest1_underscore.ts, 621, 58))
>U : U, Symbol(U, Decl(underscoreTest1_underscore.ts, 621, 14))

        random(max: number): number;
>random : { (max: number): number; (min: number, max: number): number; }, Symbol(random, Decl(underscoreTest1_underscore.ts, 621, 79), Decl(underscoreTest1_underscore.ts, 623, 36))
>max : number, Symbol(max, Decl(underscoreTest1_underscore.ts, 623, 15))

        random(min: number, max: number): number;
>random : { (max: number): number; (min: number, max: number): number; }, Symbol(random, Decl(underscoreTest1_underscore.ts, 621, 79), Decl(underscoreTest1_underscore.ts, 623, 36))
>min : number, Symbol(min, Decl(underscoreTest1_underscore.ts, 624, 15))
>max : number, Symbol(max, Decl(underscoreTest1_underscore.ts, 624, 27))

        mixin(object: any): void;
>mixin : (object: any) => void, Symbol(mixin, Decl(underscoreTest1_underscore.ts, 624, 49))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 626, 14))

        uniqueId(): number;
>uniqueId : { (): number; (prefix: string): string; }, Symbol(uniqueId, Decl(underscoreTest1_underscore.ts, 626, 33), Decl(underscoreTest1_underscore.ts, 628, 27))

        uniqueId(prefix: string): string;
>uniqueId : { (): number; (prefix: string): string; }, Symbol(uniqueId, Decl(underscoreTest1_underscore.ts, 626, 33), Decl(underscoreTest1_underscore.ts, 628, 27))
>prefix : string, Symbol(prefix, Decl(underscoreTest1_underscore.ts, 629, 17))

        escape(s: string): string;
>escape : (s: string) => string, Symbol(escape, Decl(underscoreTest1_underscore.ts, 629, 41))
>s : string, Symbol(s, Decl(underscoreTest1_underscore.ts, 631, 15))

        unescape(s: string): string;
>unescape : (s: string) => string, Symbol(unescape, Decl(underscoreTest1_underscore.ts, 631, 34))
>s : string, Symbol(s, Decl(underscoreTest1_underscore.ts, 633, 17))

        result(object: any, property: string): any;
>result : (object: any, property: string) => any, Symbol(result, Decl(underscoreTest1_underscore.ts, 633, 36))
>object : any, Symbol(object, Decl(underscoreTest1_underscore.ts, 635, 15))
>property : string, Symbol(property, Decl(underscoreTest1_underscore.ts, 635, 27))

        templateSettings: TemplateSettings;
>templateSettings : TemplateSettings, Symbol(templateSettings, Decl(underscoreTest1_underscore.ts, 635, 51))
>TemplateSettings : TemplateSettings, Symbol(TemplateSettings, Decl(underscoreTest1_underscore.ts, 378, 5))

        template(templateString: string): (data: any) => string;
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: TemplateSettings): string; }, Symbol(template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>templateString : string, Symbol(templateString, Decl(underscoreTest1_underscore.ts, 639, 17))
>data : any, Symbol(data, Decl(underscoreTest1_underscore.ts, 639, 43))

        template(templateString: string, data: any, settings?: TemplateSettings): string;
>template : { (templateString: string): (data: any) => string; (templateString: string, data: any, settings?: TemplateSettings): string; }, Symbol(template, Decl(underscoreTest1_underscore.ts, 637, 43), Decl(underscoreTest1_underscore.ts, 639, 64))
>templateString : string, Symbol(templateString, Decl(underscoreTest1_underscore.ts, 640, 17))
>data : any, Symbol(data, Decl(underscoreTest1_underscore.ts, 640, 40))
>settings : TemplateSettings, Symbol(settings, Decl(underscoreTest1_underscore.ts, 640, 51))
>TemplateSettings : TemplateSettings, Symbol(TemplateSettings, Decl(underscoreTest1_underscore.ts, 378, 5))
    }
}

declare var _: Underscore.Static;
>_ : Underscore.Static, Symbol(_, Decl(underscoreTest1_underscore.ts, 644, 11))
>Underscore : any, Symbol(Underscore, Decl(underscoreTest1_underscore.ts, 28, 1))
>Static : Underscore.Static, Symbol(Underscore.Static, Decl(underscoreTest1_underscore.ts, 384, 5))