diff --git a/README.md b/README.md
index 13d674b..fa44c6f 100644
--- a/README.md
+++ b/README.md
@@ -23,8 +23,9 @@ npm install datapipe-js
 JavaScript / TypeScript
 ```js
 const data = [
-  { name: "John",  country: "US"}, { name: "Joe", country: "US"}, { name: "Bill",  country: "US"}, { name: "Adam", country: "UK"}, 
-  { name: "Scott", country: "UK"}, { name: "Diana",country: "UK"}, { name: "Marry",country: "FR"}, { name: "Luc",country: "FR"}
+  { name: "John",  country: "US"}, { name: "Joe", country: "US"}, { name: "Bill",  country: "US"},
+  { name: "Adam", country: "UK"}, { name: "Scott", country: "UK"}, { name: "Diana",country: "UK"},
+  { name: "Marry",country: "FR"}, { name: "Luc",country: "FR"}
 ];
 
 const summaryForUS = dataPipe(data)
diff --git a/index.html b/index.html
index 91ba7d3..4a6d859 100644
--- a/index.html
+++ b/index.html
@@ -14,17 +14,17 @@ <h4>Data Pipe testing page. Do not expect anything here! </h4>
   <script>
 
     let csv = `
-F1,F2,F3,F4,F5
-11,12.5,1234.22,tt,"1 2,t3 4 5"
-21,22.2,1321.32,yy,"5 4,t3 2 1"
-    `;
+Product,Year,Sale
+P1,2017,11
+P1,2017,20
+P1,2018,12
+P2,2017,21
+P2,2018,21
+P3,2017,31`;
 
     function onButtonClick() {
-      const csv = ["", "", "F1\tF2\tF3", `1\t1,000.32\t"Test, comma"`, "\t\t"].join('\n')
-      const arr = dataPipe.dataPipe()
-        .fromCsv(csv, { separator: '\t' })
-        .toArray();
-      console.log(arr);
+      const res = dp.pivot(dp.parseCsv(csv), "Product", "Year", "Sale")
+      console.log(res);
     }
 
     onButtonClick();
diff --git a/package.json b/package.json
index b4aa4e1..2bded83 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "datapipe-js",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "description": "dataPipe is a JavaScript library for data manipulations, data transformations and data analytics inspired by LINQ (C#) and Pandas - (Python)",
   "main": "dist/data-pipe.min.js",
   "module": "dist/data-pipe.esm.js",
