diff --git a/lazy.js/lazy.js-tests.ts b/lazy.js/lazy.js-tests.ts
index 7689bcaf78..f719a90a90 100644
--- a/lazy.js/lazy.js-tests.ts
+++ b/lazy.js/lazy.js-tests.ts
@@ -3,10 +3,10 @@
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 interface Foo {
-	foo(): string;
+    foo(): string;
 }
 interface Bar {
-	bar(): string;
+    bar(): string;
 }
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -51,38 +51,38 @@ function fnValueCallback(value: Foo): void {
 }
 
 function fnGetKeyCallback(value: Foo): string {
-	return str;
+    return str;
 }
 
 function fnTestCallback(value: Foo): boolean {
-	return bool;
+    return bool;
 }
 
 function fnMapCallback(value: Foo): Bar {
-	return bar;
+    return bar;
 }
 
 function fnMapStringCallback(value: string): string {
-	return str;
+    return str;
 }
 
 function fnNumberCallback(value: Foo): number {
-	return num;
+    return num;
 }
 
 function fnMemoCallback(memo: Bar, value: Foo): Bar {
-	return bar;
+    return bar;
 }
 
 function fnGeneratorCallback(index: number): Foo {
-	return foo;
+    return foo;
 }
 
 // Lazy
 
 fooArraySeq = Lazy(fooArr);
-fooObjectSeq = Lazy<Foo>({a:foo, b:foo});
-anyObjectSeq = Lazy<any>({a:num, b:str});
+fooObjectSeq = Lazy<Foo>({a: foo, b: foo});
+anyObjectSeq = Lazy<any>({a: num, b: str});
 stringSeq = Lazy(str);
 
 // Strict
diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts
index ca19aed983..0470929d6d 100644
--- a/lazy.js/lazy.js.d.ts
+++ b/lazy.js/lazy.js.d.ts
@@ -5,243 +5,244 @@
 
 declare module LazyJS {
 
-	interface LazyStatic {
+    interface LazyStatic {
 
-		(value: string):StringLikeSequence;
-		<T>(value: T[]):ArrayLikeSequence<T>;
-		(value: any[]):ArrayLikeSequence<any>;
-		<T>(value: Object):ObjectLikeSequence<T>;
-		(value: Object):ObjectLikeSequence<any>;
+        (value: string): StringLikeSequence;
+        <T>(value: T[]): ArrayLikeSequence<T>;
+        (value: any[]): ArrayLikeSequence<any>;
+        <T>(value: Object): ObjectLikeSequence<T>;
+        (value: Object): ObjectLikeSequence<any>;
 
-		strict():LazyStatic;
+        strict(): LazyStatic;
 
-		generate<T>(generatorFn: GeneratorCallback<T>, length?: number):GeneratedSequence<T>;
+        generate<T>(generatorFn: GeneratorCallback<T>, length?: number): GeneratedSequence<T>;
 
-		range(to: number):GeneratedSequence<number>;
-		range(from: number, to: number, step?: number):GeneratedSequence<number>;
+        range(to: number): GeneratedSequence<number>;
+        range(from: number, to: number, step?: number): GeneratedSequence<number>;
 
-		repeat<T>(value: T, count?: number):GeneratedSequence<T>;
+        repeat<T>(value: T, count?: number): GeneratedSequence<T>;
 
-		on<T>(eventType: string):Sequence<T>;
+        on<T>(eventType: string): Sequence<T>;
 
-		readFile(path: string):StringLikeSequence;
-		makeHttpRequest(path: string):StringLikeSequence;
-	}
+        readFile(path: string): StringLikeSequence;
+        makeHttpRequest(path: string): StringLikeSequence;
+    }
 
-	interface ArrayLike<T> {
-		length:number;
-		[index:number]:T;
-	}
+    interface ArrayLike<T> {
+        length: number;
+        [index: number]: T;
+    }
 
-	interface Callback {
-		():void;
-	}
+    interface Callback {
+        (): void;
+    }
 
-	interface ErrorCallback {
-		(error: any):void;
-	}
+    interface ErrorCallback {
+        (error: any): void;
+    }
 
-	interface ValueCallback<T> {
-		(value: T):void;
-	}
+    interface ValueCallback<T> {
+        (value: T): void;
+    }
 
-	interface GetKeyCallback<T> {
-		(value: T):string;
-	}
+    interface GetKeyCallback<T> {
+        (value: T): string;
+    }
 
-	interface TestCallback<T> {
-		(value: T):boolean;
-	}
+    interface TestCallback<T> {
+        (value: T): boolean;
+    }
 
-	interface MapCallback<T, U> {
-		(value: T):U;
-	}
+    interface MapCallback<T, U> {
+        (value: T): U;
+    }
 
-	interface MapStringCallback {
-		(value: string):string;
-	}
+    interface MapStringCallback {
+        (value: string): string;
+    }
 
-	interface NumberCallback<T> {
-		(value: T):number;
-	}
+    interface NumberCallback<T> {
+        (value: T): number;
+    }
 
-	interface MemoCallback<T, U> {
-		(memo: U, value: T):U;
-	}
+    interface MemoCallback<T, U> {
+        (memo: U, value: T): U;
+    }
 
-	interface GeneratorCallback<T> {
-		(index: number):T;
-	}
+    interface GeneratorCallback<T> {
+        (index: number): T;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	interface Iterator<T> {
-		new (sequence: Sequence<T>):Iterator<T>;
-		current():T;
-		moveNext():boolean;
-	}
+    interface Iterator<T> {
+        new (sequence: Sequence<T>): Iterator<T>;
+        current(): T;
+        moveNext(): boolean;
+    }
 
-	interface GeneratedSequence<T> extends Sequence<T> {
-		new(generatorFn: GeneratorCallback<T>, length: number):GeneratedSequence<T>;
-		length():number;
-	}
+    interface GeneratedSequence<T> extends Sequence<T> {
+        new(generatorFn: GeneratorCallback<T>, length: number): GeneratedSequence<T>;
+        length(): number;
+    }
 
-	interface AsyncSequence<T> extends SequenceBase<T> {
-		each(callback: ValueCallback<T>):AsyncHandle<T>;
-	}
+    interface AsyncSequence<T> extends SequenceBase<T> {
+        each(callback: ValueCallback<T>): AsyncHandle<T>;
+    }
 
-	interface AsyncHandle<T> {
-		cancel():void;
-		onComplete(callback: Callback):void;
-		onError(callback: ErrorCallback):void;
-	}
+    interface AsyncHandle<T> {
+        cancel(): void;
+        onComplete(callback: Callback): void;
+        onError(callback: ErrorCallback): void;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module Sequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module Sequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface Sequence<T> extends SequenceBase<T> {
-		each(eachFn: ValueCallback<T>):Sequence<T>;
-	}
+    interface Sequence<T> extends SequenceBase<T> {
+        each(eachFn: ValueCallback<T>): Sequence<T>;
+    }
 
-	interface SequenceBase<T> extends SequenceBaser<T> {
-		first():any;
-		first(count: number):Sequence<T>;
-		indexOf(value: any, startIndex?: number):Sequence<T>;
+    interface SequenceBase<T> extends SequenceBaser<T> {
+        first(): any;
+        first(count: number): Sequence<T>;
+        indexOf(value: any, startIndex?: number): Sequence<T>;
 
-		last():any;
-		last(count: number):Sequence<T>;
-		lastIndexOf(value: any):Sequence<T>;
+        last(): any;
+        last(count: number): Sequence<T>;
+        lastIndexOf(value: any): Sequence<T>;
 
-		reverse():Sequence<T>;
-	}
+        reverse(): Sequence<T>;
+    }
 
-	interface SequenceBaser<T> {
-		// TODO improve define() (needs ugly overload)
-		async(interval: number):AsyncSequence<T>;
-		chunk(size: number):Sequence<T>;
-		compact():Sequence<T>;
-		concat(var_args: T[]):Sequence<T>;
-		consecutive(length: number):Sequence<T>;
-		contains(value: T):boolean;
-		countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
-		countBy(propertyName: string): ObjectLikeSequence<T>;
-		dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
-		every(predicateFn: TestCallback<T>): boolean;
-		filter(predicateFn: TestCallback<T>): Sequence<T>;
-		find(predicateFn: TestCallback<T>): Sequence<T>;
-		findWhere(properties: Object): Sequence<T>;
+    interface SequenceBaser<T> {
+        // TODO improve define() (needs ugly overload)
+        async(interval: number): AsyncSequence<T>;
+        chunk(size: number): Sequence<T>;
+        compact(): Sequence<T>;
+        concat(var_args: T[]): Sequence<T>;
+        consecutive(length: number): Sequence<T>;
+        contains(value: T): boolean;
+        countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+        countBy(propertyName: string): ObjectLikeSequence<T>;
+        dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
+        every(predicateFn: TestCallback<T>): boolean;
+        filter(predicateFn: TestCallback<T>): Sequence<T>;
+        find(predicateFn: TestCallback<T>): Sequence<T>;
+        findWhere(properties: Object): Sequence<T>;
 
-		flatten(): Sequence<T>;
-		groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
-		initial(count?: number): Sequence<T>;
-		intersection(var_args: T[]): Sequence<T>;
-		invoke(methodName: string): Sequence<T>;
-		isEmpty(): boolean;
-		join(delimiter?: string): string;
-		map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
+        flatten(): Sequence<T>;
+        groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+        initial(count?: number): Sequence<T>;
+        intersection(var_args: T[]): Sequence<T>;
+        invoke(methodName: string): Sequence<T>;
+        isEmpty(): boolean;
+        join(delimiter?: string): string;
+        map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
 
-		max(valueFn?: NumberCallback<T>): T;
-		min(valueFn?: NumberCallback<T>): T;
-		pluck(propertyName: string): Sequence<T>;
-		reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
-		reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
-		reject(predicateFn: TestCallback<T>): Sequence<T>;
-		rest(count?: number): Sequence<T>;
-		shuffle(): Sequence<T>;
-		some(predicateFn?: TestCallback<T>): boolean;
-		sortBy(sortFn: NumberCallback<T>): Sequence<T>;
-		sortedIndex(value: T): Sequence<T>;
-		sum(valueFn?: NumberCallback<T>): Sequence<T>;
-		takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
-		union(var_args: T[]): Sequence<T>;
-		uniq(): Sequence<T>;
-		where(properties: Object): Sequence<T>;
-		without(var_args: T[]): Sequence<T>;
-		zip(var_args: T[]): Sequence<T>;
+        max(valueFn?: NumberCallback<T>): T;
+        min(valueFn?: NumberCallback<T>): T;
+        pluck(propertyName: string): Sequence<T>;
+        reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
+        reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
+        reject(predicateFn: TestCallback<T>): Sequence<T>;
+        rest(count?: number): Sequence<T>;
+        shuffle(): Sequence<T>;
+        some(predicateFn?: TestCallback<T>): boolean;
+        sortBy(sortFn: NumberCallback<T>): Sequence<T>;
+        sortedIndex(value: T): Sequence<T>;
+        size(): number;
+        sum(valueFn?: NumberCallback<T>): Sequence<T>;
+        takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
+        union(var_args: T[]): Sequence<T>;
+        uniq(): Sequence<T>;
+        where(properties: Object): Sequence<T>;
+        without(var_args: T[]): Sequence<T>;
+        zip(var_args: T[]): Sequence<T>;
 
-		toArray(): T[];
-		toObject(): Object;
-	}
+        toArray(): T[];
+        toObject(): Object;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module ArrayLikeSequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module ArrayLikeSequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface ArrayLikeSequence<T> extends Sequence<T> {
-		// define()X;
-		concat(): ArrayLikeSequence<T>;
-		first(count?: number): ArrayLikeSequence<T>;
-		get(index: number): T;
-		length(): number;
-		map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
-		pop(): ArrayLikeSequence<T>;
-		rest(count?: number): ArrayLikeSequence<T>;
-		reverse(): ArrayLikeSequence<T>;
-		shift(): ArrayLikeSequence<T>;
-		slice(begin: number, end?: number): ArrayLikeSequence<T>;
-	}
+    interface ArrayLikeSequence<T> extends Sequence<T> {
+        // define()X;
+        concat(): ArrayLikeSequence<T>;
+        first(count?: number): ArrayLikeSequence<T>;
+        get(index: number): T;
+        length(): number;
+        map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
+        pop(): ArrayLikeSequence<T>;
+        rest(count?: number): ArrayLikeSequence<T>;
+        reverse(): ArrayLikeSequence<T>;
+        shift(): ArrayLikeSequence<T>;
+        slice(begin: number, end?: number): ArrayLikeSequence<T>;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module ObjectLikeSequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module ObjectLikeSequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface ObjectLikeSequence<T> extends Sequence<T> {
-		assign(other: Object): ObjectLikeSequence<T>;
-		// throws error
-		//async(): X;
-		defaults(defaults: Object): ObjectLikeSequence<T>;
-		functions(): Sequence<T>;
-		get(property: string): ObjectLikeSequence<T>;
-		invert(): ObjectLikeSequence<T>;
-		keys(): Sequence<string>;
-		omit(properties: string[]): ObjectLikeSequence<T>;
-		pairs(): Sequence<T>;
-		pick(properties: string[]): ObjectLikeSequence<T>;
-		toArray(): T[];
-		toObject(): Object;
-		values(): Sequence<T>;
-	}
+    interface ObjectLikeSequence<T> extends Sequence<T> {
+        assign(other: Object): ObjectLikeSequence<T>;
+        // throws error
+        //async(): X;
+        defaults(defaults: Object): ObjectLikeSequence<T>;
+        functions(): Sequence<T>;
+        get(property: string): ObjectLikeSequence<T>;
+        invert(): ObjectLikeSequence<T>;
+        keys(): Sequence<string>;
+        omit(properties: string[]): ObjectLikeSequence<T>;
+        pairs(): Sequence<T>;
+        pick(properties: string[]): ObjectLikeSequence<T>;
+        toArray(): T[];
+        toObject(): Object;
+        values(): Sequence<T>;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module StringLikeSequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module StringLikeSequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface StringLikeSequence extends SequenceBaser<string> {
-		charAt(index: number): string;
-		charCodeAt(index: number): number;
-		contains(value: string): boolean;
-		endsWith(suffix: string): boolean;
+    interface StringLikeSequence extends SequenceBaser<string> {
+        charAt(index: number): string;
+        charCodeAt(index: number): number;
+        contains(value: string): boolean;
+        endsWith(suffix: string): boolean;
 
-		first(): string;
-		first(count: number): StringLikeSequence;
+        first(): string;
+        first(count: number): StringLikeSequence;
 
-		indexOf(substring: string, startIndex?: number): number;
+        indexOf(substring: string, startIndex?: number): number;
 
-		last(): string;
-		last(count: number): StringLikeSequence;
+        last(): string;
+        last(count: number): StringLikeSequence;
 
-		lastIndexOf(substring: string, startIndex?: number): number;
-		mapString(mapFn: MapStringCallback): StringLikeSequence;
-		match(pattern: RegExp): StringLikeSequence;
-		reverse(): StringLikeSequence;
+        lastIndexOf(substring: string, startIndex?: number): number;
+        mapString(mapFn: MapStringCallback): StringLikeSequence;
+        match(pattern: RegExp): StringLikeSequence;
+        reverse(): StringLikeSequence;
 
-		split(delimiter: string): StringLikeSequence;
-		split(delimiter: RegExp): StringLikeSequence;
+        split(delimiter: string): StringLikeSequence;
+        split(delimiter: RegExp): StringLikeSequence;
 
-		startsWith(prefix: string): boolean;
-		substring(start: number, stop?: number): StringLikeSequence;
-		toLowerCase(): StringLikeSequence;
-		toUpperCase(): StringLikeSequence;
-	}
+        startsWith(prefix: string): boolean;
+        substring(start: number, stop?: number): StringLikeSequence;
+        toLowerCase(): StringLikeSequence;
+        toUpperCase(): StringLikeSequence;
+    }
 }
 
 declare var Lazy: LazyJS.LazyStatic;