Travis build: 391

snippets/JSONToDate.md

@@ -12,5 +12,5 @@ const JSONToDate = arr => {
 ```
 
 ```js
-JSONToDate(/Date(1489525200000)/) // "14/3/2017"
+JSONToDate(/Date(1489525200000)/); // "14/3/2017"
 ```

snippets/JSONToFile.md

@@ -6,9 +6,10 @@ Use `fs.writeFile()`, template literals and `JSON.stringify()` to write a `json`
 
 ```js
 const fs = require('fs');
-const JSONToFile = (obj, filename) => fs.writeFile(`${filename}.json`, JSON.stringify(obj, null, 2));
+const JSONToFile = (obj, filename) =>
+  fs.writeFile(`${filename}.json`, JSON.stringify(obj, null, 2));
 ```
 
 ```js
-JSONToFile({test: "is passed"}, 'testJsonFile') // writes the object to 'testJsonFile.json'
+JSONToFile({ test: 'is passed' }, 'testJsonFile'); // writes the object to 'testJsonFile.json'
 ```

snippets/RGBToHex.md

@@ -9,5 +9,5 @@ const RGBToHex = (r, g, b) => ((r << 16) + (g << 8) + b).toString(16).padStart(6
 ```
 
 ```js
-RGBToHex(255, 165, 1) // 'ffa501'
+RGBToHex(255, 165, 1); // 'ffa501'
 ```

snippets/UUIDGenerator.md

@@ -7,10 +7,10 @@ Use `crypto` API to generate a UUID, compliant with [RFC4122](https://www.ietf.o
 ```js
 const UUIDGenerator = () =>
   ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c =>
-    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+    (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16)
   );
 ```
 
 ```js
-UUIDGenerator() // '7982fcfe-5721-4632-bede-6000885be57d'
+UUIDGenerator(); // '7982fcfe-5721-4632-bede-6000885be57d'
 ```

snippets/anagrams.md

@@ -10,11 +10,16 @@ Base cases are for string `length` equal to `2` or `1`.
 ```js
 const anagrams = str => {
   if (str.length <= 2) return str.length === 2 ? [str, str[1] + str[0]] : [str];
-  return str.split('').reduce((acc, letter, i) =>
-    acc.concat(anagrams(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val)), []);
+  return str
+    .split('')
+    .reduce(
+      (acc, letter, i) =>
+        acc.concat(anagrams(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val)),
+      []
+    );
 };
 ```
 
 ```js
-anagrams('abc') // ['abc','acb','bac','bca','cab','cba']
+anagrams('abc'); // ['abc','acb','bac','bca','cab','cba']
 ```

snippets/arrayAverage.md

@@ -9,5 +9,5 @@ const arrayAverage = arr => arr.reduce((acc, val) => acc + val, 0) / arr.length;
 ```
 
 ```js
-arrayAverage([1,2,3]) // 2
+arrayAverage([1, 2, 3]); // 2
 ```

snippets/arrayGcd.md

@@ -6,12 +6,12 @@ Use `Array.reduce()` and the `gcd` formula (uses recursion) to calculate the gre
 
 ```js
 const arrayGcd = arr => {
-  const gcd = (x, y) => !y ? x : gcd(y, x % y);
+  const gcd = (x, y) => (!y ? x : gcd(y, x % y));
   return arr.reduce((a, b) => gcd(a, b));
 };
 ```
 
 ```js
-arrayGcd([1,2,3,4,5]) // 1
-arrayGcd([4,8,12]) // 4
+arrayGcd([1, 2, 3, 4, 5]); // 1
+arrayGcd([4, 8, 12]); // 4
 ```

snippets/arrayLcm.md

@@ -6,13 +6,13 @@ Use `Array.reduce()` and the `lcm` formula (uses recursion) to calculate the low
 
 ```js
 const arrayLcm = arr => {
-  const gcd = (x, y) => !y ? x : gcd(y, x % y);
-  const lcm = (x, y) => (x * y) / gcd(x, y);
+  const gcd = (x, y) => (!y ? x : gcd(y, x % y));
+  const lcm = (x, y) => x * y / gcd(x, y);
   return arr.reduce((a, b) => lcm(a, b));
 };
 ```
 
 ```js
-arrayLcm([1,2,3,4,5]) // 60
-arrayLcm([4,8,12]) // 24
+arrayLcm([1, 2, 3, 4, 5]); // 60
+arrayLcm([4, 8, 12]); // 24
 ```

snippets/arrayMax.md

@@ -9,5 +9,5 @@ const arrayMax = arr => Math.max(...arr);
 ```
 
 ```js
-arrayMax([10, 1, 5]) // 10
+arrayMax([10, 1, 5]); // 10
 ```

snippets/arrayMin.md

@@ -9,5 +9,5 @@ const arrayMin = arr => Math.min(...arr);
 ```
 
 ```js
-arrayMin([10, 1, 5]) // 1
+arrayMin([10, 1, 5]); // 1
 ```

snippets/arraySum.md

@@ -9,5 +9,5 @@ const arraySum = arr => arr.reduce((acc, val) => acc + val, 0);
 ```
 
 ```js
-arraySum([1,2,3,4]) // 10
+arraySum([1, 2, 3, 4]); // 10
 ```

snippets/arrayToHtmlList.md

@@ -5,9 +5,10 @@ Converts the given array elements into `<li>` tags and appends them to the list
 Use `Array.map()` and `document.querySelector()` to create a list of html tags.
 
 ```js
-const arrayToHtmlList = (arr, listID) => arr.map(item => document.querySelector('#' + listID).innerHTML += `<li>${item}</li>`);
+const arrayToHtmlList = (arr, listID) =>
+  arr.map(item => (document.querySelector('#' + listID).innerHTML += `<li>${item}</li>`));
 ```
 
 ```js
-arrayToHtmlList(['item 1', 'item 2'],'myListID')
+arrayToHtmlList(['item 1', 'item 2'], 'myListID');
 ```

snippets/bottomVisible.md

@@ -6,9 +6,10 @@ Use `scrollY`, `scrollHeight` and `clientHeight` to determine if the bottom of t
 
 ```js
 const bottomVisible = () =>
-  document.documentElement.clientHeight + window.scrollY >= (document.documentElement.scrollHeight || document.documentElement.clientHeight);
+  document.documentElement.clientHeight + window.scrollY >=
+  (document.documentElement.scrollHeight || document.documentElement.clientHeight);
 ```
 
 ```js
-bottomVisible() // true
+bottomVisible(); // true
 ```

snippets/call.md

@@ -4,12 +4,16 @@ Given a key and a set of arguments, call them when given a context. Primarily us
 
 Use a closure to call a stored key with stored arguments.
 
-```js
-const call = (key, ...args) => context => context[ key ](...args);
+```js
+const call = (key, ...args) => context => context[key](...args);
 ```
 
-```js
-Promise.resolve( [ 1, 2, 3 ] ).then( call('map', x => 2 * x ) ).then( console.log ) //[ 2, 4, 6 ]
-const map = call.bind(null, 'map')
-Promise.resolve( [ 1, 2, 3 ] ).then( map( x => 2 * x ) ).then( console.log ) //[ 2, 4, 6 ]
+```js
+Promise.resolve([1, 2, 3])
+  .then(call('map', x => 2 * x))
+  .then(console.log); //[ 2, 4, 6 ]
+const map = call.bind(null, 'map');
+Promise.resolve([1, 2, 3])
+  .then(map(x => 2 * x))
+  .then(console.log); //[ 2, 4, 6 ]
 ```

snippets/capitalize.md

@@ -11,6 +11,6 @@ const capitalize = ([first, ...rest], lowerRest = false) =>
 ```
 
 ```js
-capitalize('fooBar') // 'FooBar'
-capitalize('fooBar', true) // 'Foobar'
+capitalize('fooBar'); // 'FooBar'
+capitalize('fooBar', true); // 'Foobar'
 ```

snippets/capitalizeEveryWord.md

@@ -9,5 +9,5 @@ const capitalizeEveryWord = str => str.replace(/\b[a-z]/g, char => char.toUpperC
 ```
 
 ```js
-capitalizeEveryWord('hello world!') // 'Hello World!'
+capitalizeEveryWord('hello world!'); // 'Hello World!'
 ```

snippets/chainAsync.md

@@ -5,13 +5,25 @@ Chains asynchronous functions.
 Loop through an array of functions containing asynchronous events, calling `next` when each asynchronous event has completed.
 
 ```js
-const chainAsync = fns => { let curr = 0; const next = () => fns[curr++](next); next(); };
+const chainAsync = fns => {
+  let curr = 0;
+  const next = () => fns[curr++](next);
+  next();
+};
 ```
 
 ```js
 chainAsync([
-  next => { console.log('0 seconds'); setTimeout(next, 1000); },
-  next => { console.log('1 second');  setTimeout(next, 1000); },
-  next => { console.log('2 seconds'); }
-])
+  next => {
+    console.log('0 seconds');
+    setTimeout(next, 1000);
+  },
+  next => {
+    console.log('1 second');
+    setTimeout(next, 1000);
+  },
+  next => {
+    console.log('2 seconds');
+  }
+]);
 ```

snippets/chunk.md

@@ -8,9 +8,11 @@ If the original array can't be split evenly, the final chunk will contain the re
 
 ```js
 const chunk = (arr, size) =>
-  Array.from({length: Math.ceil(arr.length / size)}, (v, i) => arr.slice(i * size, i * size + size));
+  Array.from({ length: Math.ceil(arr.length / size) }, (v, i) =>
+    arr.slice(i * size, i * size + size)
+  );
 ```
 
 ```js
-chunk([1,2,3,4,5], 2) // [[1,2],[3,4],[5]]
+chunk([1, 2, 3, 4, 5], 2); // [[1,2],[3,4],[5]]
 ```

snippets/clampNumber.md

@@ -10,7 +10,7 @@ const clampNumber = (num, a, b) => Math.max(Math.min(num, Math.max(a, b)), Math.
 ```
 
 ```js
-clampNumber(2, 3, 5) // 3
-clampNumber(1, -1, -5) // -1
-clampNumber(3, 2, 4) // 3
+clampNumber(2, 3, 5); // 3
+clampNumber(1, -1, -5); // -1
+clampNumber(3, 2, 4); // 3
 ```

snippets/cleanObj.md

@@ -13,12 +13,12 @@ const cleanObj = (obj, keysToKeep = [], childIndicator) => {
     } else if (!keysToKeep.includes(key)) {
       delete obj[key];
     }
-   });
+  });
   return obj;
 };
 ```
 
 ```js
-const testObj = {a: 1, b: 2, children: {a: 1, b: 2}}
-cleanObj(testObj, ["a"],"children") // { a: 1, children : { a: 1}}
+const testObj = { a: 1, b: 2, children: { a: 1, b: 2 } };
+cleanObj(testObj, ['a'], 'children'); // { a: 1, children : { a: 1}}
 ```

snippets/coalesce.md

@@ -9,5 +9,5 @@ const coalesce = (...args) => args.find(_ => ![undefined, null].includes(_));
 ```
 
 ```js
-coalesce(null,undefined,"",NaN, "Waldo") // ""
+coalesce(null, undefined, '', NaN, 'Waldo'); // ""
 ```

snippets/coalesceFactory.md

@@ -9,6 +9,6 @@ const coalesceFactory = valid => (...args) => args.find(valid);
 ```
 
 ```js
-const customCoalesce = coalesceFactory(_ => ![null, undefined, "", NaN].includes(_))
-customCoalesce(undefined, null, NaN, "", "Waldo") // "Waldo"
+const customCoalesce = coalesceFactory(_ => ![null, undefined, '', NaN].includes(_));
+customCoalesce(undefined, null, NaN, '', 'Waldo'); // "Waldo"
 ```

snippets/collatz.md

@@ -5,10 +5,10 @@ Applies the Collatz algorithm.
 If `n` is even, return `n/2`. Otherwise, return `3n+1`.
 
 ```js
-const collatz = n => (n % 2 == 0) ? (n / 2) : (3 * n + 1);
+const collatz = n => (n % 2 == 0 ? n / 2 : 3 * n + 1);
 ```
 
 ```js
-collatz(8) // 4
-collatz(5) // 16
+collatz(8); // 4
+collatz(5); // 16
 ```

snippets/collectInto.md

@@ -4,14 +4,14 @@ Changes a function that accepts an array into a variadic function.
 
 Given a function, return a closure that collects all inputs into an array-accepting function.
 
-```js
+```js
 const collectInto = fn => (...args) => fn(args);
 ```
 
-```js
-const Pall = collectInto( Promise.all.bind(Promise) )
-let p1 = Promise.resolve(1)
-let p2 = Promise.resolve(2)
-let p3 = new Promise((resolve) => setTimeout(resolve,2000,3))
-Pall(p1, p2, p3).then(console.log)
+```js
+const Pall = collectInto(Promise.all.bind(Promise));
+let p1 = Promise.resolve(1);
+let p2 = Promise.resolve(2);
+let p3 = new Promise(resolve => setTimeout(resolve, 2000, 3));
+Pall(p1, p2, p3).then(console.log);
 ```

snippets/compact.md

@@ -9,5 +9,5 @@ const compact = arr => arr.filter(Boolean);
 ```
 
 ```js
-compact([0, 1, false, 2, '', 3, 'a', 'e'*23, NaN, 's', 34]) // [ 1, 2, 3, 'a', 's', 34 ]
+compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34]); // [ 1, 2, 3, 'a', 's', 34 ]
 ```

snippets/compose.md

@@ -10,8 +10,8 @@ const compose = (...fns) => fns.reduce((f, g) => (...args) => f(g(...args)));
 ```
 
 ```js
-const add5 = x => x + 5
-const multiply = (x, y) => x * y
-const multiplyAndAdd5 = compose(add5, multiply)
-multiplyAndAdd5(5, 2) // 15
+const add5 = x => x + 5;
+const multiply = (x, y) => x * y;
+const multiplyAndAdd5 = compose(add5, multiply);
+multiplyAndAdd5(5, 2); // 15
 ```

snippets/countOccurrences.md

@@ -5,9 +5,9 @@ Counts the occurrences of a value in an array.
 Use `Array.reduce()` to increment a counter each time you encounter the specific value inside the array.
 
 ```js
-const countOccurrences = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);
+const countOccurrences = (arr, value) => arr.reduce((a, v) => (v === value ? a + 1 : a + 0), 0);
 ```
 
 ```js
-countOccurrences([1,1,2,1,2,3], 1) // 3
+countOccurrences([1, 1, 2, 1, 2, 3], 1); // 3
 ```

snippets/countVowels.md

@@ -5,10 +5,10 @@ Retuns `number` of vowels in provided string.
 Use a regular expression to count the number of vowels `(A, E, I, O, U)` in a `string`.
 
 ```js
-const countVowels = str => (str.match(/[aeiou]/ig) || []).length;
+const countVowels = str => (str.match(/[aeiou]/gi) || []).length;
 ```
 
 ```js
-countVowels('foobar') // 3
-countVowels('gym') // 0
+countVowels('foobar'); // 3
+countVowels('gym'); // 0
 ```

snippets/currentURL.md

@@ -9,5 +9,5 @@ const currentURL = () => window.location.href;
 ```
 
 ```js
-currentURL() // 'https://google.com'
+currentURL(); // 'https://google.com'
 ```

snippets/curry.md

@@ -9,12 +9,10 @@ If you want to curry a function that accepts a variable number of arguments (a v
 
 ```js
 const curry = (fn, arity = fn.length, ...args) =>
-  arity <= args.length
-    ? fn(...args)
-    : curry.bind(null, fn, arity, ...args);
+  arity <= args.length ? fn(...args) : curry.bind(null, fn, arity, ...args);
 ```
 
 ```js
-curry(Math.pow)(2)(10) // 1024
-curry(Math.min, 3)(10)(50)(2) // 2
+curry(Math.pow)(2)(10); // 1024
+curry(Math.min, 3)(10)(50)(2); // 2
 ```

snippets/deepFlatten.md

@@ -7,9 +7,9 @@ Use `Array.concat()` with an empty array (`[]`) and the spread operator (`...`)
 Recursively flatten each element that is an array.
 
 ```js
-const deepFlatten = arr => [].concat(...arr.map(v => Array.isArray(v) ? deepFlatten(v) : v));
+const deepFlatten = arr => [].concat(...arr.map(v => (Array.isArray(v) ? deepFlatten(v) : v)));
 ```
 
 ```js
-deepFlatten([1,[2],[[3],4],5]) // [1,2,3,4,5]
+deepFlatten([1, [2], [[3], 4], 5]); // [1,2,3,4,5]
 ```

snippets/detectDeviceType.md

@@ -5,10 +5,13 @@ Detects wether the website is being opened in a mobile device or a desktop/lapto
 Use a regular expression to test the `navigator.userAgent` property to figure out if the device is a mobile device or a desktop/laptop.
 
 ```js
-const detectDeviceType = () => /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ? 'Mobile' : 'Desktop';
+const detectDeviceType = () =>
+  /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)
+    ? 'Mobile'
+    : 'Desktop';
 ```
 
 ```js
