diff --git a/src/Enumerable.ts b/src/Enumerable.ts
new file mode 100644
index 0000000..fce5a92
--- /dev/null
+++ b/src/Enumerable.ts
@@ -0,0 +1,4 @@
+import { Enumerable } from './internal/Enumerable';
+
+export default Enumerable;
+
diff --git a/src/bundle.ts b/src/bundle.ts
deleted file mode 100644
index 3b17c73..0000000
--- a/src/bundle.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { Enumerable } from './internal/Enumerable';
-
-import './extensions/aggregate';
-import './extensions/all';
-import './extensions/any';
-import './extensions/average';
-import './extensions/buffer';
-import './extensions/catch';
-import './extensions/concat';
-import './extensions/count';
-import './extensions/defaultIfEmpty';
-import './extensions/distinct';
-import './extensions/distinctUntilChanged';
-import './extensions/do';
-import './extensions/doWhile';
-import './extensions/elementAt';
-import './extensions/elementAtOrDefault';
-import './extensions/except';
-import './extensions/finally';
-import './extensions/first';
-import './extensions/firstOrDefault';
-import './extensions/forEach';
-import './extensions/groupBy';
-import './extensions/groupJoin';
-import './extensions/ignoreElements';
-import './extensions/intersect';
-import './extensions/isEmpty';
-import './extensions/join';
-import './extensions/last';
-import './extensions/lastOrDefault';
-import './extensions/max';
-import './extensions/maxBy';
-import './extensions/memoize';
-import './extensions/min';
-import './extensions/minBy';
-import './extensions/onErrorResumeNext';
-import './extensions/orderBy';
-import './extensions/orderByDescending';
-import './extensions/repeat';
-import './extensions/retry';
-import './extensions/reverse';
-import './extensions/scan';
-import './extensions/select';
-import './extensions/selectMany';
-import './extensions/single';
-import './extensions/singleOrDefault';
-import './extensions/skip';
-import './extensions/skipLast';
-import './extensions/skipWhile';
-import './extensions/startWith';
-import './extensions/static/catch';
-import './extensions/static/concat';
-import './extensions/static/defer';
-import './extensions/static/generate';
-import './extensions/static/if';
-import './extensions/static/range';
-import './extensions/static/repeat';
-import './extensions/static/return';
-import './extensions/static/zip';
-import './extensions/sum';
-import './extensions/take';
-import './extensions/takeLast';
-import './extensions/takeWhile';
-import './extensions/toArray';
-import './extensions/toDictionary';
-import './extensions/toLookup';
-import './extensions/union';
-import './extensions/where';
-import './extensions/while';
-import './extensions/zip';
-
-export default Enumerable;
diff --git a/src/index.ts b/src/index.ts
index f258da9..3b17c73 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,3 +1,72 @@
 import { Enumerable } from './internal/Enumerable';
 
+import './extensions/aggregate';
+import './extensions/all';
+import './extensions/any';
+import './extensions/average';
+import './extensions/buffer';
+import './extensions/catch';
+import './extensions/concat';
+import './extensions/count';
+import './extensions/defaultIfEmpty';
+import './extensions/distinct';
+import './extensions/distinctUntilChanged';
+import './extensions/do';
+import './extensions/doWhile';
+import './extensions/elementAt';
+import './extensions/elementAtOrDefault';
+import './extensions/except';
+import './extensions/finally';
+import './extensions/first';
+import './extensions/firstOrDefault';
+import './extensions/forEach';
+import './extensions/groupBy';
+import './extensions/groupJoin';
+import './extensions/ignoreElements';
+import './extensions/intersect';
+import './extensions/isEmpty';
+import './extensions/join';
+import './extensions/last';
+import './extensions/lastOrDefault';
+import './extensions/max';
+import './extensions/maxBy';
+import './extensions/memoize';
+import './extensions/min';
+import './extensions/minBy';
+import './extensions/onErrorResumeNext';
+import './extensions/orderBy';
+import './extensions/orderByDescending';
+import './extensions/repeat';
+import './extensions/retry';
+import './extensions/reverse';
+import './extensions/scan';
+import './extensions/select';
+import './extensions/selectMany';
+import './extensions/single';
+import './extensions/singleOrDefault';
+import './extensions/skip';
+import './extensions/skipLast';
+import './extensions/skipWhile';
+import './extensions/startWith';
+import './extensions/static/catch';
+import './extensions/static/concat';
+import './extensions/static/defer';
+import './extensions/static/generate';
+import './extensions/static/if';
+import './extensions/static/range';
+import './extensions/static/repeat';
+import './extensions/static/return';
+import './extensions/static/zip';
+import './extensions/sum';
+import './extensions/take';
+import './extensions/takeLast';
+import './extensions/takeWhile';
+import './extensions/toArray';
+import './extensions/toDictionary';
+import './extensions/toLookup';
+import './extensions/union';
+import './extensions/where';
+import './extensions/while';
+import './extensions/zip';
+
 export default Enumerable;