@@ -32,7 +32,7 @@
   "keywords": [
     "data",
     "data-analysis",
-    "linq",
+    "LINQ",
     "pandas",
     "data-management",
     "data-science",
diff --git a/rollup.config.dev.js b/rollup.config.dev.js
index 7e14385..bc3f78f 100644
--- a/rollup.config.dev.js
+++ b/rollup.config.dev.js
@@ -6,7 +6,7 @@ export default {
 
   input: 'src/index.ts',
   output: {
-    name: 'dataPipe',
+    name: 'dp',
     file: 'dist/data-pipe.min.js',
     format: 'umd',
     sourcemap: true,
diff --git a/rollup.config.js b/rollup.config.js
index d629a7b..15c5298 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -7,7 +7,7 @@ const input = 'src/index.ts';
 export default [{
   input,
   output: [
-    { file: pkg.main, name: 'dataPipe', format: 'umd', sourcemap: true, compact: true },
+    { file: pkg.main, name: 'dp', format: 'umd', sourcemap: true, compact: true },
   ],
   treeshake: true,
   plugins: [
diff --git a/src/_internals.ts b/src/_internals.ts
new file mode 100644
index 0000000..2244ee8
--- /dev/null
+++ b/src/_internals.ts
@@ -0,0 +1,13 @@
+import { Selector } from "./types";
+
+export function fieldSelector(input: string | string[] | Selector<any, string>): Selector<any, string> {
+    if (typeof input === "function") {
+        return input;
+    } else if (typeof input === "string") {
+        return (item) => item[input];
+    } else if (Array.isArray(input)) {
+        return (item) => input.map(r => item[r]).join('|');
+    } else {
+        throw Error(`Unknown input. Can't create a fieldSelector`)
+    }
+}
\ No newline at end of file
diff --git a/src/array.ts b/src/array.ts
deleted file mode 100644
index 9b1e1a8..0000000
--- a/src/array.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-import { Selector, Predicate } from './models';
-import { getNumberValuesArray, parseNumber } from './utils';
-
-/**
- * Sum of items in array.
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- * @returns Sum of array.
- * @public
- * @example
- * sum([1, 2, 5]); // 8
- *
- * sum([{ val: 1 }, { val: 5 }], i => i.val); // 6
- */
-export function sum(array: any[], elementSelector?: Selector): number | undefined {
-  if (!Array.isArray(array)) return;
-  const sum: number = (array.reduce((prev: number, val) => {
-    const numberVal = parseNumber(val, elementSelector);
-    if (numberVal !== undefined) {
-      prev += numberVal;
-    }
-    return prev;
-  }, 0) as number);
-  return sum;
-}
-
-/**
- * Average of array items.
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- * @public
- * @example
- * avg([1, 5, 3]); // 3
- */
-export function avg(array: any[], elementSelector?: Selector): number | undefined {
-  const s = sum(array, elementSelector);
-  if (s) {
-    return s / array.length;
-  }
-}
-
-/**
- * Count of elements in array.
- * @public
- * @param array The array to process.
- * @param predicate Predicate function invoked per iteration.
- */
-export function count(array: any[], predicate?: Predicate): number | undefined {
-  if (!Array.isArray(array)) return;
-  if (!predicate || typeof predicate !== 'function') {
-    return array.length;
-  }
-  return array.filter(predicate).length;
-}
-
-/**
- * Computes the minimum value of array.
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- */
-export function min(array: any[], elementSelector?: Selector): number | Date | undefined {
-  if (!Array.isArray(array)) return;
-  const item = elementSelector ? elementSelector(array[0]) : array[0];
-  const min = Math.min(...getNumberValuesArray(array, elementSelector));
-  if (item instanceof Date) {
-    return new Date(min);
-  }
-  return min;
-}
-
-/**
- * Computes the maximum value of array.
- * @public
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- */
-export function max(array: any[], elementSelector?: Selector): number | Date | null {
-  if (!(Array.isArray(array) && array.length)) return null;
-  const item = elementSelector ? elementSelector(array[0]) : array[0];
-  const max = Math.max(...getNumberValuesArray(array, elementSelector));
-  if (item instanceof Date) {
-    return new Date(max);
-  }
-  return max;
-}
-
-/**
- * Gets first item in array satisfies predicate.
- * @param array The array to process.
- * @param predicate Predicate function invoked per iteration.
- */
-export function first<T = any>(array: T[], predicate?: Predicate): T | undefined {
-  if (!Array.isArray(array) || !array.length) return;
-  if (!predicate) {
-    return array[0];
-  }
-  for (let i = 0; i < array.length; i++) {
-    if (predicate(array[i])) {
-      return array[i];
-    }
-  }
-}
-
-/**
- * Gets last item in array satisfies predicate.
- * @param array The array to process.
- * @param predicate Predicate function invoked per iteration.
- */
-export function last<T = any>(array: T[], predicate?: Predicate): T | undefined {
-  if (!Array.isArray(array) || !array.length) return;
-  let lastIndex = array.length - 1;
-  if (!predicate) {
-    return array[lastIndex];
-  }
-
-  for (; lastIndex >= 0; lastIndex--) {
-    if (predicate(array[lastIndex])) {
-      return array[lastIndex];
-    }
-  }
-}
-
-/**
- * Groups array items based on elementSelector function
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- */
-export function groupBy<T = any>(array: T[], elementSelector: Selector): Array<T[]> {
-  const groups: { [key: string]: T[] } = {};
-  const length = array.length;
-
-  for (let i = 0; i < length; i++) {
-    const item = array[i];
-    const group = elementSelector(item);
-    groups[group] = groups[group] || [];
-    groups[group].push(item);
-  }
-
-  return Object.values(groups);
-}
-
-/**
- * Flattens array.
- * @param array The array to flatten recursively.
- * @example
- * flatten([1, 4, [2, [5, 5, [9, 7]], 11], 0]); // length 9
- */
-export function flatten(array: any[]): any[] {
-  let res: any = [];
-  const length = array.length;
-
-  for (let i = 0; i < length; i++) {
-    var value = array[i];
-    if (Array.isArray(value)) {
-      res = [...res, ...flatten(value)];
-    } else {
-      res.push(value);
-    }
-  }
-  return res;
-}
-
-/**
- * Gets counts map of values returned by `elementSelector`.
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- */
-export function countBy(array: any[], elementSelector: Selector): { [key: string]: number } {
-  const results: { [key: string]: number } = {};
-  const length = array.length;
-
-  for (let i = 0; i < length; i++) {
-    const item = array[i];
-    const group = elementSelector(item);
-    results[group] = results[group] || 0;
-    results[group]++;
-  }
-
-  return results;
-}
-
-/**
-  * Joins data in array by elementSelector functions.
- * @param array The array to process.
- * @param array2 The array to join.
- * @param elementSelector Gets key value of array.
- * @param elementSelector2 Gets key value of array2.
- */
-
-export function joinArray(array: any[], array2: object[], elementSelector: Selector, elementSelector2: Selector): any[] {
-  const length = array.length;
-  const res = [];
-  for (let i = 0; i < length; i++) {
-    const item = array[i];
-    const item2 = array2.find(item2 => elementSelector(item) === elementSelector2(item2));
-    res.push({ ...item, ...item2 })
-  }
-
-  return res;
-}
-
diff --git a/src/array/index.ts b/src/array/index.ts
new file mode 100644
index 0000000..cbbfd22
--- /dev/null
+++ b/src/array/index.ts
@@ -0,0 +1,3 @@
+export * from './joins'
+export * from './stats'
+export * from './transform'
\ No newline at end of file
diff --git a/src/array-joins.ts b/src/array/joins.ts
similarity index 76%
rename from src/array-joins.ts
rename to src/array/joins.ts
index e50813a..048f6bd 100644
--- a/src/array-joins.ts
+++ b/src/array/joins.ts
@@ -1,32 +1,20 @@
-
-export type FieldSelectorFunction = (item: any) => string;
-
-function fieldSelector(input: string | string[] | FieldSelectorFunction): FieldSelectorFunction {
-  if (typeof input === "function") {
-    return input;
-  } else if (typeof input === "string") {
-    return (item) => item[input];
-  } else if (Array.isArray(input)) {
-    return (item) => input.map(r => item[r]).join('|');
-  } else {
-    throw Error(`Unknown input. Can't create a fieldSelector`)
-  }
-}
+import { Selector } from "../types";
+import { fieldSelector } from "../_internals";
 
 /**
  * leftJoin returns all elements from the left array (leftArray), and the matched elements from the right array (rightArray).
  * The result is NULL from the right side, if there is no match.
- * @param leftArray : array for left side in a join  
- * @param rightArray : array for right side in a join
- * @param leftKey : A key from left side array. What can be as a fieldName, multiple fields or key Selector
- * @param rightKey : A key from right side array. what can be as a fieldName, multiple fields or key Selector
+ * @param leftArray array for left side in a join  
+ * @param rightArray array for right side in a join
+ * @param leftKey A key from left side array. What can be as a fieldName, multiple fields or key Selector
+ * @param rightKey A key from right side array. what can be as a fieldName, multiple fields or key Selector
  * @param resultSelector A callback function that returns result value
  */
 export function leftJoin(
     leftArray: any[],
     rightArray: any[],
-    leftKeySelector: string | string[] | FieldSelectorFunction,
-    rightKeySelector: string | string[] | FieldSelectorFunction,
+    leftKeySelector: string | string[] | Selector<any, string>,
+    rightKeySelector: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
 ): any[] {
     return leftOrInnerJoin(false, leftArray, rightArray, leftKeySelector, rightKeySelector, resultSelector);
@@ -35,17 +23,17 @@ export function leftJoin(
 /**
  * innerJoin - Joins two arrays together by selecting elements that have matching values in both arrays.
  * If there are elements in any array that do not have matches in other array, these elements will not be shown!
- * @param leftArray : array for left side in a join  
- * @param rightArray : array for right side in a join
- * @param leftKey : A key from left side array. What can be as a fieldName, multiple fields or key Selector
- * @param rightKey : A key from right side array. what can be as a fieldName, multiple fields or key Selector
+ * @param leftArray array for left side in a join  
+ * @param rightArray array for right side in a join
+ * @param leftKey A key from left side array. What can be as a fieldName, multiple fields or key Selector
+ * @param rightKey A key from right side array. what can be as a fieldName, multiple fields or key Selector
  * @param resultSelector A callback function that returns result value
  */
 export function innerJoin(
     leftArray: any[],
     rightArray: any[],
-    leftKey: string | string[] | FieldSelectorFunction,
-    rightKey: string | string[] | FieldSelectorFunction,
+    leftKey: string | string[] | Selector<any, string>,
+    rightKey: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
 ): any[] {
     return leftOrInnerJoin(true, leftArray, rightArray, leftKey, rightKey, resultSelector);
@@ -54,17 +42,17 @@ export function innerJoin(
 /**
  * fullJoin returns all elements from the left array (leftArray), and all elements from the right array (rightArray).
  * The result is NULL from the right/left side, if there is no match.
- * @param leftArray : array for left side in a join  
- * @param rightArray : array for right side in a join
- * @param leftKey : A key from left side array. What can be as a fieldName, multiple fields or key Selector
- * @param rightKey : A key from right side array. what can be as a fieldName, multiple fields or key Selector
+ * @param leftArray array for left side in a join  
+ * @param rightArray array for right side in a join
+ * @param leftKey A key from left side array. What can be as a fieldName, multiple fields or key Selector
+ * @param rightKey A key from right side array. what can be as a fieldName, multiple fields or key Selector
  * @param resultSelector A callback function that returns result value
  */
 export function fullJoin(
     leftArray: any[],
     rightArray: any[],
-    leftKey: string | string[] | FieldSelectorFunction,
-    rightKey: string | string[] | FieldSelectorFunction,
+    leftKey: string | string[] | Selector<any, string>,
+    rightKey: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
 ): any[] {
     const leftKeySelector = fieldSelector(leftKey);
@@ -120,8 +108,8 @@ export function fullJoin(
 export function merge(
     targetArray: any[],
     sourceArray: any[],
-    targetKey: string | string[] | FieldSelectorFunction,
-    sourceKey: string | string[] | FieldSelectorFunction
+    targetKey: string | string[] | Selector<any, string>,
+    sourceKey: string | string[] | Selector<any, string>
 ): any[] {
 
     const targetKeySelector = fieldSelector(targetKey);
@@ -142,7 +130,7 @@ export function merge(
 
     for (let sourceItemKey of Object.keys(sourceArrayMap)) {
         const sourceItem = sourceArrayMap[sourceItemKey];
-        if(!targetArrayMap[sourceItemKey]){
+        if (!targetArrayMap[sourceItemKey]) {
             targetArray.push(sourceItem);
         } else {
             // merge properties in
@@ -181,12 +169,15 @@ function verifyJoinArgs(
     }
 }
 
+
+
+
 function leftOrInnerJoin(
     isInnerJoin: boolean,
     leftArray: any[],
     rightArray: any[],
-    leftKey: string | string[] | FieldSelectorFunction,
-    rightKey: string | string[] | FieldSelectorFunction,
+    leftKey: string | string[] | Selector<any, string>,
+    rightKey: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
 ): any[] {
     const leftKeySelector = fieldSelector(leftKey);
diff --git a/src/array/stats.ts b/src/array/stats.ts
new file mode 100644
index 0000000..1e990b5
--- /dev/null
+++ b/src/array/stats.ts
@@ -0,0 +1,162 @@
+import { Selector, Predicate } from "../types";
+import { parseNumber } from "../utils";
+
+/**
+ * Sum of items in array.
+ * @param array The array to process.
+ * @param elementSelector Function invoked per iteration.
+ * @returns Sum of array.
+ * @public
+ * @example
+ * sum([1, 2, 5]); // 8
+ *
+ * sum([{ val: 1 }, { val: 5 }], i => i.val); // 6
+ */
+export function sum(array: any[], field?: Selector | string): number | null {
+    if (!Array.isArray(array) || !array.length) return null;
+
+    const elementSelector = fieldSelector(field);
+
+    let sum: number = 0;
+    for (const item of array) {
+        const numberVal = parseNumber(item, elementSelector);
+        if (numberVal) {
+            sum += numberVal;
+        }
+    }
+
+    return sum;
+}
+
+/**
+ * Average of array items.
+ * @param array The array to process.
+ * @param elementSelector Function invoked per iteration.
+ * @public
+ * @example
+ * avg([1, 5, 3]); // 3
+ */
+export function avg(array: any[], field?: Selector | string): number | null {
+    const elementSelector = fieldSelector(field);
+
+    const s = sum(array, elementSelector);
+
+    return s ? s / array.length : null;
+}
+
+/**
+ * Computes the minimum value of array.
+ * @param array The array to process.
+ * @param elementSelector Function invoked per iteration.
+ */
+export function min(array: any[], field?: Selector | string): number | Date | null {
+    if (!Array.isArray(array)) return null;
+
+    const elementSelector = fieldSelector(field);
+
+    const item = elementSelector ? elementSelector(array[0]) : array[0];
+    const min = Math.min(...getNumberValuesArray(array, elementSelector));
+    if (item instanceof Date) {
+        return new Date(min);
+    }
+    return min;
+}
+
+/**
+ * Computes the maximum value of array.
+ * @public
+ * @param array The array to process.
+ * @param elementSelector Function invoked per iteration.
+ */
+export function max(array: any[], field?: Selector | string): number | Date | null {
+    if (!(Array.isArray(array) && array.length)) return null;
+    const elementSelector = fieldSelector(field);
+
+    const item = elementSelector ? elementSelector(array[0]) : array[0];
+    const max = Math.max(...getNumberValuesArray(array, elementSelector));
+    if (item instanceof Date) {
+        return new Date(max);
+    }
+    return max;
+}
+
+/**
+ * Count of elements in array.
+ * @public
+ * @param array The array to process.
+ * @param predicate Predicate function invoked per iteration.
+ */
+export function count(array: any[], predicate?: Predicate): number | null {
+    if (!Array.isArray(array)) return null;
+    if (!predicate || typeof predicate !== 'function') {
+        return array.length;
+    }
+    return array.filter(predicate).length;
+}
+
+/**
+ * Gets first item in array satisfies predicate.
+ * @param array The array to process.
+ * @param predicate Predicate function invoked per iteration.
+ */
+export function first<T = any>(array: T[], predicate?: Predicate): T | null {
+    if (!Array.isArray(array) || !array.length) return null;
+    if (!predicate) {
+        return array[0];
+    }
+    for (let i = 0; i < array.length; i++) {
+        if (predicate(array[i])) {
+            return array[i];
+        }
+    }
+    return null;
+}
+
+/**
+ * Gets last item in array satisfies predicate.
+ * @param array The array to process.
+ * @param predicate Predicate function invoked per iteration.
+ */
+export function last<T = any>(array: T[], predicate?: Predicate): T | undefined {
+    if (!Array.isArray(array) || !array.length) return;
+    let lastIndex = array.length - 1;
+    if (!predicate) {
+        return array[lastIndex];
+    }
+
+    for (; lastIndex >= 0; lastIndex--) {
+        if (predicate(array[lastIndex])) {
+            return array[lastIndex];
+        }
+    }
+}
+
+/**
+ * Gets counts map of values returned by `elementSelector`.
+ * @param array The array to process.
+ * @param elementSelector Function invoked per iteration.
+ */
+export function countBy(array: any[], elementSelector: Selector): { [key: string]: number } {
+    const results: { [key: string]: number } = {};
+    const length = array.length;
+
+    for (let i = 0; i < length; i++) {
+        const item = array[i];
+        const group = elementSelector(item);
+        results[group] = results[group] || 0;
+        results[group]++;
+    }
+
+    return results;
+}
+
+function fieldSelector(field?: string | Selector): Selector {
+    if (!field) {
+        return (item: any) => item;
+    }
+    return typeof field === 'function' ? field as Selector : (item: any) => item[String(field)];
+}
+
+function getNumberValuesArray(array: any[], elementSelector?: Selector): number[] {
+    return array.map(item => parseNumber(item, elementSelector)).filter(v => v !== undefined) as number[];
+}
\ No newline at end of file
diff --git a/src/array/transform.ts b/src/array/transform.ts
new file mode 100644
index 0000000..430d233
--- /dev/null
+++ b/src/array/transform.ts
@@ -0,0 +1,104 @@
+import { Selector } from "../types";
+import { fieldSelector } from "../_internals";
+import { avg, sum } from "./stats";
+
+/**
+ * Groups array items based on elementSelector function
+ * @param array The array to process.
+ * @param elementSelector Function invoked per iteration.
+ */
+export function groupBy(array: any[], groupByFields: string | string[] | Selector): any[] {
+    const groups: { [key: string]: any[] } = {};
+
+    const elementSelector = fieldSelector(groupByFields);
+
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        const group = elementSelector(item);
+        groups[group] = groups[group] || [];
+        groups[group].push(item);
+    }
+
+    return Object.values(groups);
+}
+
+/**
+ * Flattens array.
+ * @param array The array to flatten recursively.
+ * @example
+ * flatten([1, 4, [2, [5, 5, [9, 7]], 11], 0]); // length 9
+ */
+export function flatten(array: any[]): any[] {
+    let res: any = [];
+    const length = array.length;
+
+    for (let i = 0; i < length; i++) {
+        var value = array[i];
+        if (Array.isArray(value)) {
+            res = [...res, ...flatten(value)];
+        } else {
+            res.push(value);
+        }
+    }
+    return res;
+}
+
+/**
+ * Returns a reshaped array based on unique column values.
+ * @param array array to pivot
+ * @param rowFields row fields (or index fields). It can be one or more field names
+ * @param columnField a field which values will be used to create columns
+ * @param dataField a dataField which will be aggrated with aggregate function and groupped by rows and columns
+ * @param aggFunction an aggregation function. Default value is sum. data field will be aggregated by this function
+ * @param columnValues an optional initial column values. Use it to define a set of columns/values you would expect
+ */
+export function pivot(array: any, rowFields: string | string[],columnField: string, dataField: string,
+    aggFunction?: (array: number[]) => number | null, columnValues?: string[]): any[] {
+
+    const groups: { [key: string]: any[] } = Object.create(null);
+    columnValues = columnValues || [];
+    aggFunction = aggFunction || ((a: number[]) => sum(a));
+
+    const elementSelector = fieldSelector(rowFields);
+
+    rowFields = Array.isArray(rowFields) ? rowFields : [rowFields];
+
+    // group by rows
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        const group = elementSelector(item);
+        groups[group] = groups[group] || [];
+        groups[group].push(item);
+
+        // accumulate column values
+        const columnValue = item[columnField];
+        if (columnValues.indexOf(columnValue) < 0) {
+            columnValues.push(columnValue);
+        }
+    }
+
+    var result: any[] = [];
+    for (const groupName of Object.keys(groups)) {
+
+        const item = Object.create(null);
+        // row fields first
+        for (const rowField of rowFields) {
+            item[rowField] = groups[groupName][0][rowField];
+        }
+
+        // then aggregated data for each colum value
+        for (const columnValue of columnValues) {
+            const dataArray = groups[groupName]
+                .filter(r => r[columnField] === columnValue)
+                .map(r => r[dataField]);
+            item[columnValue] = aggFunction(dataArray);
+        }
+
+        result.push(item);
+    }
+
+    return result;
+
+    throw Error('Not Implemented');
+
+}
\ No newline at end of file
diff --git a/src/data-pipe.ts b/src/data-pipe.ts
index fe6f7b8..6287c26 100644
--- a/src/data-pipe.ts
+++ b/src/data-pipe.ts
@@ -1,23 +1,20 @@
 import { sum, avg, count, min, max, first, last, groupBy, flatten, countBy } from './array';
-import { Selector, Predicate } from './models';
-import { fromTable, toTable } from './table';
-import { ParsingOptions, parseCsv } from './dsv-parser';
-import { leftJoin, innerJoin, fullJoin, merge, FieldSelectorFunction } from './array-joins';
+import { Selector, Predicate, ParsingOptions } from './types';
+import { parseCsv, fromTable, toTable } from './utils';
+import { leftJoin, innerJoin, fullJoin, merge } from './array';
 
 
-export class DataPipe<T = any> {
-  private data: Array<T | any>;
+export class DataPipe {
+  private data: any[];
 
-  constructor(data: T[] = []) {
+  constructor(data: any[] = []) {
     this.data = data;
   }
 
-
-
   /**
    * Get pipes currrent array data.
    */
-  toArray(): T[] {
+  toArray(): any[] {
     return this.data;
   }
 
@@ -29,7 +26,7 @@ export class DataPipe<T = any> {
    *
    * dataPipe([{ val: 1 }, { val: 5 }]).sum(i => i.val); // 6
    */
-  sum(elementSelector?: Selector): number | undefined {
+  sum(elementSelector?: Selector): number | null {
     return sum(this.data, elementSelector);
   }
 
@@ -53,7 +50,7 @@ export class DataPipe<T = any> {
    * @example
    * dataPipe([1, 5, 3]).avg(); // 3
    */
-  avg(elementSelector?: Selector): number | undefined {
+  avg(elementSelector?: Selector): number | null {
     return avg(this.data, elementSelector);
   }
 
@@ -63,7 +60,7 @@ export class DataPipe<T = any> {
    * Count of elements in array.
    * @param predicate Predicate function invoked per iteration.
    */
-  count(predicate?: Predicate): number | undefined {
+  count(predicate?: Predicate): number | null {
     return count(this.data, predicate);
   }
 
@@ -71,7 +68,7 @@ export class DataPipe<T = any> {
    * Computes the minimum value of array.
    * @param elementSelector Function invoked per iteration.
    */
-  min(elementSelector?: Selector): number | Date | undefined {
+  min(elementSelector?: Selector): number | Date | null {
     return min(this.data, elementSelector);
   }
 
@@ -87,7 +84,7 @@ export class DataPipe<T = any> {
    * Gets first item in array satisfies predicate.
    * @param predicate Predicate function invoked per iteration.
    */
-  first(predicate?: Predicate): T | undefined {
+  first(predicate?: Predicate): any | undefined {
     return first(this.data, predicate);
   }
 
@@ -96,7 +93,7 @@ export class DataPipe<T = any> {
    * @param array The array to process.
    * @param predicate Predicate function invoked per iteration.
    */
-  last(predicate?: Predicate): T | undefined {
+  last(predicate?: Predicate): any | undefined {
     return last(this.data, predicate);
   }
 
@@ -114,7 +111,7 @@ export class DataPipe<T = any> {
    * @example
    * dataPipe([1, 4, [2, [5, 5, [9, 7]], 11], 0]).flatten(); // length 9
    */
-  flatten(): T[] {
+  flatten(): any[] {
     return flatten(this.data);
   }
 
@@ -134,8 +131,8 @@ export class DataPipe<T = any> {
    * @param resultSelector 
    */
   innerJoin(rightArray: any[],
-    leftKey: string | string[] | FieldSelectorFunction,
-    rightKey: string | string[] | FieldSelectorFunction,
+    leftKey: string | string[] | Selector<any, string>,
+    rightKey: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
   ): DataPipe {
     this.data = innerJoin(this.data, rightArray, leftKey, rightKey, resultSelector);
@@ -143,8 +140,8 @@ export class DataPipe<T = any> {
   }
 
   leftJoin(rightArray: any[],
-    leftKey: string | string[] | FieldSelectorFunction,
-    rightKey: string | string[] | FieldSelectorFunction,
+    leftKey: string | string[] | Selector<any, string>,
+    rightKey: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
   ): DataPipe {
 
@@ -153,8 +150,8 @@ export class DataPipe<T = any> {
   }
 
   fullJoin(rightArray: any[],
-    leftKey: string | string[] | FieldSelectorFunction,
-    rightKey: string | string[] | FieldSelectorFunction,
+    leftKey: string | string[] | Selector<any, string>,
+    rightKey: string | string[] | Selector<any, string>,
     resultSelector: (leftItem: any, rightItem: any) => any
   ): DataPipe {
     this.data = fullJoin(this.data, rightArray, leftKey, rightKey, resultSelector);
@@ -163,8 +160,8 @@ export class DataPipe<T = any> {
 
   merge(
     sourceArray: any[],
-    targetKey: string | string[] | FieldSelectorFunction,
-    sourceKey: string | string[] | FieldSelectorFunction
+    targetKey: string | string[] | Selector<any, string>,
+    sourceKey: string | string[] | Selector<any, string>
   ): DataPipe {
     this.data = merge(this.data, sourceArray, targetKey, sourceKey);
     return this;
diff --git a/src/examples/node-example.js b/src/examples/node-example.js
index ec33f2b..d7e7633 100644
--- a/src/examples/node-example.js
+++ b/src/examples/node-example.js
@@ -11,7 +11,7 @@ const summaryForUS = dataPipe(data)
   .groupBy(i => i.country)
   .select(g => {
     const r = {}
-    r.country = dataPipe(g).first().country
+    r.country = first(g).country
     r.names = dataPipe(g).map(r => r.name).join(", ")
     r.count = dataPipe(g).count()
     return r;
diff --git a/src/index.ts b/src/index.ts
index b9b04a4..91c9482 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,8 @@
 import { DataPipe } from "./data-pipe";
-export * from './utils-pipe';
+
+export * from './array'
+export * from './utils'
+export * from './string'
 
 /**
  * Data Pipeline factory function what creates DataPipe
@@ -8,6 +11,7 @@ export * from './utils-pipe';
  * @example
  * dataPipe([1, 2, 3])
  */
-export function dataPipe<T = any>(data?: T[]): DataPipe<T> {
-  return new DataPipe<T>(data);
+export function dataPipe(data?: any[]): DataPipe {
+  data = data || [];
+  return new DataPipe(data);
 }
diff --git a/src/models.ts b/src/models.ts
deleted file mode 100644
index 69b12d1..0000000
--- a/src/models.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export type Predicate<T=any> = (p: T) => boolean;
-export type Selector<T=any, V=any> = (p: T) => V;
diff --git a/src/string/index.ts b/src/string/index.ts
new file mode 100644
index 0000000..a4fa13b
--- /dev/null
+++ b/src/string/index.ts
@@ -0,0 +1 @@
+export * from './stringUtils'
\ No newline at end of file
diff --git a/src/string/stringUtils.ts b/src/string/stringUtils.ts
new file mode 100644
index 0000000..9f05309
--- /dev/null
+++ b/src/string/stringUtils.ts
@@ -0,0 +1,7 @@
+export function formatCamelStr(str: string = ''): string {
+    return str.replace(/^\w/, c => c.toUpperCase()).replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
+}
+
+export function replaceAll(text: string, searchValue: string, replaceValue: string = ''): string {
+    return text.replace(new RegExp(searchValue, 'g'), replaceValue || '');
+}
diff --git a/src/array.spec.ts b/src/tests/array.spec.ts
similarity index 57%
rename from src/array.spec.ts
rename to src/tests/array.spec.ts
index 2edc88d..b5da7fd 100644
--- a/src/array.spec.ts
+++ b/src/tests/array.spec.ts
@@ -1,5 +1,5 @@
-import * as pipeFuncs from './array';
-import { leftJoin } from './array-joins';
+import * as pipeFuncs from '../array'
+import { leftJoin, pivot, avg, sum } from '../array';
 
 export const data = [
   { name: "John", country: "US" }, { name: "Joe", country: "US" }, { name: "Bill", country: "US" }, { name: "Adam", country: "UK" },
@@ -39,7 +39,7 @@ describe('Test array methods', () => {
     expect(pipeFuncs.avg(testObjArray, obj => obj.value)).toBe(testNumberArrayAvg);
 
     const avg = pipeFuncs.avg(testAnyPrimitiveArray);
-    if (avg !== undefined) {
+    if (avg) {
       expect(Math.round(avg * 100) / 100).toBe(testAnyPrimitiveArrayAvg);
     } else {
       throw Error('testAnyPrimitiveArray failed');
@@ -114,4 +114,86 @@ describe('Test array methods', () => {
     expect(item.capital).toBe('Washington');
     expect(item.name).toBeTruthy();
   })
+
+  it('simple pivot', () => {
+    const arr = [
+      { product: 'P1', year: '2018', sale: '11' },
+      { product: 'P1', year: '2019', sale: '12' },
+      { product: 'P2', year: '2018', sale: '21' },
+      { product: 'P2', year: '2019', sale: '22' },
+    ];
+
+    const res = pivot(arr, 'product', 'year', 'sale')
+    expect(res.length).toBe(2);
+    expect(res.filter(r => r.product === 'P1')[0]['2018']).toBe(11);
+    expect(res.filter(r => r.product === 'P2')[0]['2018']).toBe(21);
+  })
+
+  it('pivot with default sum', () => {
+    const arr = [
+      { product: 'P1', year: '2018', sale: '11' },
+      { product: 'P1', year: '2019', sale: '12' },
+      { product: 'P1', year: '2019', sale: '22' },
+      { product: 'P2', year: '2018', sale: '21' },
+      { product: 'P2', year: '2019', sale: '22' },
+    ];
+
+    const res = pivot(arr, 'product', 'year', 'sale')
+    expect(res.length).toBe(2);
+    expect(res.filter(r => r.product === 'P1')[0]['2019']).toBe(34);
+    expect(res.filter(r => r.product === 'P2')[0]['2018']).toBe(21);
+  })
+
+  it('pivot with specified AVG', () => {
+    const arr = [
+      { product: 'P1', year: '2018', sale: '11' },
+      { product: 'P1', year: '2019', sale: '12' },
+      { product: 'P1', year: '2019', sale: '22' },
+      { product: 'P2', year: '2018', sale: '21' },
+      { product: 'P2', year: '2019', sale: '22' },
+    ];
+
+    const res = pivot(arr, 'product', 'year', 'sale', avg)
+    expect(res.length).toBe(2);
+    expect(res.filter(r => r.product === 'P1')[0]['2019']).toBe(17);
+    expect(res.filter(r => r.product === 'P2')[0]['2018']).toBe(21);
+  })
+
+
+  it('pivot with null value', () => {
+    const arr = [
+      { product: 'P1', year: '2018', sale: '11' },
+      { product: 'P1', year: '2019', sale: '12' },
+      { product: 'P1', year: '2019', sale: '22' },
+      { product: 'P2', year: '2018', sale: '21' },
+      { product: 'P2', year: '2019', sale: '22' },
+      { product: 'P3', year: '2019', sale: '33' },
+    ];
+
+    const res = pivot(arr, 'product', 'year', 'sale', avg)
+    expect(res.length).toBe(3);
+    expect(res.filter(r => r.product === 'P1')[0]['2019']).toBe(17);
+    expect(res.filter(r => r.product === 'P2')[0]['2018']).toBe(21);
+    expect(res.filter(r => r.product === 'P3')[0]['2019']).toBe(33);
+    expect(res.filter(r => r.product === 'P3')[0]['2018']).toBe(null);
+  })
+
+  it('pivot with null value with sum', () => {
+    const arr = [
+      { product: 'P1', year: '2018', sale: '11' },
+      { product: 'P1', year: '2019', sale: '12' },
+      { product: 'P1', year: '2019', sale: '22' },
+      { product: 'P2', year: '2018', sale: '21' },
+      { product: 'P2', year: '2019', sale: '22' },
+      { product: 'P3', year: '2019', sale: '33' },
+    ];
+
+    const res = pivot(arr, 'product', 'year', 'sale', sum)
+    expect(res.length).toBe(3);
+    expect(res.filter(r => r.product === 'P1')[0]['2019']).toBe(34);
+    expect(res.filter(r => r.product === 'P2')[0]['2018']).toBe(21);
+    expect(res.filter(r => r.product === 'P3')[0]['2019']).toBe(33);
+    expect(res.filter(r => r.product === 'P3')[0]['2018']).toBe(null);
+  })
+
 })
diff --git a/src/data-pipe.spec.ts b/src/tests/data-pipe.spec.ts
similarity index 93%
rename from src/data-pipe.spec.ts
rename to src/tests/data-pipe.spec.ts
index 8764eb0..56aaa3e 100644
--- a/src/data-pipe.spec.ts
+++ b/src/tests/data-pipe.spec.ts
@@ -1,7 +1,7 @@
-import { dataPipe } from './index';
-import { DataPipe } from './data-pipe';
-import { data } from './array.spec';
+import { dataPipe } from '../index';
 import { table } from './table.spec';
+import { data } from './array.spec';
+import { DataPipe } from '../data-pipe';
 
 describe('DataPipe specification', () => {
   it('dataPipe returns DataPipe', () => {
diff --git a/src/dsv-parser.spec.ts b/src/tests/dsv-parser.spec.ts
similarity index 97%
rename from src/dsv-parser.spec.ts
rename to src/tests/dsv-parser.spec.ts
index 3309207..4f8d1c3 100644
--- a/src/dsv-parser.spec.ts
+++ b/src/tests/dsv-parser.spec.ts
@@ -1,5 +1,6 @@
-import { dataPipe } from './index';
-import { ParsingOptions, parseCsv, toCsv } from './dsv-parser';
+
+import { parseCsv, toCsv } from '../utils';
+import { ParsingOptions } from '../types';
 
 describe('Dsv Parser specification', () => {
   it('simple numbers', () => {
diff --git a/src/table.spec.ts b/src/tests/table.spec.ts
similarity index 95%
rename from src/table.spec.ts
rename to src/tests/table.spec.ts
index f0a9531..b6ee7cc 100644
--- a/src/table.spec.ts
+++ b/src/tests/table.spec.ts
@@ -1,5 +1,6 @@
+
 import { data } from "./array.spec";
-import { toTable, fromTable } from "./table";
+import { fromTable, toTable } from "../utils";
 
 export const table = {
   fields: ['name', 'country'],
diff --git a/src/tests/utils-pipe.spec.ts b/src/tests/utils-pipe.spec.ts
new file mode 100644
index 0000000..35e5615
--- /dev/null
+++ b/src/tests/utils-pipe.spec.ts
@@ -0,0 +1,26 @@
+import { parseDatetimeOrNull, parseNumberOrNull } from "../utils";
+
+
+describe('Test dataUtils', () => {
+  it('parseDate', () => {
+    expect(parseDatetimeOrNull('')).toBe(null);
+    expect(parseDatetimeOrNull('10-1010')).toBe(null);
+    let date = parseDatetimeOrNull('1111');
+    if (date) {
+      expect(date.getFullYear()).toBe(1970);
+    }
+    date = parseDatetimeOrNull('10-10-10');
+    expect(date).toBeInstanceOf(Date);
+    if (date) {
+      expect(date.getMonth()).toBe(9);
+    }
+  })
+
+  it('parseNumber', () => {
+    expect(parseNumberOrNull('')).toBe(null);
+    expect(parseNumberOrNull('11')).toBe(11);
+    expect(parseNumberOrNull('11.1')).toBe(11.1);
+    expect(parseNumberOrNull(11.1)).toBe(11.1);
+    expect(parseNumberOrNull(NaN)).toBe(NaN);
+  })
+})
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..8750dd5
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,13 @@
+export type Predicate<T = any> = (p: T) => boolean;
+export type Selector<T = any, V = any> = (p: T) => V;
+export class ParsingOptions {
+    delimiter: string = ',';
+    skipRows: number = 0;
+    dateFields: string[] = [];
+    numberFields: string[] = [];
+    booleanFields: string[] = [];
+    skipUntil?: (tokens: string[]) => boolean;
+    takeWhile?: (tokens: string[]) => boolean;
+    parseFields?: {};
+    elementSelector?: (headers: string[], tokens: string[]) => any;
+}
\ No newline at end of file
diff --git a/src/utils-pipe.spec.ts b/src/utils-pipe.spec.ts
deleted file mode 100644
index 4e40663..0000000
--- a/src/utils-pipe.spec.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { utils } from './utils-pipe';
-
-describe('Test dataUtils', () => {
-  it('parseDate', () => {
-    expect(utils().parseDate('')).toBe(null);
-    expect(utils().parseDate('10-1010')).toBe(null);
-    expect(utils().parseDate(null)).toBe(null);
-    let date = utils().parseDate(1111);
-    if (date) {
-      expect(date.getFullYear()).toBe(1970);
-    }
-    date = utils().parseDate('10-10-10');
-    expect(date).toBeInstanceOf(Date);
-    if (date) {
-      expect(date.getMonth()).toBe(9);
-    }
-  })
-
-  it('parseNumber', () => {
-    expect(utils().parseNumber('')).toBe(null);
-    expect(utils().parseNumber('11')).toBe(11);
-    expect(utils().parseNumber('11.1')).toBe(11.1);
-    expect(utils().parseNumber(11.1)).toBe(11.1);
-    expect(utils().parseNumber(NaN)).toBe(NaN);
-  })
-})
diff --git a/src/utils-pipe.ts b/src/utils-pipe.ts
deleted file mode 100644
index 83fb5c2..0000000
--- a/src/utils-pipe.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import {
-  parseDatetimeOrNull, deepClone,
-  dateToString, formatCamelStr, parseNumberOrNull
-} from "./utils";
-
-/**
- * DataUtils
- *
- * @example
- * dataUtils().parseData("10-03-2019") // Date
- */
-export function utils() {
-  return {
-    parseDate(date: any): Date | null {
-      return parseDatetimeOrNull(date);
-    },
-    dateToString,
-    parseNumber(str: string | number): number | null {
-      return parseNumberOrNull(str)
-    },
-    deepClone,
-    formatCamelStr
-  }
-}
diff --git a/src/dsv-parser.ts b/src/utils/dsv-parser.ts
similarity index 92%
rename from src/dsv-parser.ts
rename to src/utils/dsv-parser.ts
index f2846ef..e66e831 100644
--- a/src/dsv-parser.ts
+++ b/src/utils/dsv-parser.ts
@@ -1,16 +1,5 @@
 import { parseNumberOrNull, parseDatetimeOrNull } from "./utils";
-
-export class ParsingOptions {
-    delimiter: string = ',';
-    skipRows: number = 0;
-    dateFields: string[] = [];
-    numberFields: string[] = [];
-    booleanFields: string[] = [];
-    skipUntil?: (tokens: string[]) => boolean;
-    takeWhile?: (tokens: string[]) => boolean;
-    parseFields?: {};
-    elementSelector?: (headers: string[], tokens: string[]) => any;
-}
+import { ParsingOptions } from "../types";
 
 export function parseCsv(content: string, options?: ParsingOptions): any[] {
     const result: any[] = [];
diff --git a/src/utils/index.ts b/src/utils/index.ts
new file mode 100644
index 0000000..eb6e38e
--- /dev/null
+++ b/src/utils/index.ts
@@ -0,0 +1,3 @@
+export * from './dsv-parser'
+export * from './utils'
+export * from './table'
diff --git a/src/table.ts b/src/utils/table.ts
similarity index 100%
rename from src/table.ts
rename to src/utils/table.ts
diff --git a/src/utils.ts b/src/utils/utils.ts
similarity index 89%
rename from src/utils.ts
rename to src/utils/utils.ts
index a78f65e..c00d371 100644
--- a/src/utils.ts
+++ b/src/utils/utils.ts
@@ -1,14 +1,5 @@
-import { Selector } from "./models";
+import { Selector } from "../types";
 
-/**
- * Get selector number values.
- * @param array The array to process.
- * @param elementSelector Function invoked per iteration.
- * @private
- */
-export function getNumberValuesArray(array: any[], elementSelector?: Selector): number[] {
-  return array.map(item => parseNumber(item, elementSelector)).filter(v => v !== undefined) as number[];
-}
 
 /**
  * Formats selected value to number.
@@ -175,6 +166,3 @@ export function deepClone(obj: any): any {
   return obj;
 }
 
-export function formatCamelStr(str: string = ''): string {
-  return str.replace(/^\w/, c => c.toUpperCase()).replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/_/g, ' ');
-}
diff --git a/tsconfig.json b/tsconfig.json
index ffe5302..c6ed90a 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -75,6 +75,10 @@
     "out": "docs",
     "excludeExternals": true,
     "exclude": "**/*+(index|.spec|.e2e).ts",
-    "readme": "README.md"
+    "excludeNotExported": false,
+    "readme": "README.md",
+    "toc": [
+      "data-pipe"
+    ]
   }
 }