-detectDeviceType() // "Mobile"
-detectDeviceType() // "Desktop"
+detectDeviceType(); // "Mobile"
+detectDeviceType(); // "Desktop"
 ```

snippets/difference.md

@@ -5,9 +5,12 @@ Returns the difference between two arrays.
 Create a `Set` from `b`, then use `Array.filter()` on `a` to only keep values not contained in `b`.
 
 ```js
-const difference = (a, b) => { const s = new Set(b); return a.filter(x => !s.has(x)); };
+const difference = (a, b) => {
+  const s = new Set(b);
+  return a.filter(x => !s.has(x));
+};
 ```
 
 ```js
-difference([1,2,3], [1,2,4]) // [3]
+difference([1, 2, 3], [1, 2, 4]); // [3]
 ```

snippets/differenceWith.md

@@ -9,5 +9,5 @@ const differenceWith = (arr, val, comp) => arr.filter(a => !val.find(b => comp(a
 ```
 
 ```js
-differenceWith([1, 1.2, 1.5, 3], [1.9, 3], (a,b) => Math.round(a) == Math.round(b)) // [1, 1.2]
+differenceWith([1, 1.2, 1.5, 3], [1.9, 3], (a, b) => Math.round(a) == Math.round(b)); // [1, 1.2]
 ```

