handlebars-i18n 1.7.0 → 1.8.0

package/test/handlebars-i18n.test.js

@@ -12,7 +12,7 @@ const Handlebars = require('handlebars');
 const i18next = require('i18next');
 const HandlebarsI18n = require('../dist/handlebars-i18n');
 
-describe('handlebars-i18n Tests', function() {
+describe('handlebars-i18n Tests', function () {
 
   const i18nInitObj = {
     resources: {
@@ -59,6 +59,10 @@ describe('handlebars-i18n Tests', function() {
     assert.isFunction(hI18n.helpers._date);
   });
 
+  it('after method call init() HandlebarsEnvironment object should have a function _dateAdd', function () {
+    assert.isFunction(hI18n.helpers._dateAdd);
+  });
+
   it('after method call init() HandlebarsEnvironment object should have a function _dateRel', function () {
     assert.isFunction(hI18n.helpers._dateRel);
   });
@@ -99,19 +103,19 @@ describe('handlebars-i18n Tests', function() {
    Tests against function _locale
    ****************************************/
 
-  it('expecting function _locale to be [undefined] as long as no language was set with i18next.init', function() {
+  it('expecting _locale to be [undefined] as long as no language was set with i18next.init', function () {
     i18next.init(); // empty init
     const res = hI18n.helpers._locale();
     expect(res).to.be.undefined;
   });
 
-  it('function _locale should return "en" if language is specified as "en" by init Object', function() {
+  it('_locale should return "en" if language is specified as "en" by init Object', function () {
     i18next.init(i18nInitObj); // initialize with data
     const res = hI18n.helpers._locale();
     assert.equal('en', res);
   });
 
-  it('function _locale should return "de" after language change to "de"', function() {
+  it('_locale should return "de" after language change to "de"', function () {
     i18next.changeLanguage('de');
     const res = hI18n.helpers._locale();
     assert.equal('de', res);
@@ -122,13 +126,13 @@ describe('handlebars-i18n Tests', function() {
    Tests against function isLocale
    ****************************************/
 
-  it('function isLocale should return TRUE when current language is set to "en" and given "en" as parameter', function() {
+  it('function isLocale should return TRUE when current language is set to "en" and given "en" as parameter', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers.localeIs('en');
     assert.equal(true, res);
   });
 
-  it('function isLocale should return FALSE when current language is set to "en" and given "someOther" as parameter', function() {
+  it('function isLocale should return FALSE when current language is set to "en" and given "someOther" as parameter', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers.localeIs('someOther');
     assert.equal(false, res);
@@ -139,35 +143,37 @@ describe('handlebars-i18n Tests', function() {
    Tests against function __
    ****************************************/
 
-  it('expect __ to throw error when called with no parameter', function() {
-    expect(function() { hI18n.helpers.__() }).to.throw();
+  it('expect __ to throw error when called with no parameter', function () {
+    expect(function () {
+      hI18n.helpers.__()
+    }).to.throw();
   });
 
-  it('function __ should return a SafeString object with property "string" where "string" returns the first argument given to __', function() {
-    const res = hI18n.helpers.__("someNoneExitingKey", { hash: {} });
+  it('__ should return a SafeString object with property "string" where "string" returns the first argument given to __', function () {
+    const res = hI18n.helpers.__("someNoneExitingKey", {hash: {}});
     assert.equal("someNoneExitingKey", res.string);
   });
 
-  it('function __ should return a SafeString object with property "string" where "string" contains "What is good?!', function() {
-    const res = hI18n.helpers.__("key1", { hash: {} });
+  it('__ should return a SafeString object with property "string" where "string" contains "What is good?!', function () {
+    const res = hI18n.helpers.__("key1", {hash: {}});
     assert.equal("What is good?", res.string);
   });
 
-  it('function __ should return a SafeString object with property "string" where "string" contains "Was ist gut?"', function() {
+  it('__ should return a SafeString object with property "string" where "string" contains "Was ist gut?"', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers.__("key1", { hash: {} });
+    const res = hI18n.helpers.__("key1", {hash: {}});
     assert.equal("Was ist gut?", res.string);
   });
 
-  it('function __ should return a SafeString object with property "string" where "string" contains "handlebarsI18next is good."', function() {
+  it('__ should return a SafeString object with property "string" where "string" contains "handlebarsI18next is good."', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers.__("key2", { hash: { what : "handlebarsI18next", adverb : "good" } });
+    const res = hI18n.helpers.__("key2", {hash: {what: "handlebarsI18next", adverb: "good"}});
     assert.equal("handlebarsI18next is good.", res.string);
   });
 
-  it('function __ should return a SafeString object with property "string" where "string" contains "handlebarsI18next ist gut."', function() {
+  it('__ should return a SafeString object with property "string" where "string" contains "handlebarsI18next ist gut."', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers.__("key2", { hash: { what: "handlebarsI18next", adverb: "gut" } });
+    const res = hI18n.helpers.__("key2", {hash: {what: "handlebarsI18next", adverb: "gut"}});
     assert.equal("handlebarsI18next ist gut.", res.string);
   });
 
@@ -176,11 +182,13 @@ describe('handlebars-i18n Tests', function() {
    Tests against function _date
    ****************************************/
 
-  it('expect function _date to throw error when called with invalid date parameter', function() {
-    expect(function() { hI18n.helpers._date('someStrangeString') }).to.throw("Invalid valid date passed to format");
+  it('expect _date to throw error when called with invalid date parameter', function () {
+    expect(function () {
+      hI18n.helpers._date('someStrangeString')
+    }).to.throw("Invalid valid date passed to format");
   });
 
-  it('function _date should return today’s date in Intl default format when called without parameter', function() {
+  it('_date should return today’s date in Intl default format when called without parameter', function () {
     i18next.changeLanguage('en');
     const today = new Date();
     const todayFormated = new Intl.DateTimeFormat().format(today);
@@ -189,8 +197,8 @@ describe('handlebars-i18n Tests', function() {
     assert.equal(todayFormated, res);
   });
 
-  it('function _date should return today’s date in Intl default format when called with parameter, "Today" or "Now" no matter of upper or lower case writing',
-    function() {
+  it('_date should return today’s date in Intl default format when called with parameter, "Today" or "Now" no matter of upper or lower case writing',
+    function () {
       i18next.changeLanguage('en');
       const today = new Date();
       const todayFormated = new Intl.DateTimeFormat().format(today);
@@ -201,97 +209,266 @@ describe('handlebars-i18n Tests', function() {
       assert.equal(todayFormated, hI18n.helpers._date("now"));
       assert.equal(todayFormated, hI18n.helpers._date("Now"));
       assert.equal(todayFormated, hI18n.helpers._date("NOW"));
-  });
+    });
 
-  it('function _date should return "1/1/1970" (Intl default format) when called with parameter 1 as number ', function() {
+  it('_date should return "1/1/1970" (Intl default format) when called with parameter 1 as number ', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._date(1);
     assert.equal('1/1/1970', res);
   });
 
-  it('function _date should return "12/17/1995" (Intl default format) when called with parameter "1995-12-17T03:24:00"', function() {
+  it('_date should return "12/17/1995" (Intl default format) when called with parameter "1995-12-17T03:24:00"', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._date('1995-12-17T03:24:00');
     assert.equal('12/17/1995', res);
   });
 
-  it('function _date should return "12/17/1995" (Intl default format) when called with parameter "December 17, 1995 03:24:00"', function() {
+  it('_date should return "12/17/1995" (Intl default format) when called with parameter "December 17, 1995 03:24:00"', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._date('December 17, 1995 03:24:00');
     assert.equal('12/17/1995', res);
   });
 
-  it('function _date should return "1/1/2020" (Intl default format) when called with parameter "[2020]"', function() {
+  it('_date should return "1/1/2020" (Intl default format) when called with parameter "[2020]"', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._date('[1995]');
     assert.equal('1/1/1995', res);
   });
 
-  it('function _date should return "12/1/1995" (Intl default format) when called with parameter "[2020,11]"', function() {
+  it('_date should return "12/1/1995" (Intl default format) when called with parameter "[2020,11]"', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._date('[1995,11]');
     assert.equal('12/1/1995', res);
   });
 
-  it('function _date should return "12/17/1995" (Intl default format) when called with parameter "[2020,11,17]"', function() {
+  it('_date should return "12/17/1995" (Intl default format) when called with parameter "[2020,11,17]"', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._date('[1995,11,17]');
     assert.equal('12/17/1995', res);
   });
 
-  it('function _date should return "12/1/95" when called with parameter "[2020,11,01] and specifying options"', function() {
+  it('_date should return "12/1/95" when called with parameter "[2020,11,01] and specifying options"', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('[1995,11,1]', { hash: { year:"2-digit", month:"2-digit", day:"2-digit" } });
+    const res = hI18n.helpers._date('[1995,11,1]', {hash: {year: "2-digit", month: "2-digit", day: "2-digit"}});
     assert.equal('12/1/95', res);
   });
 
-  it('function _date should return "01.12.95" when called with parameter "[2020,11,01] and specifying options an language set to "de"', function() {
+  it('_date should return "01.12.95" when called with parameter "[2020,11,01] and specifying options an language set to "de"', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._date('[1995,11,1]', { hash: { year:"2-digit", month:"2-digit", day:"2-digit" } });
+    const res = hI18n.helpers._date('[1995,11,1]', {hash: {year: "2-digit", month: "2-digit", day: "2-digit"}});
     assert.equal('01.12.95', res);
   });
 
 
+  /****************************************
+   Tests against function _dateAdd
+   ****************************************/
+
+  it('_dateAdd should throw error when called without params', function () {
+    expect(function () {
+      hI18n.helpers._dateAdd()
+    }).to.throw("@ handlebars-i18n: invalid first argument \"dateInput\" was given for _dateAdd.");
+  });
+
+  it('_dateAdd should throw error when called without 2nd param', function () {
+    expect(function () {
+      hI18n.helpers._dateAdd('December 17, 1995 02:00:00')
+    }).to.throw("@ handlebars-i18n: invalid second argument \"offset\" was given for _dateAdd.");
+  });
+
+  it('_dateAdd should use default unit "hour" when called without 3rd param', function () {
+    i18next.changeLanguage('en');
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 25);
+    assert.equal('12/18/1995', res);
+  });
+
+  it('_dateAdd should return "12/17/1995" when called with parameters "December 17, 1995 02:00:00", 1, and "day"', function () {
+    i18next.changeLanguage('en');
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, {"hash": {unit: "day"}});
+    assert.equal('12/18/1995', res);
+  });
+
+  // -- Test for "second" -- //
+
+  it('_dateAdd should return "12/18/1995" when called with parameters "December 17, 1995 02:00:00", 1, and "second"', function () {
+    i18next.changeLanguage('en');
+    const options = {hash: {unit: "second", hour: "2-digit", minute: "2-digit", second: "2-digit"}}
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('02:00:01', res);
+  });
+
+  // -- Test for "minute" -- //
+
+  it('_dateAdd should return "02:01:00" when called with parameters "December 17, 1995 02:00:00", 1, and "minute"', function () {
+    i18next.changeLanguage('en');
+    const options = {hash: {unit: "minute", hour: "2-digit", minute: "2-digit", second: "2-digit"}}
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('02:01:00', res);
+  });
+
+  // -- Test for "hour" -- //
+
+  it('_dateAdd should return "03:00:00" when called with parameters "December 17, 1995 02:00:00", 1, and "hour"', function () {
+    i18next.changeLanguage('en');
+    const options = {hash: {unit: "hour", hour: "2-digit", minute: "2-digit", second: "2-digit"}}
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('03:00:00', res);
+  });
+
+  // -- Test for "day" -- //
+
+  it('_dateAdd should return "December 18, 1995 02:00:00" when called with parameters "December 17, 1995 02:00:00", 1, and "day"', function () {
+    i18next.changeLanguage('en');
+    const options = {
+      hash: {
+        unit: "day",
+        year: "numeric",
+        month: "long",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }
+    }
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('December 18, 1995 at 02:00:00', res);
+  });
+
+  // -- Test for "week" -- //
+
+  it('_dateAdd should return "December 24, 1995 02:00:00" when called with parameters "December 17, 1995 02:00:00", 1, and "week"', function () {
+    i18next.changeLanguage('en');
+    const options = {
+      hash: {
+        unit: "week",
+        year: "numeric",
+        month: "long",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }
+    }
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('December 24, 1995 at 02:00:00', res);
+  });
+
+  // -- Test for "month" -- //
+
+  it('_dateAdd should return "January 17, 1996 02:00:00" when called with parameters "December 17, 1995 02:00:00", 1, and "month"', function () {
+    i18next.changeLanguage('en');
+    const options = {
+      hash: {
+        unit: "month",
+        year: "numeric",
+        month: "long",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }
+    }
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('January 17, 1996 at 02:00:00', res);
+  });
+
+  // -- Test for "quarter" -- //
+
+  it('_dateAdd should return "March 17, 1996 02:00:00" when called with parameters "December 17, 1995 02:00:00", 1, and "quarter"', function () {
+    i18next.changeLanguage('en');
+    const options = {
+      hash: {
+        unit: "quarter",
+        year: "numeric",
+        month: "long",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }
+    }
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('March 17, 1996 at 02:00:00', res);
+  });
+
+  // -- Test for "year" -- //
+
+  it('_dateAdd should return "December 17, 1996 02:00:00" when called with parameters "December 17, 1995 02:00:00", 1, and "year"', function () {
+    i18next.changeLanguage('en');
+    const options = {
+      hash: {
+        unit: "year",
+        year: "numeric",
+        month: "long",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      }
+    }
+    const res = hI18n.helpers._dateAdd('December 17, 1995 02:00:00', 1, options);
+    assert.equal('December 17, 1996 at 02:00:00', res);
+  });
+
+
   /****************************************
    Tests against function _dateRel
    ****************************************/
 
-  it('expect function _dateRel to throw error when called without parameter', function() {
-    expect(function() { hI18n.helpers._dateRel() }).to.throw('Invalid "number" argument: NaN');
+  it('expect _dateRel to throw error when called without parameter', function () {
+    expect(function () {
+      hI18n.helpers._dateRel()
+    }).to.throw('Invalid "number" argument: NaN');
   });
 
-  it('expect function _dateRel to throw error when called with invalid date parameter', function() {
-    expect(function() { hI18n.helpers._dateRel('someStrangeString') }).to.throw('Invalid "number" argument: NaN');
+  it('expect _dateRel to throw error when called with invalid date parameter', function () {
+    expect(function () {
+      hI18n.helpers._dateRel('someStrangeString')
+    }).to.throw('Invalid "number" argument: NaN');
   });
 
-  it('expect function _dateRel to throw error when called with non-existent language shortcode', function() {
+  it('expect _dateRel to throw error when called with non-existent language shortcode', function () {
     i18next.changeLanguage('invalid');
-    expect(function() {
-      hI18n.helpers._dateRel(1, { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit:"day" }})
+    expect(function () {
+      hI18n.helpers._dateRel(1, {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: "day"}})
     }).to.throw('No locale data passed');
   });
 
-  it('expect function _dateRel to return \'in 1 hour\' when called with \'en\' and first parameter being 1', function() {
+  it('expect _dateRel to return \'in 1 hour\' when called with \'en\' and first parameter being 1', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._dateRel(1);
     assert.equal('in 1 hour', res);
   });
 
-  it('expect function _dateRel to return \'1 hour ago\' when called with \'en\' and first parameter being -1', function() {
+  it('expect _dateRel to return \'1 hour ago\' when called with \'en\' and first parameter being -1', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._dateRel(-1);
     assert.equal('1 hour ago', res);
   });
 
-  it('expect function _dateRel to return \'in 1 second\' when called with \'en\' and first parameter being 1 and according options', function() {
+  it('expect _dateRel to return \'in 1 second\' when called with \'en\' and first parameter being 1 and according options', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._dateRel(1, { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit:"seconds" }});
+    const res = hI18n.helpers._dateRel(1, {
+      hash: {
+        localeMatcher: "best fit",
+        numeric: "always",
+        style: "long",
+        unit: "seconds"
+      }
+    });
     assert.equal('in 1 second', res);
   });
 
-  it('expect function _dateRel to return \'in 1 Tag\' when called with \'de\' and paramter 1 and according options', function() {
+  it('expect _dateRel to return \'in 1 Tag\' when called with \'de\' and paramter 1 and according options', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._dateRel(1, { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit:"day" }});
+    const res = hI18n.helpers._dateRel(1, {
+      hash: {
+        localeMatcher: "best fit",
+        numeric: "always",
+        style: "long",
+        unit: "day"
+      }
+    });
     assert.equal('in 1 Tag', res);
   });
 
@@ -300,35 +477,33 @@ describe('handlebars-i18n Tests', function() {
    Tests against function _dateDiff
    ****************************************/
 
-  it('function _dateDiff should return null when called with no parameter', function() {
+  it('_dateDiff should return null when called with no parameter', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._dateDiff();
     assert.equal(null, res);
   });
 
-  it('expect function _dateDiff to throw error when called with invalid 1. date parameter', function() {
-    expect(function() { hI18n.helpers._dateDiff('someStrangeString', '1995-12-17T03:24:00') })
+  it('expect _dateDiff to throw error when called with invalid 1. date parameter', function () {
+    expect(function () {
+      hI18n.helpers._dateDiff('someStrangeString', '1995-12-17T03:24:00')
+    })
       .to.throw('Invalid "number" argument: NaN');
   });
 
-  it('expect function _dateDiff to throw error when called with invalid 2. date parameter', function() {
-    expect(function() { hI18n.helpers._dateDiff('1995-12-17T03:24:00', 'someStrangeString') })
+  it('expect _dateDiff to throw error when called with invalid 2. date parameter', function () {
+    expect(function () {
+      hI18n.helpers._dateDiff('1995-12-17T03:24:00', 'someStrangeString')
+    })
       .to.throw('Invalid "number" argument: NaN');
   });
 
-  /*it('expect function _dateDiff to return the first date as "in 227,543 hours", when no second param given', function() {
+  it('expect _dateDiff to return null when called with empty argument', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._dateDiff('1995-12-17T00:00:00');
-    assert.equal('in 227,543 hours', res);
-  });*/
-
-  it('expect function _dateDiff to return the second date as "in 227,543 hours", when first param is empty', function() {
-    i18next.changeLanguage('en');
-    const res = hI18n.helpers._dateDiff('', '1995-12-17T00:00:00');
-    assert.equal('in 227,543 hours', res);
+    const res = hI18n.helpers._dateDiff('');
+    assert.equal(null, res);
   });
 
-  it('expect function _dateDiff to return "in 0 hours", when dates are identical', function() {
+  it('expect _dateDiff to return "in 0 hours", when dates are identical', function () {
     i18next.changeLanguage('en');
     const res = hI18n.helpers._dateDiff('1995-12-17T00:00:00', '1995-12-17T00:00:00');
     assert.equal('in 0 hours', res);
@@ -336,124 +511,124 @@ describe('handlebars-i18n Tests', function() {
 
   // -- Test year -- //
 
-  it('expect function _dateDiff to return "in 1 year"', function() {
+  it('expect _dateDiff to return "in 1 year"', function () {
     i18next.changeLanguage('en');
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: "year" } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: "year"}};
     const res = hI18n.helpers._dateDiff('1996-12-17T00:00:00', '1995-12-17T00:00:00', hash);
     assert.equal('in 1 year', res);
   });
 
-  it('expect function _dateDiff to return "1 year ago"', function() {
+  it('expect _dateDiff to return "1 year ago"', function () {
     i18next.changeLanguage('en');
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: "year" } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: "year"}};
     const res = hI18n.helpers._dateDiff('1995-12-17T00:00:00', '1996-12-17T00:00:00', hash);
     assert.equal('1 year ago', res);
   });
 
   // -- Test quarter -- //
 
-  it('expect function _dateDiff to return "in 1 quarter"', function() {
+  it('expect _dateDiff to return "in 1 quarter"', function () {
     i18next.changeLanguage('en');
     const unit = 'quarter';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-17T00:00:00', '1996-09-16T00:00:00', hash);
     assert.equal(`in 1 ${unit}`, res);
   });
 
-  it('expect function _dateDiff to return "1 quarter ago"', function() {
+  it('expect _dateDiff to return "1 quarter ago"', function () {
     i18next.changeLanguage('en');
     const unit = 'quarter';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-09-16T00:00:00', '1996-12-17T00:00:00', hash);
     assert.equal(`1 ${unit} ago`, res);
   });
 
   // -- Test month -- //
 
-  it('expect function _dateDiff to return "in 1 month"', function() {
+  it('expect _dateDiff to return "in 1 month"', function () {
     i18next.changeLanguage('en');
     const unit = 'month';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-17T00:00:00', '1996-11-16T00:00:00', hash);
     assert.equal(`in 1 ${unit}`, res);
   });
 
-  it('expect function _dateDiff to return "1 month ago"', function() {
+  it('expect _dateDiff to return "1 month ago"', function () {
     i18next.changeLanguage('en');
     const unit = 'month';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-11-16T00:00:00', '1996-12-17T00:00:00', hash);
     assert.equal(`1 ${unit} ago`, res);
   });
 
   // -- Test week -- //
 
-  it('expect function _dateDiff to return "in 1 week"', function() {
+  it('expect _dateDiff to return "in 1 week"', function () {
     i18next.changeLanguage('en');
     const unit = 'week';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-08T00:00:00', '1996-12-01T00:00:00', hash);
     assert.equal(`in 1 ${unit}`, res);
   });
 
-  it('expect function _dateDiff to return "1 week ago"', function() {
+  it('expect _dateDiff to return "1 week ago"', function () {
     i18next.changeLanguage('en');
     const unit = 'week';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-01T00:00:00', '1996-12-08T00:00:00', hash);
     assert.equal(`1 ${unit} ago`, res);
   });
 
   // -- Test day -- //
 
-  it('expect function _dateDiff to return "in 1 day"', function() {
+  it('expect _dateDiff to return "in 1 day"', function () {
     i18next.changeLanguage('en');
     const unit = 'day';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-08T00:00:00', '1996-12-07T00:00:00', hash);
     assert.equal(`in 1 ${unit}`, res);
   });
 
-  it('expect function _dateDiff to return "1 day ago"', function() {
+  it('expect _dateDiff to return "1 day ago"', function () {
     i18next.changeLanguage('en');
     const unit = 'day';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-07T00:00:00', '1996-12-08T00:00:00', hash);
     assert.equal(`1 ${unit} ago`, res);
   });
 
   // -- Test minute -- //
 
-  it('expect function _dateDiff to return "in 1 minute"', function() {
+  it('expect _dateDiff to return "in 1 minute"', function () {
     i18next.changeLanguage('en');
     const unit = 'minute';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-08T00:01:00', '1996-12-08T00:00:00', hash);
     assert.equal(`in 1 ${unit}`, res);
   });
 
-  it('expect function _dateDiff to return "1 minute ago"', function() {
+  it('expect _dateDiff to return "1 minute ago"', function () {
     i18next.changeLanguage('en');
     const unit = 'minute';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-08T00:00:00', '1996-12-08T00:01:00', hash);
     assert.equal(`1 ${unit} ago`, res);
   });
 
   // -- Test second -- //
 
-  it('expect function _dateDiff to return "in 1 second"', function() {
+  it('expect _dateDiff to return "in 1 second"', function () {
     i18next.changeLanguage('en');
     const unit = 'second';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-08T00:00:01', '1996-12-08T00:00:00', hash);
     assert.equal(`in 1 ${unit}`, res);
   });
 
-  it('expect function _dateDiff to return "1 second ago"', function() {
+  it('expect _dateDiff to return "1 second ago"', function () {
     i18next.changeLanguage('en');
     const unit = 'second';
-    const hash = { hash: { localeMatcher: "best fit", numeric: "always", style: "long", unit: unit } };
+    const hash = {hash: {localeMatcher: "best fit", numeric: "always", style: "long", unit: unit}};
     const res = hI18n.helpers._dateDiff('1996-12-08T00:00:00', '1996-12-08T00:00:01', hash);
     assert.equal(`1 ${unit} ago`, res);
   });
@@ -463,27 +638,27 @@ describe('handlebars-i18n Tests', function() {
    Tests against function _num
    ****************************************/
 
-  it('function _num should return comma separated triples of decimals when language is "en"', function() {
+  it('_num should return comma separated triples of decimals when language is "en"', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: {} });
+    const res = hI18n.helpers._num(4000000, {hash: {}});
     assert.equal('4,000,000', res);
   });
 
-  it('function _num should return dot separated triples of decimals when language is "de"', function() {
+  it('_num should return dot separated triples of decimals when language is "de"', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._num(4000000, { hash: {} });
+    const res = hI18n.helpers._num(4000000, {hash: {}});
     assert.equal('4.000.000', res);
   });
 
-  it('function _num should return comma separated triples of decimals and 2 fraction digits"', function() {
+  it('_num should return comma separated triples of decimals and 2 fraction digits"', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { minimumFractionDigits : 2 } });
+    const res = hI18n.helpers._num(4000000, {hash: {minimumFractionDigits: 2}});
     assert.equal('4,000,000.00', res);
   });
 
-  it('function _num should return dot separated triples of decimals and 2 fraction digits when language is "de"', function() {
+  it('_num should return dot separated triples of decimals and 2 fraction digits when language is "de"', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._num(4000000, { hash: { minimumFractionDigits : 2 } });
+    const res = hI18n.helpers._num(4000000, {hash: {minimumFractionDigits: 2}});
     assert.equal('4.000.000,00', res);
   });
 
@@ -492,28 +667,28 @@ describe('handlebars-i18n Tests', function() {
    Tests against function _price
    ****************************************/
 
-  it('function _currency should return price in € written in comma separated triples of decimals and 2 fraction digits with leading currency symbol', function() {
+  it('_currency should return price in € written in comma separated triples of decimals and 2 fraction digits with leading currency symbol', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(4000000, { hash: {} });
+    const res = hI18n.helpers._price(4000000, {hash: {}});
     assert.equal('€4,000,000.00', res);
   });
 
-  it('function _currency should return price in € written in dot separated triples of decimals and 2 fraction digits with trailing currency symbol', function() {
+  it('_currency should return price in € written in dot separated triples of decimals and 2 fraction digits with trailing currency symbol', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._price(4000000, { hash: {} });
+    const res = hI18n.helpers._price(4000000, {hash: {}});
     assert.isString(res);
     assert.equal('4.000.000,00 €', res);
   });
 
-  it('function _currency should return price in ¥ written in comma separated triples of decimals with leading currency symbol', function() {
+  it('_currency should return price in ¥ written in comma separated triples of decimals with leading currency symbol', function () {
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(4000000, { hash: { currency: 'JPY', maximumFractionDigits: 0 } });
+    const res = hI18n.helpers._price(4000000, {hash: {currency: 'JPY', maximumFractionDigits: 0}});
     assert.equal('¥4,000,000', res);
   });
 
-  it('function _currency should return price in ¥ written in comma separated triples of decimals with trailing currency symbol', function() {
+  it('_currency should return price in ¥ written in comma separated triples of decimals with trailing currency symbol', function () {
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._price(4000000, { hash: { currency: 'JPY', maximumFractionDigits: 0 } });
+    const res = hI18n.helpers._price(4000000, {hash: {currency: 'JPY', maximumFractionDigits: 0}});
     assert.equal('4.000.000 ¥', res);
   });
 
@@ -522,53 +697,57 @@ describe('handlebars-i18n Tests', function() {
    Tests against method configure()
    ****************************************/
 
-  it('method configure() should return false if called without argument', function() {
+  it('method configure() should return false if called without argument', function () {
     const configure = HandlebarsI18n.configure();
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return false if called with empty array []', function() {
+  it('method configure() should return false if called with empty array []', function () {
     const configure = HandlebarsI18n.configure([]);
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return false if called with only one argument', function() {
+  it('method configure() should return false if called with only one argument', function () {
     const configure = HandlebarsI18n.configure('en');
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return false if called with language argument and invalid second argument', function() {
+  it('method configure() should return false if called with language argument and invalid second argument', function () {
     const configure = HandlebarsI18n.configure('en', 'somestrangeinput');
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return false if called with language argument "en" and second argument "DateTimeFormat" and Number (invalid argument) as third', function() {
+  it('method configure() should return false if called with language argument "en" and second argument "DateTimeFormat" and Number (invalid argument) as third', function () {
     const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', 12);
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return true if called with language argument "en" and second argument "DateTimeFormat" and options object as third argument', function() {
-    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', { year:'numeric' } );
+  it('method configure() should return true if called with language argument "en" and second argument "DateTimeFormat" and options object as third argument', function () {
+    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', {year: 'numeric'});
     assert.isOk(configure);
   });
 
-  it('method configure() should return true if called with arguments "en", "DateTimeFormat", { year:"numeric" } and a string as custom configuration name', function() {
-    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', { year:'numeric' }, "my-custom-conf" );
+  it('method configure() should return true if called with arguments "en", "DateTimeFormat", { year:"numeric" } and a string as custom configuration name', function () {
+    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', {year: 'numeric'}, "my-custom-conf");
     assert.isOk(configure);
   });
 
-  it('method configure() should return false if called with arguments "en", "DateTimeFormat", { year:"numeric" } and an additional object (invalid argument)', function() {
-    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', { year:'numeric' }, {} );
+  it('method configure() should return false if called with arguments "en", "DateTimeFormat", { year:"numeric" } and an additional object (invalid argument)', function () {
+    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', {year: 'numeric'}, {});
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return false if called with arguments "en", "DateTimeFormat", { year:"numeric" } and an additional empty string (invalid argument)', function() {
-    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', { year:'numeric' }, "" );
+  it('method configure() should return false if called with arguments "en", "DateTimeFormat", { year:"numeric" } and an additional empty string (invalid argument)', function () {
+    const configure = HandlebarsI18n.configure('en', 'DateTimeFormat', {year: 'numeric'}, "");
     assert.isNotOk(configure);
   });
 
-  it('method configure() should return true if called with arguments "en", "RelativeTimeFormat", { localeMatcher: "best fit", numeric: "always", style: "long" }', function() {
-    const configure = HandlebarsI18n.configure('en', 'RelativeTimeFormat', { localeMatcher: "best fit", numeric: "always", style: "long" } );
+  it('method configure() should return true if called with arguments "en", "RelativeTimeFormat", { localeMatcher: "best fit", numeric: "always", style: "long" }', function () {
+    const configure = HandlebarsI18n.configure('en', 'RelativeTimeFormat', {
+      localeMatcher: "best fit",
+      numeric: "always",
+      style: "long"
+    });
     assert.isOk(configure);
   });
 
@@ -577,13 +756,13 @@ describe('handlebars-i18n Tests', function() {
    Tests against method reset()
    ****************************************/
 
-  it('method reset() should return TRUE if called', function() {
+  it('method reset() should return TRUE if called', function () {
     const res = HandlebarsI18n.reset();
     assert.isOk(res);
   });
 
-  it('function _num should return Intl standard format (no fraction digits) after reset() being called', function() {
-    HandlebarsI18n.configure('en', 'NumberFormat', { minimumFractionDigits:4 } );
+  it('_num should return Intl standard format (no fraction digits) after reset() being called', function () {
+    HandlebarsI18n.configure('en', 'NumberFormat', {minimumFractionDigits: 4});
     i18next.changeLanguage('en');
     HandlebarsI18n.reset();
     const res = hI18n.helpers._num(4000000);
@@ -595,74 +774,74 @@ describe('handlebars-i18n Tests', function() {
    Tests for custom format configurations for function _date
    ********************************************************************/
 
-  it('function _date when called after configure() with defined custom format (year:2-digit) should return ' +
-    'date "95" when language is "en"', function() {
-    HandlebarsI18n.configure('en', 'DateTimeFormat', { year:"2-digit" }, 'my-custom-format');
+  it('_date when called after configure() with defined custom format (year:2-digit) should return ' +
+    'date "95" when language is "en"', function () {
+    HandlebarsI18n.configure('en', 'DateTimeFormat', {year: "2-digit"}, 'my-custom-format');
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('December 17, 1995 03:24:00', { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._date('December 17, 1995 03:24:00', {hash: {format: 'my-custom-format'}});
     assert.equal('95', res);
   });
 
-  it('function _date when called after configure() with defined custom format (year:numeric) given as ARRAY should return ' +
-    'date "12/17/95" when language is "en"', function() {
-    HandlebarsI18n.configure(['en', 'DateTimeFormat', { year:"numeric" }, 'my-custom-format']);
+  it('_date when called after configure() with defined custom format (year:numeric) given as ARRAY should return ' +
+    'date "12/17/95" when language is "en"', function () {
+    HandlebarsI18n.configure(['en', 'DateTimeFormat', {year: "numeric"}, 'my-custom-format']);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('December 17, 1995 03:24:00', { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._date('December 17, 1995 03:24:00', {hash: {format: 'my-custom-format'}});
     assert.equal('95', res);
   });
 
-  it('function _date when called after configure() with defined custom format (year:2-digit) should override ' +
-    'standard configuration when language is "en"', function() {
+  it('_date when called after configure() with defined custom format (year:2-digit) should override ' +
+    'standard configuration when language is "en"', function () {
     HandlebarsI18n.configure([
-      ['en', 'DateTimeFormat', { year:"numeric" }],
-      ['en', 'DateTimeFormat', { year:"2-digit" }, 'my-custom-format']
+      ['en', 'DateTimeFormat', {year: "numeric"}],
+      ['en', 'DateTimeFormat', {year: "2-digit"}, 'my-custom-format']
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('[1995,11,17]', { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._date('[1995,11,17]', {hash: {format: 'my-custom-format'}});
     assert.equal('95', res);
   });
 
-  it('function _date when called after configure() with defined custom format (year:2-digit) should override ' +
-    'standard configuration also when being defined first', function() {
+  it('_date when called after configure() with defined custom format (year:2-digit) should override ' +
+    'standard configuration also when being defined first', function () {
     HandlebarsI18n.configure([
-      ['en', 'DateTimeFormat', { year:"2-digit" }, 'my-custom-format'],
-      ['en', 'DateTimeFormat', { year:"numeric" }]
+      ['en', 'DateTimeFormat', {year: "2-digit"}, 'my-custom-format'],
+      ['en', 'DateTimeFormat', {year: "numeric"}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('December 17, 1995 03:24:00', { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._date('December 17, 1995 03:24:00', {hash: {format: 'my-custom-format'}});
     assert.equal('95', res);
   });
 
-  it('function _date when called after configure() should fall back to generic language format "en" when custom format is unknown' +
-    'standard configuration also when being defined first', function() {
+  it('_date when called after configure() should fall back to generic language format "en" when custom format is unknown' +
+    'standard configuration also when being defined first', function () {
     HandlebarsI18n.configure([
-      ['en', 'DateTimeFormat', { year:"2-digit" }, 'my-custom-format'],
-      ['en', 'DateTimeFormat', { year:"numeric" }]
+      ['en', 'DateTimeFormat', {year: "2-digit"}, 'my-custom-format'],
+      ['en', 'DateTimeFormat', {year: "numeric"}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('December 17, 1995 03:24:00', { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._date('December 17, 1995 03:24:00', {hash: {format: 'my-unknown-format'}});
     assert.equal('1995', res);
   });
 
-  it('function _date when called after configure() should fall back to generic language format "all" when custom format is unknown' +
-    'standard configuration also when being defined first', function() {
+  it('_date when called after configure() should fall back to generic language format "all" when custom format is unknown' +
+    'standard configuration also when being defined first', function () {
     HandlebarsI18n.configure([
-      ['all', 'DateTimeFormat', { year:"2-digit" }, 'my-custom-format'],
-      ['en', 'DateTimeFormat', { year:"numeric" }]
+      ['all', 'DateTimeFormat', {year: "2-digit"}, 'my-custom-format'],
+      ['en', 'DateTimeFormat', {year: "numeric"}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('December 17, 1995 03:24:00', { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._date('December 17, 1995 03:24:00', {hash: {format: 'my-unknown-format'}});
     assert.equal('1995', res);
   });
 
-  it('function _date when called after configure() should fall back to Intl default format when custom format is unknown' +
-    'standard configuration also when being defined first', function() {
+  it('_date when called after configure() should fall back to Intl default format when custom format is unknown' +
+    'standard configuration also when being defined first', function () {
     HandlebarsI18n.reset();
     HandlebarsI18n.configure([
-      ['en', 'DateTimeFormat', { year:"2-digit" }, 'my-custom-format']
+      ['en', 'DateTimeFormat', {year: "2-digit"}, 'my-custom-format']
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._date('December 17, 1995 03:24:00', { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._date('December 17, 1995 03:24:00', {hash: {format: 'my-unknown-format'}});
     assert.equal('12/17/1995', res);
   });
 
@@ -671,52 +850,52 @@ describe('handlebars-i18n Tests', function() {
    Tests for custom format configurations for _dateRel / _dateDiff
    ********************************************************************/
 
-  it('function _dateRel called after configure() with defined "all" (style: "long", unit: "second") should return ' +
-    '"in 12 seconds" when language is "en"', function() {
-    HandlebarsI18n.configure('all', 'RelativeTimeFormat', { style: "long", unit: "second" });
+  it('_dateRel called after configure() with defined "all" (style: "long", unit: "second") should return ' +
+    '"in 12 seconds" when language is "en"', function () {
+    HandlebarsI18n.configure('all', 'RelativeTimeFormat', {style: "long", unit: "second"});
     i18next.changeLanguage('en');
     const res = hI18n.helpers._dateRel('12');
     assert.equal('in 12 seconds', res);
   });
 
-  it('function _dateRel called after configure() with defined custom format (style: "long", unit: "year") should return ' +
-    '"in 12 Jahren" when language is "de"', function() {
-    HandlebarsI18n.configure('de', 'RelativeTimeFormat', { style: "long", unit: "year" }, 'date-rel-custom');
+  it('_dateRel called after configure() with defined custom format (style: "long", unit: "year") should return ' +
+    '"in 12 Jahren" when language is "de"', function () {
+    HandlebarsI18n.configure('de', 'RelativeTimeFormat', {style: "long", unit: "year"}, 'date-rel-custom');
     i18next.changeLanguage('de');
-    const res = hI18n.helpers._dateRel('12', { hash: { format: 'date-rel-custom'} });
+    const res = hI18n.helpers._dateRel('12', {hash: {format: 'date-rel-custom'}});
     assert.equal('in 12 Jahren', res);
   });
 
-  it('function _dateRel called after configure() with defined custom format { style: "short", unit: "minutes" } should override ' +
-    'standard configuration when language is "en"', function() {
+  it('_dateRel called after configure() with defined custom format { style: "short", unit: "minutes" } should override ' +
+    'standard configuration when language is "en"', function () {
     HandlebarsI18n.configure([
-      ['en', 'RelativeTimeFormat', { style: "short", unit: "day" }, 'date-rel-spec'],
-      ['en', 'RelativeTimeFormat', { style: "long", unit: "second" }]
+      ['en', 'RelativeTimeFormat', {style: "short", unit: "day"}, 'date-rel-spec'],
+      ['en', 'RelativeTimeFormat', {style: "long", unit: "second"}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._dateRel('12', { hash: { format: 'date-rel-spec'} });
+    const res = hI18n.helpers._dateRel('12', {hash: {format: 'date-rel-spec'}});
     assert.equal('in 12 days', res);
   });
 
-  it('function _dateRel called after configure() with defined custom format { style: "short", unit: "minutes" } should override ' +
-    'standard configuration when language is "en" and output: \'in 12 days\'', function() {
+  it('_dateRel called after configure() with defined custom format { style: "short", unit: "minutes" } should override ' +
+    'standard configuration when language is "en" and output: \'in 12 days\'', function () {
     HandlebarsI18n.configure([
-      ['en', 'RelativeTimeFormat', { style: "short", unit: "day" }, 'date-rel-spec'],
-      ['en', 'RelativeTimeFormat', { style: "long", unit: "second" }]
+      ['en', 'RelativeTimeFormat', {style: "short", unit: "day"}, 'date-rel-spec'],
+      ['en', 'RelativeTimeFormat', {style: "long", unit: "second"}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._dateRel('12', { hash: { format: 'date-rel-spec'} });
+    const res = hI18n.helpers._dateRel('12', {hash: {format: 'date-rel-spec'}});
     assert.equal('in 12 days', res);
   });
 
-  it('function _dateDiff called after configure() with defined custom format { style: "short", unit: "minutes" } should override ' +
-    'standard configuration when language is "en" and output: \'in in 1 yr.\'', function() {
+  it('_dateDiff called after configure() with defined custom format { style: "short", unit: "minutes" } should override ' +
+    'standard configuration when language is "en" and output: \'in in 1 yr.\'', function () {
     HandlebarsI18n.configure([
-      ['en', 'RelativeTimeFormat', { style: "short", unit: "year" }, 'date-rel-spec'],
-      ['en', 'RelativeTimeFormat', { style: "long", unit: "day" }]
+      ['en', 'RelativeTimeFormat', {style: "short", unit: "year"}, 'date-rel-spec'],
+      ['en', 'RelativeTimeFormat', {style: "long", unit: "day"}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._dateDiff('1996-12-17T00:00:00', '1995-12-17T00:00:00',{ hash: { format: 'date-rel-spec'} });
+    const res = hI18n.helpers._dateDiff('1996-12-17T00:00:00', '1995-12-17T00:00:00', {hash: {format: 'date-rel-spec'}});
     assert.equal('in 1 yr.', res);
   });
 
@@ -725,71 +904,71 @@ describe('handlebars-i18n Tests', function() {
    Tests for custom format configurations for function _num
    ********************************************************************/
 
-  it('function _num when called after configure() with defined custom format (minimumFractionDigits:4) should return ' +
-    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function() {
-    HandlebarsI18n.configure('en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format');
+  it('_num when called after configure() with defined custom format (minimumFractionDigits:4) should return ' +
+    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function () {
+    HandlebarsI18n.configure('en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format');
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-custom-format'}});
     assert.equal('4,000,000.0000', res);
   });
 
-  it('function _num when called after configure() with defined custom format (minimumFractionDigits:4) given as ARRAY should return ' +
-    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function() {
-    HandlebarsI18n.configure(['en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format']);
+  it('_num when called after configure() with defined custom format (minimumFractionDigits:4) given as ARRAY should return ' +
+    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function () {
+    HandlebarsI18n.configure(['en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format']);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-custom-format'}});
     assert.equal('4,000,000.0000', res);
   });
 
-  it('function _num when called after configure() with defined custom format (minimumFractionDigits:4) should override' +
-    'standard configuration when language is "en"', function() {
+  it('_num when called after configure() with defined custom format (minimumFractionDigits:4) should override' +
+    'standard configuration when language is "en"', function () {
     HandlebarsI18n.configure([
-      ['en', 'NumberFormat', { maximumFractionDigits:1 }],
-      ['en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format']
+      ['en', 'NumberFormat', {maximumFractionDigits: 1}],
+      ['en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format']
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-custom-format'}});
     assert.equal('4,000,000.0000', res);
   });
 
-  it('function _num when called after configure() with defined custom format (minimumFractionDigits:4) should override' +
-    'standard configuration also when being defined first', function() {
+  it('_num when called after configure() with defined custom format (minimumFractionDigits:4) should override' +
+    'standard configuration also when being defined first', function () {
     HandlebarsI18n.configure([
-      ['en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format'],
-      ['en', 'NumberFormat', { maximumFractionDigits:1 }]
+      ['en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format'],
+      ['en', 'NumberFormat', {maximumFractionDigits: 1}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-custom-format'}});
     assert.equal('4,000,000.0000', res);
   });
 
-  it('function _num when called after configure() should fall back to standard language format "en" when custom format is unknown', function() {
+  it('_num when called after configure() should fall back to standard language format "en" when custom format is unknown', function () {
     HandlebarsI18n.configure([
-      ['en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format'],
-      ['en', 'NumberFormat', { minimumFractionDigits:1 }]
+      ['en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format'],
+      ['en', 'NumberFormat', {minimumFractionDigits: 1}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-unknown-format'}});
     assert.equal('4,000,000.0', res);
   });
 
-  it('function _num when called after configure() should fall back to standard language format "all" when custom format is unknown', function() {
+  it('_num when called after configure() should fall back to standard language format "all" when custom format is unknown', function () {
     HandlebarsI18n.configure([
-      ['en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format'],
-      ['all', 'NumberFormat', { minimumFractionDigits:1 }]
+      ['en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format'],
+      ['all', 'NumberFormat', {minimumFractionDigits: 1}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-unknown-format'}});
     assert.equal('4,000,000.0', res);
   });
 
-  it('function _num when called after configure() should fall back to Intl default when custom format is unknown', function() {
+  it('_num when called after configure() should fall back to Intl default when custom format is unknown', function () {
     HandlebarsI18n.reset();
     HandlebarsI18n.configure([
-      ['en', 'NumberFormat', { minimumFractionDigits:4 }, 'my-custom-format']
+      ['en', 'NumberFormat', {minimumFractionDigits: 4}, 'my-custom-format']
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._num(4000000, { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._num(4000000, {hash: {format: 'my-unknown-format'}});
     assert.equal('4,000,000', res);
   });
 
@@ -798,78 +977,78 @@ describe('handlebars-i18n Tests', function() {
    Tests for custom format configurations for function _price
    ********************************************************************/
 
-  it('function _price when called after configure() with defined custom format (minimumFractionDigits:4) should return ' +
-    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function() {
-    HandlebarsI18n.configure('en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format');
+  it('_price when called after configure() with defined custom format (minimumFractionDigits:4) should return ' +
+    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function () {
+    HandlebarsI18n.configure('en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format');
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-custom-format'}});
     assert.equal('€2.000', res);
   });
 
-  it('function _price when called after configure() with defined custom format (minimumFractionDigits:4) should return ' +
-    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function() {
-    HandlebarsI18n.configure('en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format');
+  it('_price when called after configure() with defined custom format (minimumFractionDigits:4) should return ' +
+    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function () {
+    HandlebarsI18n.configure('en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format');
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-custom-format'}});
     assert.equal('€2.000', res);
   });
 
-  it('function _price when called after configure() with defined custom format (minimumFractionDigits:4) given as ARRAY should return ' +
-    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function() {
-    HandlebarsI18n.configure(['en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format']);
+  it('_price when called after configure() with defined custom format (minimumFractionDigits:4) given as ARRAY should return ' +
+    'comma separated triples of decimals and 4 fraction of digits when language is "en"', function () {
+    HandlebarsI18n.configure(['en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format']);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-custom-format'}});
     assert.equal('€2.000', res);
   });
 
-  it('function _price when called after configure() with defined custom format (minimumFractionDigits:3) should override' +
-    'standard configuration when language is "en"', function() {
+  it('_price when called after configure() with defined custom format (minimumFractionDigits:3) should override' +
+    'standard configuration when language is "en"', function () {
     HandlebarsI18n.configure([
-      ['en', 'PriceFormat', { currency:'USD'}],
-      ['en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format']
+      ['en', 'PriceFormat', {currency: 'USD'}],
+      ['en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format']
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-custom-format'}});
     assert.equal('€2.000', res);
   });
 
-  it('function _price when called after configure() with defined custom format (minimumFractionDigits:3) should override' +
-    'standard configuration also when being defined first', function() {
+  it('_price when called after configure() with defined custom format (minimumFractionDigits:3) should override' +
+    'standard configuration also when being defined first', function () {
     HandlebarsI18n.configure([
-      ['en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format'],
-      ['en', 'PriceFormat', { currency:'USD'}]
+      ['en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format'],
+      ['en', 'PriceFormat', {currency: 'USD'}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-custom-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-custom-format'}});
     assert.equal('€2.000', res);
   });
 
-  it('function _price when called after configure() should fall back to standard language format "en" when custom format is unknown', function() {
+  it('_price when called after configure() should fall back to standard language format "en" when custom format is unknown', function () {
     HandlebarsI18n.configure([
-      ['en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format'],
-      ['en', 'PriceFormat', { currency:'USD'}]
+      ['en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format'],
+      ['en', 'PriceFormat', {currency: 'USD'}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-unknown-format'}});
     assert.equal('$2.00', res);
   });
 
-  it('function _price when called after configure() should fall back to standard language format "all" when custom format is unknown', function() {
+  it('_price when called after configure() should fall back to standard language format "all" when custom format is unknown', function () {
     HandlebarsI18n.configure([
-      ['en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format'],
-      ['all', 'PriceFormat', { currency:'USD'}]
+      ['en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format'],
+      ['all', 'PriceFormat', {currency: 'USD'}]
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-unknown-format'}});
     assert.equal('$2.00', res);
   });
 
-  it('function _price when called after configure() should fall back to Intl default when custom format is unknown', function() {
+  it('_price when called after configure() should fall back to Intl default when custom format is unknown', function () {
     HandlebarsI18n.configure([
-      ['en', 'PriceFormat', { currency:'EUR', minimumFractionDigits:3 }, 'my-custom-format']
+      ['en', 'PriceFormat', {currency: 'EUR', minimumFractionDigits: 3}, 'my-custom-format']
     ]);
     i18next.changeLanguage('en');
-    const res = hI18n.helpers._price(2, { hash: { format: 'my-unknown-format'} });
+    const res = hI18n.helpers._price(2, {hash: {format: 'my-unknown-format'}});
     assert.equal('$2.00', res);
   });
 
@@ -895,12 +1074,12 @@ describe('handlebars-i18n Private helper Function Tests (in production not expor
     expect(instance.b).to.equal(2);
   });
 
- /* it('should handle no arguments', () => {
-    const instance = HandlebarsI18n.private.applyToConstructor(TestConstructor, []);
-    expect(instance).to.be.an.instanceof(TestConstructor);
-    expect(instance.a).to.equal(null);
-    expect(instance.b).to.equal(undefined); // because 'undefined' is passed as second argument
-  });*/
+  /* it('should handle no arguments', () => {
+     const instance = HandlebarsI18n.private.applyToConstructor(TestConstructor, []);
+     expect(instance).to.be.an.instanceof(TestConstructor);
+     expect(instance.a).to.equal(null);
+     expect(instance.b).to.equal(undefined); // because 'undefined' is passed as second argument
+   });*/
 
   it('should handle constructor with no arguments', () => {
     function ConstructorWithNoArgs() {
@@ -920,6 +1099,7 @@ describe('handlebars-i18n Private helper Function Tests (in production not expor
     }
 
     const args = [new ComplexArgument(5)];
+
     function ConstructorWithComplexArg(arg) {
       this.arg = arg;
     }
@@ -944,12 +1124,12 @@ describe('handlebars-i18n Private helper Function Tests (in production not expor
   const lang = 'en';
   const OCFormat = {
     standard: {
-      en: { /* Standard configuration for English */ },
-      all: { /* Universal configuration for all languages */ }
+      en: { /* Standard configuration for English */},
+      all: { /* Universal configuration for all languages */}
     },
     custom: {
       customFormat: {
-        en: { /* Custom configuration for English */ }
+        en: { /* Custom configuration for English */}
       }
     }
   };
@@ -985,5 +1165,4 @@ describe('handlebars-i18n Private helper Function Tests (in production not expor
     expect(result).to.deep.equal({});
   });
 
-
 });