diff --git a/test/aggregateTest.ts b/test/aggregateTest.ts
index 5faa74f..748c9d0 100644
--- a/test/aggregateTest.ts
+++ b/test/aggregateTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('aggregate()', () => {
     it('should applies an accumulator function over a sequence', () => {
diff --git a/test/allTest.ts b/test/allTest.ts
index 8a0f5f6..f25cad3 100644
--- a/test/allTest.ts
+++ b/test/allTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('all()', () => {
     it('should determines whether all elements of a sequence satisfy a condition', () => {
diff --git a/test/anyTest.ts b/test/anyTest.ts
index 1604d8a..785eec7 100644
--- a/test/anyTest.ts
+++ b/test/anyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('any()', () => {
     it('should determines whether a sequence contains any elements', () => {
diff --git a/test/averageTest.ts b/test/averageTest.ts
index 395bddb..9e14c76 100644
--- a/test/averageTest.ts
+++ b/test/averageTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('average()', () => {
     it('should computes the average of a sequence of numbers', () => {
diff --git a/test/bufferTest.ts b/test/bufferTest.ts
index bc4fd96..395703e 100644
--- a/test/bufferTest.ts
+++ b/test/bufferTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('buffer()', () => {
     it('should generates a sequence of non-overlapping adjacent buffers over the source sequence', () => {
diff --git a/test/catchTest.ts b/test/catchTest.ts
index b962e72..4a13b5d 100644
--- a/test/catchTest.ts
+++ b/test/catchTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('catch()', () => {
     it('should creates a sequence that corresponds to the source sequence', () => {
diff --git a/test/concatTest.ts b/test/concatTest.ts
index 423aede..eb4896c 100644
--- a/test/concatTest.ts
+++ b/test/concatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('concat()', () => {
     it('should concatenates two sequences', () => {
diff --git a/test/countTest.ts b/test/countTest.ts
index c82aa58..c4420fa 100644
--- a/test/countTest.ts
+++ b/test/countTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('count()', () => {
     it('should returns the number of elements in a sequence', () => {
diff --git a/test/defaultIfEmptyTest.ts b/test/defaultIfEmptyTest.ts
index f3041cb..6575d33 100644
--- a/test/defaultIfEmptyTest.ts
+++ b/test/defaultIfEmptyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('defaultIfEmpty()', () => {
     it('should returns the elements of the specified sequence', () => {
diff --git a/test/distinctTest.ts b/test/distinctTest.ts
index cfe5617..02a95f7 100644
--- a/test/distinctTest.ts
+++ b/test/distinctTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('distinct()', () => {
     it('should returns distinct elements from a sequence', () => {
diff --git a/test/distinctUntilChangedTest.ts b/test/distinctUntilChangedTest.ts
index 2b1db18..dd3ca1d 100644
--- a/test/distinctUntilChangedTest.ts
+++ b/test/distinctUntilChangedTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('distinctUntilChanged()', () => {
     it('should returns consecutive distinct elements', () => {
diff --git a/test/doTest.ts b/test/doTest.ts
index d954be0..7e18116 100644
--- a/test/doTest.ts
+++ b/test/doTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('do()', () => {
     it('should lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination', () => {
diff --git a/test/doWhileTest.ts b/test/doWhileTest.ts
index 16d06b8..bc41236 100644
--- a/test/doWhileTest.ts
+++ b/test/doWhileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('doWhile()', () => {
     it('should generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds', () => {
diff --git a/test/elementAtOrDefaultTest.ts b/test/elementAtOrDefaultTest.ts
index 32704e6..5be1ab4 100644
--- a/test/elementAtOrDefaultTest.ts
+++ b/test/elementAtOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('elementAtOrDefault()', () => {
     it('should returns the element at a specified index in a sequence', () => {
diff --git a/test/elementAtTest.ts b/test/elementAtTest.ts
index c842ff1..05a1174 100644
--- a/test/elementAtTest.ts
+++ b/test/elementAtTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('elementAt()', () => {
     it('should returns the element at a specified index in a sequence', () => {
diff --git a/test/exceptTest.ts b/test/exceptTest.ts
index 8c326f3..1a961a4 100644
--- a/test/exceptTest.ts
+++ b/test/exceptTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('except()', () => {
     it('should produces the set difference of two sequences', () => {
diff --git a/test/finallyTest.ts b/test/finallyTest.ts
index b86ad25..8009e82 100644
--- a/test/finallyTest.ts
+++ b/test/finallyTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('finally()', () => {
     it('should creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed', () => {
diff --git a/test/firstOrDefaultTest.ts b/test/firstOrDefaultTest.ts
index f147d31..70be8b8 100644
--- a/test/firstOrDefaultTest.ts
+++ b/test/firstOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('firstOrDefault()', () => {
     it('should returns the first element of a sequence', () => {
diff --git a/test/firstTest.ts b/test/firstTest.ts
index fd904cf..f40dba6 100644
--- a/test/firstTest.ts
+++ b/test/firstTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('first()', () => {
     it('should returns the first element of a sequence', () => {
diff --git a/test/forEachTest.ts b/test/forEachTest.ts
index 3f26c71..8bac435 100644
--- a/test/forEachTest.ts
+++ b/test/forEachTest.ts
@@ -1,5 +1,5 @@
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('forEach()', () => {
     it('should enumerates the sequence and invokes the given action for each value in the sequence', () => {
diff --git a/test/groupByTest.ts b/test/groupByTest.ts
index 56bc3ac..0d298df 100644
--- a/test/groupByTest.ts
+++ b/test/groupByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('groupBy()', () => {
     it('should groups the elements of a sequence according to a specified key selector function', () => {
diff --git a/test/groupJoinTest.ts b/test/groupJoinTest.ts
index bf61fe8..9355229 100644
--- a/test/groupJoinTest.ts
+++ b/test/groupJoinTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('groupJoin()', () => {
     it('should correlates the elements of two sequences based on equality of keys and groups the results', () => {
diff --git a/test/ignoreElementsTest.ts b/test/ignoreElementsTest.ts
index 46699ec..13b946b 100644
--- a/test/ignoreElementsTest.ts
+++ b/test/ignoreElementsTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('ignoreElements()', () => {
     it('should ignores all elements in the source sequence', () => {
diff --git a/test/intersectTest.ts b/test/intersectTest.ts
index 6a169e5..db22348 100644
--- a/test/intersectTest.ts
+++ b/test/intersectTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('intersect()', () => {
     it('should Produces the set intersection of two sequences by using the default equality comparer to compare values', () => {
diff --git a/test/isEmptyTest.ts b/test/isEmptyTest.ts
index b9ce270..edac95a 100644
--- a/test/isEmptyTest.ts
+++ b/test/isEmptyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('isEmpty()', () => {
     it('should determines whether an enumerable sequence is empty', () => {
diff --git a/test/joinTest.ts b/test/joinTest.ts
index 35301c1..e7e38e7 100644
--- a/test/joinTest.ts
+++ b/test/joinTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('join()', () => {
     it('should correlates the elements of two sequences based on matching keys', () => {
diff --git a/test/lastOrDefaultTest.ts b/test/lastOrDefaultTest.ts
index 766054d..9adbac5 100644
--- a/test/lastOrDefaultTest.ts
+++ b/test/lastOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('lastOrDefault()', () => {
     it('should returns the last element of a sequence', () => {
diff --git a/test/lastTest.ts b/test/lastTest.ts
index fdb71c0..ea9ea4c 100644
--- a/test/lastTest.ts
+++ b/test/lastTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('last()', () => {
     it('should returns the last element of a sequence', () => {
diff --git a/test/maxByTest.ts b/test/maxByTest.ts
index 8841d0a..0369e93 100644
--- a/test/maxByTest.ts
+++ b/test/maxByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('maxBy()', () => {
     it('should returns the elements with the minimum key value by using the default comparer to compare key values', () => {
diff --git a/test/maxTest.ts b/test/maxTest.ts
index a9c5224..313ede3 100644
--- a/test/maxTest.ts
+++ b/test/maxTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('max()', () => {
     it('should returns the maximum value in a sequence of values', () => {
diff --git a/test/memoizeTest.ts b/test/memoizeTest.ts
index 658eb53..87878c9 100644
--- a/test/memoizeTest.ts
+++ b/test/memoizeTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('memoize()', () => {
     it('should creates a buffer with a view over the source sequence', () => {
diff --git a/test/minByTest.ts b/test/minByTest.ts
index 7ba6fe5..2800359 100644
--- a/test/minByTest.ts
+++ b/test/minByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('minBy()', () => {
     it('should returns the elements with the maximum key value by using the default comparer to compare key values', () => {
diff --git a/test/minTest.ts b/test/minTest.ts
index 67cb636..bc0bf57 100644
--- a/test/minTest.ts
+++ b/test/minTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('min()', () => {
     it('should returns the minimum value in a sequence of values', () => {
diff --git a/test/onErrorResumeNextTest.ts b/test/onErrorResumeNextTest.ts
index 0fb3970..7acb534 100644
--- a/test/onErrorResumeNextTest.ts
+++ b/test/onErrorResumeNextTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('onErrorResumeNext()', () => {
     it('should creates a sequence that concatenates both given sequences', () => {
diff --git a/test/orderByDescendingTest.ts b/test/orderByDescendingTest.ts
index 47b1799..779380e 100644
--- a/test/orderByDescendingTest.ts
+++ b/test/orderByDescendingTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('orderByDescending()', () => {
     it('should sorts the elements of a sequence in ascending order according to a key', () => {
diff --git a/test/orderByTest.ts b/test/orderByTest.ts
index cd026c8..08a4e7a 100644
--- a/test/orderByTest.ts
+++ b/test/orderByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('orderBy()', () => {
     it('should sorts the elements of a sequence in ascending order according to a key', () => {
diff --git a/test/repeatTest.ts b/test/repeatTest.ts
index 5b3eec0..3aa779a 100644
--- a/test/repeatTest.ts
+++ b/test/repeatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('repeat()', () => {
     it('should generates a sequence by repeating the given value.', () => {
diff --git a/test/retryTest.ts b/test/retryTest.ts
index 4487bd7..605d12c 100644
--- a/test/retryTest.ts
+++ b/test/retryTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('retry()', () => {
     it('should creates a sequence that retries enumerating the source sequence as long as an error occurs.', () => {
diff --git a/test/reverseTest.ts b/test/reverseTest.ts
index 08de779..52b87bb 100644
--- a/test/reverseTest.ts
+++ b/test/reverseTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('reverse()', () => {
     it('should inverts the order of the elements in a sequence', () => {
diff --git a/test/scanTest.ts b/test/scanTest.ts
index 066f688..7fae4a4 100644
--- a/test/scanTest.ts
+++ b/test/scanTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('scan()', () => {
     it('should generates a sequence of accumulated values', () => {
diff --git a/test/selectManyTest.ts b/test/selectManyTest.ts
index 83ca2c6..20706cc 100644
--- a/test/selectManyTest.ts
+++ b/test/selectManyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('selectMany()', () => {
     it('should projects each element of a sequence to a Iterable<T>', () => {
diff --git a/test/selectTest.ts b/test/selectTest.ts
index bd8d5ac..a780aa0 100644
--- a/test/selectTest.ts
+++ b/test/selectTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('select()', () => {
     it('should projects each element of a sequence', () => {
diff --git a/test/singleOrDefaultTest.ts b/test/singleOrDefaultTest.ts
index fc45908..4451a4e 100644
--- a/test/singleOrDefaultTest.ts
+++ b/test/singleOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('singleOrDefault()', () => {
     it('should returns the only element of a sequence', () => {
diff --git a/test/singleTest.ts b/test/singleTest.ts
index 9b7415b..edc91d8 100644
--- a/test/singleTest.ts
+++ b/test/singleTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('single()', () => {
     it('should returns the only element of a sequence', () => {
diff --git a/test/skipLastTest.ts b/test/skipLastTest.ts
index c37835e..c300866 100644
--- a/test/skipLastTest.ts
+++ b/test/skipLastTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('skipLast()', () => {
     it('should bypasses a specified number of contiguous elements from the end of the sequence', () => {
diff --git a/test/skipTest.ts b/test/skipTest.ts
index 0291b6c..18b170e 100644
--- a/test/skipTest.ts
+++ b/test/skipTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('skip()', () => {
     it('should bypasses a specified number of elements in a sequence and then returns the remaining elements', () => {
diff --git a/test/skipWhileTest.ts b/test/skipWhileTest.ts
index f36df61..f36fd2e 100644
--- a/test/skipWhileTest.ts
+++ b/test/skipWhileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('skipWhile()', () => {
     it('should skip elements in a sequence while a condition is true', () => {
diff --git a/test/startWithTest.ts b/test/startWithTest.ts
index f828740..f39327c 100644
--- a/test/startWithTest.ts
+++ b/test/startWithTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('startWith()', () => {
     it('should returns the source sequence prefixed with the specified value', () => {
diff --git a/test/static/catchTest.ts b/test/static/catchTest.ts
index 70f0a78..55abed7 100644
--- a/test/static/catchTest.ts
+++ b/test/static/catchTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('catch()', () => {
     it('should creates a sequence by concatenating source sequences until a source sequence completes successfully', () => {
diff --git a/test/static/concatTest.ts b/test/static/concatTest.ts
index c22dcb2..91fa9dc 100644
--- a/test/static/concatTest.ts
+++ b/test/static/concatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('concat()', () => {
     it('should concatenates two sequences', () => {
diff --git a/test/static/deferTest.ts b/test/static/deferTest.ts
index a9df2f8..fcbcf17 100644
--- a/test/static/deferTest.ts
+++ b/test/static/deferTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('defer()', () => {
     it('should creates an enumerable sequence based on an enumerable factory function', () => {
diff --git a/test/static/generateTest.ts b/test/static/generateTest.ts
index b192fa5..05b4ddc 100644
--- a/test/static/generateTest.ts
+++ b/test/static/generateTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('generate()', () => {
     it('should generates a sequence by mimicking a for loop', () => {
diff --git a/test/static/ifTest.ts b/test/static/ifTest.ts
index 28ae34b..f263011 100644
--- a/test/static/ifTest.ts
+++ b/test/static/ifTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('if()', () => {
     it('should returns an enumerable sequence based on the evaluation result of the given condition', () => {
diff --git a/test/static/rangeTest.ts b/test/static/rangeTest.ts
index 1a0f98c..0ecf715 100644
--- a/test/static/rangeTest.ts
+++ b/test/static/rangeTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('range()', () => {
     it('should generates a sequence of integral numbers within a specified range', () => {
diff --git a/test/static/repeatTest.ts b/test/static/repeatTest.ts
index 8851342..5742096 100644
--- a/test/static/repeatTest.ts
+++ b/test/static/repeatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('repeat()', () => {
     it('should generates a sequence by repeating the given value', () => {
diff --git a/test/static/returnTest.ts b/test/static/returnTest.ts
index 71d3b77..c1bfa4f 100644
--- a/test/static/returnTest.ts
+++ b/test/static/returnTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('return()', () => {
     it('should returns a sequence with a single element.', () => {
diff --git a/test/static/zipTest.ts b/test/static/zipTest.ts
index 6f655cc..a36da92 100644
--- a/test/static/zipTest.ts
+++ b/test/static/zipTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src/bundle';
+import Enumerable from '../../src/';
 
 describe('zip()', () => {
     it('should applies a specified function to the corresponding elements of two sequences', () => {
diff --git a/test/sumTest.ts b/test/sumTest.ts
index ac8505a..bd25f79 100644
--- a/test/sumTest.ts
+++ b/test/sumTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('sum()', () => {
     it('should computes the sum of a sequence of numeric values', () => {
diff --git a/test/takeLastTest.ts b/test/takeLastTest.ts
index 5106e67..fc5f4df 100644
--- a/test/takeLastTest.ts
+++ b/test/takeLastTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('takeLast()', () => {
     it('should returns a specified number of contiguous elements from the end of the sequence', () => {
diff --git a/test/takeTest.ts b/test/takeTest.ts
index 33288f9..0b7c031 100644
--- a/test/takeTest.ts
+++ b/test/takeTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('take()', () => {
     it('should returns a specified number of contiguous elements from the start of a sequence', () => {
diff --git a/test/takeWhileTest.ts b/test/takeWhileTest.ts
index 80eeed0..478eb78 100644
--- a/test/takeWhileTest.ts
+++ b/test/takeWhileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('takeWhile()', () => {
     it('should yield elements from a sequence while a condition is true', () => {
diff --git a/test/toArrayTest.ts b/test/toArrayTest.ts
index f7314f1..cb75cc8 100644
--- a/test/toArrayTest.ts
+++ b/test/toArrayTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('toArray()', () => {
     it('should creates a Array<T> from Iterable<T>', () => {
diff --git a/test/toDictionaryTest.ts b/test/toDictionaryTest.ts
index f2d9ce2..a9f36cb 100644
--- a/test/toDictionaryTest.ts
+++ b/test/toDictionaryTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('toDictionary()', () => {
     it('should creates a Map<T> from Iterable<T>', () => {
diff --git a/test/toLookupTest.ts b/test/toLookupTest.ts
index 8514d86..48d8d5d 100644
--- a/test/toLookupTest.ts
+++ b/test/toLookupTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('toLookup()', () => {
     it('should creates a generic Map<TKey, TElement> from an Iterable<T>', () => {
diff --git a/test/unionTest.ts b/test/unionTest.ts
index 38bd35b..2e09238 100644
--- a/test/unionTest.ts
+++ b/test/unionTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('union()', () => {
     it('should produces the set union of two sequences', () => {
diff --git a/test/whereTest.ts b/test/whereTest.ts
index aa8a58f..cd3b49e 100644
--- a/test/whereTest.ts
+++ b/test/whereTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('where()', () => {
     it('should filters a sequence of values based on a predicate', () => {
diff --git a/test/whileTest.ts b/test/whileTest.ts
index 9d24472..b11deb1 100644
--- a/test/whileTest.ts
+++ b/test/whileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('while()', () => {
     it('should generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds', () => {
diff --git a/test/zipTest.ts b/test/zipTest.ts
index 68983ae..f6869b5 100644
--- a/test/zipTest.ts
+++ b/test/zipTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/bundle';
+import Enumerable from '../src/';
 
 describe('zip()', () => {
     it('should applies a specified function to the corresponding elements of two sequences', () => {