snippets/digitize.md

@@ -6,9 +6,9 @@ Convert the number to a string, using spread operators in ES6(`[...string]`) bui
 Use `Array.map()` and `parseInt()` to transform each value to an integer.
 
 ```js
-const digitize = n => [...'' + n].map(i => parseInt(i));
+const digitize = n => [...('' + n)].map(i => parseInt(i));
 ```
 
 ```js
-digitize(123) // [1, 2, 3]
+digitize(123); // [1, 2, 3]
 ```

snippets/distance.md

@@ -9,5 +9,5 @@ const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);
 ```
 
 ```js
-distance(1,1, 2,3) // 2.23606797749979
+distance(1, 1, 2, 3); // 2.23606797749979
 ```

snippets/distinctValuesOfArray.md

@@ -9,5 +9,5 @@ const distinctValuesOfArray = arr => [...new Set(arr)];
 ```
 
 ```js
-distinctValuesOfArray([1,2,2,3,4,4,5]) // [1,2,3,4,5]
+distinctValuesOfArray([1, 2, 2, 3, 4, 4, 5]); // [1,2,3,4,5]
 ```

snippets/dropElements.md

@@ -13,5 +13,5 @@ const dropElements = (arr, func) => {
 ```
 
 ```js
-dropElements([1, 2, 3, 4], n => n >= 3) // [3,4]
+dropElements([1, 2, 3, 4], n => n >= 3); // [3,4]
 ```

snippets/dropRight.md

@@ -9,7 +9,7 @@ const dropRight = (arr, n = 1) => arr.slice(0, -n);
 ```
 
 ```js
-dropRight([1,2,3]) // [1,2]
-dropRight([1,2,3], 2) // [1]
-dropRight([1,2,3], 42) // []
+dropRight([1, 2, 3]); // [1,2]
+dropRight([1, 2, 3], 2); // [1]
+dropRight([1, 2, 3], 42); // []
 ```

snippets/elementIsVisibleInViewport.md

@@ -13,13 +13,13 @@ const elementIsVisibleInViewport = (el, partiallyVisible = false) => {
   const { innerHeight, innerWidth } = window;
   return partiallyVisible
     ? ((top > 0 && top < innerHeight) || (bottom > 0 && bottom < innerHeight)) &&
-      ((left > 0 && left < innerWidth) || (right > 0 && right < innerWidth))
+        ((left > 0 && left < innerWidth) || (right > 0 && right < innerWidth))
     : top >= 0 && left >= 0 && bottom <= innerHeight && right <= innerWidth;
 };
 ```
 
 ```js
 // e.g. 100x100 viewport and a 10x10px element at position {top: -1, left: 0, bottom: 9, right: 10}
-elementIsVisibleInViewport(el) // false // (not fully visible)
-elementIsVisibleInViewport(el, true) // true // (partially visible)
+elementIsVisibleInViewport(el); // false // (not fully visible)
+elementIsVisibleInViewport(el, true); // true // (partially visible)
 ```

snippets/escapeRegExp.md

@@ -9,5 +9,5 @@ const escapeRegExp = str => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 ```
 
 ```js
-escapeRegExp('(test)') // \\(test\\)
+escapeRegExp('(test)'); // \\(test\\)
 ```

snippets/everyNth.md

@@ -9,5 +9,5 @@ const everyNth = (arr, nth) => arr.filter((e, i) => i % nth === nth - 1);
 ```
 
 ```js
-everyNth([1,2,3,4,5,6], 2) // [ 2, 4, 6 ]
+everyNth([1, 2, 3, 4, 5, 6], 2); // [ 2, 4, 6 ]
 ```

snippets/extendHex.md

@@ -6,10 +6,15 @@ Use `Array.map()`, `split()` and `Array.join()` to join the mapped array for con
 `String.slice()` is used to remove `#` from string start since it's added once.
 ```js
 const extendHex = shortHex =>
-  '#' + shortHex.slice(shortHex.startsWith('#') ? 1 : 0).split('').map(x => x + x).join('');
+  '#' +
+  shortHex
+    .slice(shortHex.startsWith('#') ? 1 : 0)
+    .split('')
+    .map(x => x + x)
+    .join('');
 ```
 
 ```js
-extendHex('#03f') // '#0033ff'
-extendHex('05a') // '#0055aa'
+extendHex('#03f'); // '#0033ff'
+extendHex('05a'); // '#0055aa'
 ```

snippets/factorial.md

@@ -9,10 +9,13 @@ Throws an exception if `n` is a negative number.
 
 ```js
 const factorial = n =>
-  n < 0 ? (() => { throw new TypeError('Negative numbers are not allowed!'); })()
-  : n <= 1 ? 1 : n * factorial(n - 1);
+  n < 0
+    ? (() => {
+        throw new TypeError('Negative numbers are not allowed!');
+      })()
+    : n <= 1 ? 1 : n * factorial(n - 1);
 ```
 
 ```js
-factorial(6) // 720
+factorial(6); // 720
 ```

snippets/fibonacci.md

@@ -7,9 +7,12 @@ Use `Array.reduce()` to add values into the array, using the sum of the last two
 
 ```js
 const fibonacci = n =>
-  Array.from({ length: n}).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []);
+  Array.from({ length: n }).reduce(
+    (acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i),
+    []
+  );
 ```
 
 ```js
-fibonacci(6) // 720
+fibonacci(6); // 720
 ```

snippets/fibonacciCountUntilNum.md

@@ -10,5 +10,5 @@ const fibonacciCountUntilNum = num =>
 ```
 
 ```js
-fibonacciCountUntilNum(10) // 7
+fibonacciCountUntilNum(10); // 7
 ```

snippets/fibonacciUntilNum.md

@@ -9,10 +9,13 @@ Uses a mathematical formula to calculate the length of the array required.
 ```js
 const fibonacciUntilNum = num => {
   let n = Math.ceil(Math.log(num * Math.sqrt(5) + 1 / 2) / Math.log((Math.sqrt(5) + 1) / 2));
-  return Array.from({ length: n}).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []);
+  return Array.from({ length: n }).reduce(
+    (acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i),
+    []
+  );
 };
 ```
 
 ```js
-fibonacciCountUntilNum(10) // 7
+fibonacciCountUntilNum(10); // 7
 ```

snippets/filterNonUnique.md

@@ -9,5 +9,5 @@ const filterNonUnique = arr => arr.filter(i => arr.indexOf(i) === arr.lastIndexO
 ```
 
 ```js
-filterNonUnique([1,2,2,3,4,4,5]) // [1,3,5]
+filterNonUnique([1, 2, 2, 3, 4, 4, 5]); // [1,3,5]
 ```

snippets/flatten.md

@@ -5,9 +5,9 @@ Flattens an array.
 Use a new array and concatenate it with the spread input array causing a shallow denesting of any contained arrays.
 
 ```js
-const flatten = arr => [ ].concat(...arr);
+const flatten = arr => [].concat(...arr);
 ```
 
 ```js
-flatten([1,[2],3,4]) // [1,2,3,4]
+flatten([1, [2], 3, 4]); // [1,2,3,4]
 ```

snippets/flattenDepth.md

@@ -9,10 +9,11 @@ Omit the second element, `depth` to flatten only to a depth of `1` (single flatt
 
 ```js
 const flattenDepth = (arr, depth = 1) =>
-  depth != 1 ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v), [])
-  : arr.reduce((a, v) => a.concat(v), []);
+  depth != 1
+    ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v), [])
+    : arr.reduce((a, v) => a.concat(v), []);
 ```
 
 ```js
-flattenDepth([1,[2],3,4]) // [1,2,3,4]
+flattenDepth([1, [2], 3, 4]); // [1,2,3,4]
 ```

snippets/flip.md

@@ -4,16 +4,16 @@ Flip takes a function as an argument, then makes the first argument the last
 
 Return a closure that takes variadic inputs, and splices the last argument to make it the first argument before applying the rest.
 
-```js
+```js
 const flip = fn => (...args) => fn(args.pop(), ...args);
 ```
 
-```js
-let a = {name: 'John Smith'}
-let b = {}
-const mergeFrom = flip(Object.assign)
-let mergePerson = mergeFrom.bind(null, a)
-mergePerson(b) // == b
-b = {}
-Object.assign(b, a) // == b
+```js
+let a = { name: 'John Smith' };
+let b = {};
+const mergeFrom = flip(Object.assign);
+let mergePerson = mergeFrom.bind(null, a);
+mergePerson(b); // == b
+b = {};
+Object.assign(b, a); // == b
 ```

snippets/fromCamelCase.md

@@ -7,12 +7,14 @@ Omit the second argument to use a default separator of `_`.
 
 ```js
 const fromCamelCase = (str, separator = '_') =>
-  str.replace(/([a-z\d])([A-Z])/g, '$1' + separator + '$2')
-    .replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + separator + '$2').toLowerCase();
+  str
+    .replace(/([a-z\d])([A-Z])/g, '$1' + separator + '$2')
+    .replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + separator + '$2')
+    .toLowerCase();
 ```
 
 ```js
-fromCamelCase('someDatabaseFieldName', ' ') // 'some database field name'
-fromCamelCase('someLabelThatNeedsToBeCamelized', '-') // 'some-label-that-needs-to-be-camelized'
-fromCamelCase('someJavascriptProperty', '_') // 'some_javascript_property'
+fromCamelCase('someDatabaseFieldName', ' '); // 'some database field name'
+fromCamelCase('someLabelThatNeedsToBeCamelized', '-'); // 'some-label-that-needs-to-be-camelized'
+fromCamelCase('someJavascriptProperty', '_'); // 'some_javascript_property'
 ```

snippets/functionName.md

@@ -9,5 +9,5 @@ const functionName = fn => (console.debug(fn.name), fn);
 ```
 
 ```js
-functionName(Math.max) // max (logged in debug channel of console)
+functionName(Math.max); // max (logged in debug channel of console)
 ```

snippets/gcd.md

@@ -7,9 +7,9 @@ Base case is when `y` equals `0`. In this case, return `x`.
 Otherwise, return the GCD of `y` and the remainder of the division `x/y`.
 
 ```js
-const gcd = (x, y) => !y ? x : gcd(y, x % y);
+const gcd = (x, y) => (!y ? x : gcd(y, x % y));
 ```
 
 ```js
-gcd (8, 36) // 4
+gcd(8, 36); // 4
 ```

snippets/getDaysDiffBetweenDates.md

@@ -5,9 +5,10 @@ Returns the difference (in days) between two dates.
 Calculate the difference (in days) between two `Date` objects.
 
 ```js
-const getDaysDiffBetweenDates = (dateInitial, dateFinal) => (dateFinal - dateInitial) / (1000 * 3600 * 24);
+const getDaysDiffBetweenDates = (dateInitial, dateFinal) =>
+  (dateFinal - dateInitial) / (1000 * 3600 * 24);
 ```
 
 ```js
-getDaysDiffBetweenDates(new Date("2017-12-13"), new Date("2017-12-22")) // 9
+getDaysDiffBetweenDates(new Date('2017-12-13'), new Date('2017-12-22')); // 9
 ```

snippets/getScrollPosition.md

@@ -6,11 +6,12 @@ Use `pageXOffset` and `pageYOffset` if they are defined, otherwise `scrollLeft`
 You can omit `el` to use a default value of `window`.
 
 ```js
-const getScrollPosition = (el = window) =>
-  ({x: (el.pageXOffset !== undefined) ? el.pageXOffset : el.scrollLeft,
-    y: (el.pageYOffset !== undefined) ? el.pageYOffset : el.scrollTop});
+const getScrollPosition = (el = window) => ({
+  x: el.pageXOffset !== undefined ? el.pageXOffset : el.scrollLeft,
+  y: el.pageYOffset !== undefined ? el.pageYOffset : el.scrollTop
+});
 ```
 
 ```js
-getScrollPosition() // {x: 0, y: 200}
+getScrollPosition(); // {x: 0, y: 200}
 ```

snippets/getType.md

@@ -10,5 +10,5 @@ const getType = v =>
 ```
 
 ```js
-getType(new Set([1,2,3])) // "set"
+getType(new Set([1, 2, 3])); // "set"
 ```

snippets/getURLParameters.md

@@ -7,11 +7,11 @@ Pass `location.search` as the argument to apply to the current `url`.
 
 ```js
 const getURLParameters = url =>
-  url.match(/([^?=&]+)(=([^&]*))/g).reduce(
-    (a, v) => (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1), a), {}
-  );
+  url
+    .match(/([^?=&]+)(=([^&]*))/g)
+    .reduce((a, v) => ((a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1)), a), {});
 ```
 
 ```js
-getURLParameters('http://url.com/page?name=Adam&surname=Smith') // {name: 'Adam', surname: 'Smith'}
+getURLParameters('http://url.com/page?name=Adam&surname=Smith'); // {name: 'Adam', surname: 'Smith'}
 ```

snippets/groupBy.md

@@ -7,11 +7,13 @@ Use `Array.reduce()` to create an object, where the keys are produced from the m
 
 ```js
 const groupBy = (arr, func) =>
-  arr.map(typeof func === 'function' ? func : val => val[func])
-    .reduce((acc, val, i) => { acc[val] = (acc[val] || []).concat(arr[i]); return acc; }, {});
+  arr.map(typeof func === 'function' ? func : val => val[func]).reduce((acc, val, i) => {
+    acc[val] = (acc[val] || []).concat(arr[i]);
+    return acc;
+  }, {});
 ```
 
 ```js
-groupBy([6.1, 4.2, 6.3], Math.floor) // {4: [4.2], 6: [6.1, 6.3]}
-groupBy(['one', 'two', 'three'], 'length') // {3: ['one', 'two'], 5: ['three']}
+groupBy([6.1, 4.2, 6.3], Math.floor); // {4: [4.2], 6: [6.1, 6.3]}
+groupBy(['one', 'two', 'three'], 'length'); // {3: ['one', 'two'], 5: ['three']}
 ```

snippets/hammingDistance.md

@@ -6,10 +6,9 @@ Use XOR operator (`^`) to find the bit difference between the two numbers, conve
 Count and return the number of `1`s in the string, using `match(/1/g)`.
 
 ```js
-const hammingDistance = (num1, num2) =>
-  ((num1 ^ num2).toString(2).match(/1/g) || '').length;
+const hammingDistance = (num1, num2) => ((num1 ^ num2).toString(2).match(/1/g) || '').length;
 ```
 
 ```js
-hammingDistance(2,3) // 1
+hammingDistance(2, 3); // 1
 ```

snippets/head.md

@@ -9,5 +9,5 @@ const head = arr => arr[0];
 ```
 
 ```js
-head([1,2,3]) // 1
+head([1, 2, 3]); // 1
 ```

snippets/hexToRGB.md

@@ -6,20 +6,28 @@ Use bitwise right-shift operator and mask bits with `&` (and) operator to conver
 
 ```js
 const hexToRGB = hex => {
-  let alpha = false, h = hex.slice(hex.startsWith('#') ? 1 : 0);
+  let alpha = false,
+    h = hex.slice(hex.startsWith('#') ? 1 : 0);
   if (h.length === 3) h = [...h].map(x => x + x).join('');
   else if (h.length === 8) alpha = true;
   h = parseInt(h, 16);
-  return 'rgb' + (alpha ? 'a' : '') + '(' +
-    (h >>> (alpha ? 24 : 16)) + ', ' +
-    ((h & (alpha ? 0x00ff0000 : 0x00ff00)) >>> (alpha ? 16 : 8)) + ', ' +
+  return (
+    'rgb' +
+    (alpha ? 'a' : '') +
+    '(' +
+    (h >>> (alpha ? 24 : 16)) +
+    ', ' +
+    ((h & (alpha ? 0x00ff0000 : 0x00ff00)) >>> (alpha ? 16 : 8)) +
+    ', ' +
     ((h & (alpha ? 0x0000ff00 : 0x0000ff)) >>> (alpha ? 8 : 0)) +
-    (alpha ? `, ${(h & 0x000000ff)}` : '') + ')';
+    (alpha ? `, ${h & 0x000000ff}` : '') +
+    ')'
+  );
 };
 ```
 
 ```js
-hexToRGB('#27ae60ff') // 'rgba(39, 174, 96, 255)'
-hexToRGB('27ae60') // 'rgb(39, 174, 96)'
-hexToRGB('#fff') // 'rgb(255, 255, 255)'
+hexToRGB('#27ae60ff'); // 'rgba(39, 174, 96, 255)'
+hexToRGB('27ae60'); // 'rgb(39, 174, 96)'
+hexToRGB('#fff'); // 'rgb(255, 255, 255)'
 ```

snippets/inRange.md

@@ -7,14 +7,14 @@ If the second parameter, `end`, is not specified, the range is considered to be
 
 ```js
 const inRange = (n, start, end = null) => {
-  if (end && start > end) end = [start, start = end][0];
-  return (end == null) ? (n >= 0 && n < start) : (n >= start && n < end);
+  if (end && start > end) end = [start, (start = end)][0];
+  return end == null ? n >= 0 && n < start : n >= start && n < end;
 };
 ```
 
 ```js
-inRange(3, 2, 5) // true
-inRange(3, 4) // true
-inRange(2, 3, 5) // false
-inrange(3, 2) // false
+inRange(3, 2, 5); // true
+inRange(3, 4); // true
+inRange(2, 3, 5); // false
+inrange(3, 2); // false
 ```

snippets/initial.md

@@ -9,5 +9,5 @@ const initial = arr => arr.slice(0, -1);
 ```
 
 ```js
-initial([1,2,3]) // [1,2]
+initial([1, 2, 3]); // [1,2]
 ```

snippets/initialize2DArray.md

@@ -5,9 +5,12 @@ Initializes a 2D array of given width and height and value.
 Use `Array.map()` to generate h rows where each is a new array of size w initialize with value. If the value is not provided, default to `null`.
 
 ```js
-const initialize2DArray = (w, h, val = null) => Array(h).fill().map(() => Array(w).fill(val));
+const initialize2DArray = (w, h, val = null) =>
+  Array(h)
+    .fill()
+    .map(() => Array(w).fill(val));
 ```
 
 ```js
-initialize2DArray(2, 2, 0) // [[0,0], [0,0]]
+initialize2DArray(2, 2, 0); // [[0,0], [0,0]]
 ```

snippets/initializeArrayWithRange.md

@@ -7,10 +7,10 @@ You can omit `start` to use a default value of `0`.
 
 ```js
 const initializeArrayWithRange = (end, start = 0) =>
-  Array.from({ length: (end + 1) - start }).map((v, i) => i + start);
+  Array.from({ length: end + 1 - start }).map((v, i) => i + start);
 ```
 
 ```js
-initializeArrayWithRange(5) // [0,1,2,3,4,5]
-initializeArrayWithRange(7, 3) // [3,4,5,6,7]
+initializeArrayWithRange(5); // [0,1,2,3,4,5]
+initializeArrayWithRange(7, 3); // [3,4,5,6,7]
 ```

snippets/initializeArrayWithValues.md

@@ -10,5 +10,5 @@ const initializeArrayWithValues = (n, value = 0) => Array(n).fill(value);
 ```
 
 ```js
-initializeArrayWithValues(5, 2) // [2,2,2,2,2]
+initializeArrayWithValues(5, 2); // [2,2,2,2,2]
 ```

snippets/intersection.md

@@ -5,9 +5,12 @@ Returns a list of elements that exist in both arrays.
 Create a `Set` from `b`, then use `Array.filter()` on `a` to only keep values contained in `b`.
 
 ```js
-const intersection = (a, b) => { const s = new Set(b); return a.filter(x => s.has(x)); };
+const intersection = (a, b) => {
+  const s = new Set(b);
+  return a.filter(x => s.has(x));
+};
 ```
 
 ```js
-intersection([1,2,3], [4,3,2]) // [2,3]
+intersection([1, 2, 3], [4, 3, 2]); // [2,3]
 ```

snippets/isArmstrongNumber.md

@@ -6,11 +6,13 @@ Convert the given number into an array of digits. Use `Math.pow()` to get the ap
 
 ```js
 const isArmstrongNumber = digits =>
-  (arr => arr.reduce((a, d) => a + Math.pow(parseInt(d), arr.length), 0) == digits)((digits + '').split(''));
+  (arr => arr.reduce((a, d) => a + Math.pow(parseInt(d), arr.length), 0) == digits)(
+    (digits + '').split('')
+  );
 ```
 
 ```js
-isArmstrongNumber(1634) // true
-isArmstrongNumber(371) // true
-isArmstrongNumber(56) // false
+isArmstrongNumber(1634); // true
+isArmstrongNumber(371); // true
+isArmstrongNumber(56); // false
 ```

snippets/isArray.md

@@ -9,6 +9,6 @@ const isArray = val => !!val && Array.isArray(val);
 ```
 
 ```js
-isArray(null) // false
-isArray([1]) // true
+isArray(null); // false
+isArray([1]); // true
 ```

snippets/isBoolean.md

@@ -9,6 +9,6 @@ const isBoolean = val => typeof val === 'boolean';
 ```
 
 ```js
-isBoolean(null) // false
-isBoolean(false) // true
+isBoolean(null); // false
+isBoolean(false); // true
 ```

snippets/isDivisible.md

@@ -9,5 +9,5 @@ const isDivisible = (dividend, divisor) => dividend % divisor === 0;
 ```
 
 ```js
-isDivisible(6,3) // true
+isDivisible(6, 3); // true
 ```

snippets/isEven.md

@@ -10,5 +10,5 @@ const isEven = num => num % 2 === 0;
 ```
 
 ```js
-isEven(3) // false
+isEven(3); // false
 ```

snippets/isFunction.md

@@ -9,6 +9,6 @@ const isFunction = val => val && typeof val === 'function';
 ```
 
 ```js
-isFunction('x') // false
-isFunction(x => x) // true
+isFunction('x'); // false
+isFunction(x => x); // true
 ```

snippets/isNumber.md

@@ -9,6 +9,6 @@ const isNumber = val => typeof val === 'number';
 ```
 
 ```js
-isNumber('1') // false
-isNumber(1) // true
+isNumber('1'); // false
+isNumber(1); // true
 ```

snippets/isPrime.md

@@ -14,6 +14,6 @@ const isPrime = num => {
 ```
 
 ```js
-isPrime(11) // true
-isPrime(12) // false
+isPrime(11); // true
+isPrime(12); // false
 ```

snippets/isString.md

@@ -9,6 +9,6 @@ const isString = val => typeof val === 'string';
 ```
 
 ```js
-isString(10) // false
-isString('10') // true
+isString(10); // false
+isString('10'); // true
 ```

snippets/isSymbol.md

@@ -9,6 +9,6 @@ const isSymbol = val => typeof val === 'symbol';
 ```
 
 ```js
-isSymbol('x') // false
-isSymbol(Symbol('x')) // true
+isSymbol('x'); // false
+isSymbol(Symbol('x')); // true
 ```

snippets/last.md

@@ -9,5 +9,5 @@ const last = arr => arr[arr.length - 1];
 ```
 
 ```js
-last([1,2,3]) // 3
+last([1, 2, 3]); // 3
 ```

snippets/lcm.md

@@ -7,11 +7,11 @@ The GCD formula uses recursion.
 
 ```js
 const lcm = (x, y) => {
-  const gcd = (x, y) => !y ? x : gcd(y, x % y);
-  return Math.abs(x * y) / (gcd(x, y));
+  const gcd = (x, y) => (!y ? x : gcd(y, x % y));
+  return Math.abs(x * y) / gcd(x, y);
 };
 ```
 
 ```js
-lcm(12,7) // 84
+lcm(12, 7); // 84
 ```

snippets/mapObject.md

@@ -6,10 +6,12 @@ Use an anonymous inner function scope to declare an undefined memory space, usin
 
 ```js
 const mapObject = (arr, fn) =>
-  (a => (a = [arr, arr.map(fn)], a[0].reduce((acc, val, ind) => (acc[val] = a[1][ind], acc), {})))();
+  (a => (
+    (a = [arr, arr.map(fn)]), a[0].reduce((acc, val, ind) => ((acc[val] = a[1][ind]), acc), {})
+  ))();
 ```
 
 ```js
-const squareIt = arr => mapObject(arr, a => a*a)
-squareIt([1,2,3]) // { 1: 1, 2: 4, 3: 9 }
+const squareIt = arr => mapObject(arr, a => a * a);
+squareIt([1, 2, 3]); // { 1: 1, 2: 4, 3: 9 }
 ```

snippets/median.md

@@ -7,12 +7,13 @@ Return the number at the midpoint if `length` is odd, otherwise the average of t
 
 ```js
 const median = arr => {
-  const mid = Math.floor(arr.length / 2), nums = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(arr.length / 2),
+    nums = [...arr].sort((a, b) => a - b);
   return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
 };
 ```
 
 ```js
-median([5,6,50,1,-5]) // 5
-median([0,10,-2,7]) // 3.5
+median([5, 6, 50, 1, -5]); // 5
+median([0, 10, -2, 7]); // 3.5
 ```

snippets/negate.md

@@ -9,6 +9,6 @@ const negate = func => (...args) => !func(...args);
 ```
 
 ```js
-filter([1, 2, 3, 4, 5, 6], negate(isEven)) // [1, 3, 5]
-negate(isOdd)(1) // false
+filter([1, 2, 3, 4, 5, 6], negate(isEven)); // [1, 3, 5]
+negate(isOdd)(1); // false
 ```

snippets/nthElement.md

@@ -11,6 +11,6 @@ const nthElement = (arr, n = 0) => (n > 0 ? arr.slice(n, n + 1) : arr.slice(n))[
 ```
 
 ```js
-nthElement(['a','b','c'],1) // 'b'
-nthElement(['a','b','b'],-3) // 'a'
+nthElement(['a', 'b', 'c'], 1); // 'b'
+nthElement(['a', 'b', 'b'], -3); // 'a'
 ```

snippets/objectFromPairs.md

@@ -5,9 +5,9 @@ Creates an object from the given key-value pairs.
 Use `Array.reduce()` to create and combine key-value pairs.
 
 ```js
-const objectFromPairs = arr => arr.reduce((a, v) => (a[v[0]] = v[1], a), {});
+const objectFromPairs = arr => arr.reduce((a, v) => ((a[v[0]] = v[1]), a), {});
 ```
 
 ```js
-objectFromPairs([['a',1],['b',2]]) // {a: 1, b: 2}
+objectFromPairs([['a', 1], ['b', 2]]); // {a: 1, b: 2}
 ```

snippets/objectToPairs.md

@@ -9,5 +9,5 @@ const objectToPairs = obj => Object.keys(obj).map(k => [k, obj[k]]);
 ```
 
 ```js
-objectToPairs({a: 1, b: 2}) // [['a',1],['b',2]])
+objectToPairs({ a: 1, b: 2 }); // [['a',1],['b',2]])
 ```

snippets/orderBy.md

@@ -19,8 +19,12 @@ const orderBy = (arr, props, orders) =>
 ```
 
 ```js
-const users = [{ 'name': 'fred',   'age': 48 },{ 'name': 'barney', 'age': 36 },
-  { 'name': 'fred',   'age': 40 },{ 'name': 'barney', 'age': 34 }];
-orderby(users, ['name', 'age'], ['asc', 'desc']) // [{name: 'barney', age: 36}, {name: 'barney', age: 34}, {name: 'fred', age: 48}, {name: 'fred', age: 40}]
-orderby(users, ['name', 'age']) // [{name: 'barney', age: 34}, {name: 'barney', age: 36}, {name: 'fred', age: 40}, {name: 'fred', age: 48}]
+const users = [
+  { name: 'fred', age: 48 },
+  { name: 'barney', age: 36 },
+  { name: 'fred', age: 40 },
+  { name: 'barney', age: 34 }
+];
+orderby(users, ['name', 'age'], ['asc', 'desc']); // [{name: 'barney', age: 36}, {name: 'barney', age: 34}, {name: 'fred', age: 48}, {name: 'fred', age: 40}]
+orderby(users, ['name', 'age']); // [{name: 'barney', age: 34}, {name: 'barney', age: 36}, {name: 'fred', age: 40}, {name: 'fred', age: 48}]
 ```

snippets/palindrome.md

@@ -8,10 +8,16 @@ Then, `split('')` into individual characters, `reverse()`, `join('')` and compar
 ```js
 const palindrome = str => {
   const s = str.toLowerCase().replace(/[\W_]/g, '');
-  return s === s.split('').reverse().join('');
+  return (
+    s ===
+    s
+      .split('')
+      .reverse()
+      .join('')
+  );
 };
 ```
 
 ```js
-palindrome('taco cat') // true
+palindrome('taco cat'); // true
 ```

snippets/percentile.md

@@ -10,5 +10,5 @@ const percentile = (arr, val) =>
 ```
 
 ```js
-percentile([1,2,3,4,5,6,7,8,9,10], 6) // 55
+percentile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 6); // 55
 ```

snippets/pick.md

@@ -10,5 +10,5 @@ const pick = (obj, arr) =>
 ```
 
 ```js
-pick({ 'a': 1, 'b': '2', 'c': 3 }, ['a', 'c']) // { 'a': 1, 'c': 3 }
+pick({ a: 1, b: '2', c: 3 }, ['a', 'c']); // { 'a': 1, 'c': 3 }
 ```

snippets/pipeFunctions.md

@@ -10,8 +10,8 @@ const pipeFunctions = (...fns) => fns.reduce((f, g) => (...args) => g(f(...args)
 ```
 
 ```js
-const add5 = x => x + 5
-const multiply = (x, y) => x * y
-const multiplyAndAdd5 = pipeFunctions(multiply, add5)
-multiplyAndAdd5(5, 2) // 15
+const add5 = x => x + 5;
+const multiply = (x, y) => x * y;
+const multiplyAndAdd5 = pipeFunctions(multiply, add5);
+multiplyAndAdd5(5, 2); // 15
 ```

snippets/powerset.md

@@ -5,10 +5,9 @@ Returns the powerset of a given array of numbers.
 Use `Array.reduce()` combined with `Array.map()` to iterate over elements and combine into an array containing all combinations.
 
 ```js
-const powerset = arr =>
-  arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);
+const powerset = arr => arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);
 ```
 
 ```js
-powerset([1,2]) // [[], [1], [2], [2,1]]
+powerset([1, 2]); // [[], [1], [2], [2,1]]
 ```

snippets/primes.md

@@ -6,14 +6,14 @@ Generate an array from `2` to the given number. Use `Array.filter()` to filter o
 
 ```js
 const primes = num => {
-  let arr = Array.from({length: num - 1}).map((x, i) => i + 2),
+  let arr = Array.from({ length: num - 1 }).map((x, i) => i + 2),
     sqroot = Math.floor(Math.sqrt(num)),
-    numsTillSqroot = Array.from({length: sqroot - 1}).map((x, i) => i + 2);
-  numsTillSqroot.forEach(x => arr = arr.filter(y => ((y % x) !== 0) || (y == x)));
+    numsTillSqroot = Array.from({ length: sqroot - 1 }).map((x, i) => i + 2);
+  numsTillSqroot.forEach(x => (arr = arr.filter(y => y % x !== 0 || y == x)));
   return arr;
 };
 ```
 
 ```js
-primes(10) // [2,3,5,7]
+primes(10); // [2,3,5,7]
 ```

snippets/promisify.md

@@ -8,15 +8,13 @@ Use the `...rest` operator to pass in all the parameters.
 *In Node 8+, you can use [`util.promisify`](https://nodejs.org/api/util.html#util_util_promisify_original)*
 
 ```js
-const promisify = func =>
-  (...args) =>
-    new Promise((resolve, reject) =>
-      func(...args, (err, result) =>
-        err ? reject(err) : resolve(result))
-    );
+const promisify = func => (...args) =>
+  new Promise((resolve, reject) =>
+    func(...args, (err, result) => (err ? reject(err) : resolve(result)))
+  );
 ```
 
 ```js
-const delay = promisify((d, cb) => setTimeout(cb, d))
-delay(2000).then(() => console.log('Hi!')) // // Promise resolves after 2s
+const delay = promisify((d, cb) => setTimeout(cb, d));
+delay(2000).then(() => console.log('Hi!')); // // Promise resolves after 2s
 ```

snippets/pull.md

@@ -19,9 +19,9 @@ const pull = (arr, ...args) => {
 ```js
 let myArray1 = ['a', 'b', 'c', 'a', 'b', 'c'];
 pull(myArray1, 'a', 'c');
-console.log(myArray1) // [ 'b', 'b' ]
+console.log(myArray1); // [ 'b', 'b' ]
 
 let myArray2 = ['a', 'b', 'c', 'a', 'b', 'c'];
 pull(myArray2, ['a', 'c']);
-console.log(myArray2) // [ 'b', 'b' ]
+console.log(myArray2); // [ 'b', 'b' ]
 ```

snippets/pullAtIndex.md

@@ -9,8 +9,9 @@ Use `Array.push()` to keep track of pulled values
 ```js
 const pullAtIndex = (arr, pullArr) => {
   let removed = [];
-  let pulled = arr.map((v, i) => pullArr.includes(i) ? removed.push(v) : v)
-                  .filter((v, i) => !pullArr.includes(i));
+  let pulled = arr
+    .map((v, i) => (pullArr.includes(i) ? removed.push(v) : v))
+    .filter((v, i) => !pullArr.includes(i));
   arr.length = 0;
   pulled.forEach(v => arr.push(v));
   return removed;

snippets/pullAtValue.md

@@ -9,7 +9,7 @@ Use `Array.push()` to keep track of pulled values
 ```js
 const pullAtValue = (arr, pullArr) => {
   let removed = [],
-    pushToRemove = arr.forEach((v, i) => pullArr.includes(v) ? removed.push(v) : v),
+    pushToRemove = arr.forEach((v, i) => (pullArr.includes(v) ? removed.push(v) : v)),
     mutateTo = arr.filter((v, i) => !pullArr.includes(v));
   arr.length = 0;
   mutateTo.forEach(v => arr.push(v));

snippets/randomHexColorCode.md

@@ -5,15 +5,14 @@ Generates a random hexadecimal color code.
 Use `Math.random` to generate a random 24-bit(6x4bits) hexadecimal number. Use bit shifting and then convert it to an hexadecimal String using `toString(16)`.
 
 ```js
-const randomHexColorCode = () => { 
-  let n = (Math.random() * 0xfffff | 0).toString(16); 
-  return '#' + (n.length !== 6 
-        ? (Math.random() * 0xf | 0).toString(16) + n : n); 
-}; 
+const randomHexColorCode = () => {
+  let n = ((Math.random() * 0xfffff) | 0).toString(16);
+  return '#' + (n.length !== 6 ? ((Math.random() * 0xf) | 0).toString(16) + n : n);
+};
 ```
 
 ```js
-randomHexColorCode() // "#e34155"
-randomHexColorCode() // "#fd73a6"
-randomHexColorCode() // "#4144c6"
+randomHexColorCode(); // "#e34155"
+randomHexColorCode(); // "#fd73a6"
+randomHexColorCode(); // "#4144c6"
 ```

snippets/randomIntegerInRange.md

@@ -9,5 +9,5 @@ const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min
 ```
 
 ```js
-randomIntegerInRange(0, 5) // 2
+randomIntegerInRange(0, 5); // 2
 ```

snippets/randomNumberInRange.md

@@ -9,5 +9,5 @@ const randomNumberInRange = (min, max) => Math.random() * (max - min) + min;
 ```
 
 ```js
-randomNumberInRange(2,10) // 6.0211363285087005
+randomNumberInRange(2, 10); // 6.0211363285087005
 ```