@zohodesk/i18n 1.0.0-beta.3 → 1.0.0-beta.31

package/es/components/__tests__/DateTimeDiffFormat.spec.js

@@ -2,720 +2,931 @@ import DateTimeDiffFormat from '../DateTimeDiffFormat';
 import I18NProvider from '../I18NProvider';
 import React from 'react';
 import renderer from 'react-test-renderer';
-
-var tzData = {
+let tzData = {
   offsets: [154, 180],
   untils: [1013911200000, null]
 };
-
-var fromTzData = tzData,
+let fromTzData = tzData,
     toTzData = tzData;
+describe('DateTimeDiffFormat component', () => {
+  it('Should display yesterday - with same time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T06:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-24T05:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref;
 
-describe('DateTimeDiffFormat component', function () {
-  it('Should display yesterday - with same time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T06:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-24T05:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref) {
-          var years = _ref.years,
-              days = _ref.days,
-              hours = _ref.hours,
-              minutes = _ref.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display yesterday - less than 24 hour', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-24T06:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref2) {
-          var years = _ref2.years,
-              days = _ref2.days,
-              hours = _ref2.hours,
-              minutes = _ref2.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display yesterday - less than 24 hour', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-24T06:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref2 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref2;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display yesterday - greater than 24 hour', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-24T04:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref3) {
-          var years = _ref3.years,
-              days = _ref3.days,
-              hours = _ref3.hours,
-              minutes = _ref3.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display yesterday - greater than 24 hour', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-24T04:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref3 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref3;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display today key - same time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-25T05:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref4) {
-          var years = _ref4.years,
-              days = _ref4.days,
-              hours = _ref4.hours,
-              minutes = _ref4.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display today key - same time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-25T05:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref4 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref4;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
+  it('Should display today key - less than 24 hour', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-25T04:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref5 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref5;
 
-  it('Should display today key - less than 24 hour', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-25T04:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref5) {
-          var years = _ref5.years,
-              days = _ref5.days,
-              hours = _ref5.hours,
-              minutes = _ref5.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display today key -  greater than 24 hour', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-25T06:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref6) {
-          var years = _ref6.years,
-              days = _ref6.days,
-              hours = _ref6.hours,
-              minutes = _ref6.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display today key -  greater than 24 hour', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-25T06:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref6 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref6;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display tomorrow key - same time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-26T05:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref7) {
-          var years = _ref7.years,
-              days = _ref7.days,
-              hours = _ref7.hours,
-              minutes = _ref7.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display tomorrow key - same time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-26T05:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref7 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref7;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display tomorrow key - less than 24 hour', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-26T04:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref8) {
-          var years = _ref8.years,
-              days = _ref8.days,
-              hours = _ref8.hours,
-              minutes = _ref8.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display tomorrow key - less than 24 hour', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-26T04:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref8 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref8;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display tomorrow key -  greater than 24 hour', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-26T06:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref9) {
-          var years = _ref9.years,
-              days = _ref9.days,
-              hours = _ref9.hours,
-              minutes = _ref9.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display tomorrow key -  greater than 24 hour', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-26T06:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref9 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref9;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display other - same time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-23T05:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref10) {
-          var years = _ref10.years,
-              days = _ref10.days,
-              hours = _ref10.hours,
-              minutes = _ref10.minutes,
-              suffix = _ref10.suffix;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display other - same time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-23T05:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref10 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix
+        } = _ref10;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display other - greater time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-23T06:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref11) {
-          var years = _ref11.years,
-              days = _ref11.days,
-              hours = _ref11.hours,
-              minutes = _ref11.minutes,
-              suffix = _ref11.suffix;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display other - greater time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-23T06:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref11 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix
+        } = _ref11;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display other - less time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-23T04:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref12) {
-          var years = _ref12.years,
-              days = _ref12.days,
-              hours = _ref12.hours,
-              minutes = _ref12.minutes,
-              suffix = _ref12.suffix;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display other - less time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-23T04:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref12 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix
+        } = _ref12;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display other later- same time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-27T05:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref13) {
-          var years = _ref13.years,
-              days = _ref13.days,
-              hours = _ref13.hours,
-              minutes = _ref13.minutes,
-              suffix = _ref13.suffix,
-              isWithInAWeek = _ref13.isWithInAWeek;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display other later- same time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-27T05:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref13 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix,
+          isWithInAWeek
+        } = _ref13;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display other later- less time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-27T06:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref14) {
-          var years = _ref14.years,
-              days = _ref14.days,
-              hours = _ref14.hours,
-              minutes = _ref14.minutes,
-              suffix = _ref14.suffix;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display other later- less time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-27T06:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref14 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix
+        } = _ref14;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display other later- less time', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-27T04:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref15) {
-          var years = _ref15.years,
-              days = _ref15.days,
-              hours = _ref15.hours,
-              minutes = _ref15.minutes,
-              suffix = _ref15.suffix;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display other later- less time', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-27T04:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref15 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix
+        } = _ref15;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display others', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      { i18n: { today: 'today', yesterday: 'yesterday' } },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-11-27T05:55:28.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref16) {
-          var years = _ref16.years,
-              days = _ref16.days,
-              hours = _ref16.hours,
-              minutes = _ref16.minutes,
-              suffix = _ref16.suffix,
-              isWithInAWeek = _ref16.isWithInAWeek;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return '[less 7] DD-MM-YYYY';
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+  it('Should display others', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-11-27T05:55:28.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref16 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes,
+          suffix,
+          isWithInAWeek
+        } = _ref16;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
+        }
+
+        return '[less 7] DD-MM-YYYY';
+      },
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
+  it('Should display today1', () => {
+    let toDates = ['2016-10-24T05:55:28.000Z', '2016-10-24T06:55:28.000Z', '2016-10-24T04:55:28.000Z', '2016-10-25T05:55:28.000Z', '2016-10-25T04:55:28.000Z', '2016-10-25T06:55:28.000Z', '2016-10-26T05:55:28.000Z', '2016-10-26T04:55:28.000Z', '2016-10-26T06:55:28.000Z', '2016-10-23T05:55:28.000Z', '2016-10-23T04:55:28.000Z', '2016-10-23T06:55:28.000Z'];
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday',
+        now: 'noooow',
+        'support.1day.ago': '1day ago',
+        'support.1day.nhours.ago': 'one day {0} hours ago',
+        'support.1min.ago': '1min ago',
+        'support.nmins.ago': '{0} mins ago'
+      }
+    }, /*#__PURE__*/React.createElement("div", null, toDates.map((to, i) => /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      key: i,
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: to,
+      toTzData: toTzData,
+      format: (_ref17, pattern) => {
+        let {
+          years,
+          days,
+          months,
+          hours
+        } = _ref17;
+
+        switch (pattern) {
+          case '000000':
+          case '000001':
+          case '000002':
+            return {
+              key: 'now'
+            };
+            break;
+
+          case '000010':
+            return {
+              key: 'support.1min'
+            };
+            break;
+
+          case '000020':
+            return {
+              key: 'support.nmins',
+              params: ['m']
+            };
+            break;
 
-  it('Should display today1', function () {
-    var toDates = ['2016-10-24T05:55:28.000Z', '2016-10-24T06:55:28.000Z', '2016-10-24T04:55:28.000Z', '2016-10-25T05:55:28.000Z', '2016-10-25T04:55:28.000Z', '2016-10-25T06:55:28.000Z', '2016-10-26T05:55:28.000Z', '2016-10-26T04:55:28.000Z', '2016-10-26T06:55:28.000Z', '2016-10-23T05:55:28.000Z', '2016-10-23T04:55:28.000Z', '2016-10-23T06:55:28.000Z'];
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      {
-        i18n: {
-          today: 'today',
-          yesterday: 'yesterday',
-          now: 'noooow',
-          'support.1day.ago': '1day ago',
-          'support.1day.nhours.ago': 'one day {0} hours ago',
-          'support.1min.ago': '1min ago',
-          'support.nmins.ago': '{0} mins ago'
+          case '001000':
+          case '001100':
+            return {
+              key: 'support.1day'
+            };
+            break;
+
+          case '001200':
+          case '001201':
+            return {
+              key: 'support.1day.nhours',
+              params: ['h']
+            };
+            break;
         }
       },
-      React.createElement(
-        'div',
-        null,
-        toDates.map(function (to, i) {
-          return React.createElement(DateTimeDiffFormat, {
-            key: i,
-            from: '2016-10-25T05:55:28.000Z',
-            fromTzData: fromTzData,
-            to: to,
-            toTzData: toTzData,
-            format: function format(_ref17, pattern) {
-              var years = _ref17.years,
-                  days = _ref17.days,
-                  months = _ref17.months,
-                  hours = _ref17.hours;
-
-              switch (pattern) {
-                case '000000':
-                case '000001':
-                case '000002':
-                  return {
-                    key: 'now'
-                  };
-                  break;
-                case '000010':
-                  return {
-                    key: 'support.1min'
-                  };
-                  break;
-                case '000020':
-                  return {
-                    key: 'support.nmins',
-                    params: ['m']
-                  };
-                  break;
-                case '001000':
-                case '001100':
-                  return {
-                    key: 'support.1day'
-                  };
-                  break;
-                case '001200':
-                case '001201':
-                  return {
-                    key: 'support.1day.nhours',
-                    params: ['h']
-                  };
-                  break;
-              }
-            },
-            ago: 'ago',
-            later: 'later'
-          });
-        })
-      )
-    ));
-    var tree = ele.toJSON();
+      ago: "ago",
+      later: "later"
+    })))));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display today later', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      {
-        i18n: {
-          today: 'today',
-          yesterday: 'yesterday',
-          'today.later': '{0}:{1}:{2} later'
+  it('Should display today later', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday',
+        'today.later': '{0}:{1}:{2} later'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-25T05:55:29.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref18 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref18;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
         }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
       },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-25T05:55:29.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref18) {
-          var years = _ref18.years,
-              days = _ref18.days,
-              hours = _ref18.hours,
-              minutes = _ref18.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display today ago', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      {
-        i18n: {
-          today: 'today',
-          yesterday: 'yesterday',
-          'today.later': '{0}:{1}:{2} later',
-          'today.ago': '{0}:{1}:{2} ago'
+  it('Should display today ago', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        today: 'today',
+        yesterday: 'yesterday',
+        'today.later': '{0}:{1}:{2} later',
+        'today.ago': '{0}:{1}:{2} ago'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2016-10-25T05:55:30.000Z",
+      fromTzData: fromTzData,
+      to: "2016-10-25T05:55:29.000Z",
+      toTzData: toTzData,
+      today: {
+        key: 'today',
+        params: ['hh', 'mm', 'ss']
+      },
+      yesterday: {
+        key: 'yesterday',
+        params: ['hh', 'mm', 'ss']
+      },
+      tomorrow: {
+        key: 'tomorrow',
+        params: ['hh', 'mm', 'ss']
+      },
+      others: _ref19 => {
+        let {
+          years,
+          days,
+          hours,
+          minutes
+        } = _ref19;
+
+        if (days > 7) {
+          return 'DD-MM-YYYY';
         }
+
+        return getDateKeyWithParam(years, days, hours, minutes);
       },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2016-10-25T05:55:30.000Z',
-        fromTzData: fromTzData,
-        to: '2016-10-25T05:55:29.000Z',
-        toTzData: toTzData,
-        today: { key: 'today', params: ['hh', 'mm', 'ss'] },
-        yesterday: { key: 'yesterday', params: ['hh', 'mm', 'ss'] },
-        tomorrow: { key: 'tomorrow', params: ['hh', 'mm', 'ss'] },
-        others: function others(_ref19) {
-          var years = _ref19.years,
-              days = _ref19.days,
-              hours = _ref19.hours,
-              minutes = _ref19.minutes;
-
-          if (days > 7) {
-            return 'DD-MM-YYYY';
-          }
-          return getDateKeyWithParam(years, days, hours, minutes);
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display years and days', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      {
-        i18n: {
-          'nyear.ndays.ago': '{0} years {1} days ago',
-          yesterday: 'yesterday'
+  it('Should display years and days', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        'nyear.ndays.ago': '{0} years {1} days ago',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2017-10-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2015-08-25T05:55:28.000Z",
+      toTzData: toTzData,
+      format: (_ref20, pattern) => {
+        let {
+          years,
+          days,
+          months,
+          hours
+        } = _ref20;
+
+        if (years > 1) {
+          return {
+            key: 'nyear.ndays',
+            params: ['y', 'days']
+          };
         }
       },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2017-10-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2015-08-25T05:55:28.000Z',
-        toTzData: toTzData,
-        format: function format(_ref20, pattern) {
-          var years = _ref20.years,
-              days = _ref20.days,
-              months = _ref20.months,
-              hours = _ref20.hours;
-
-          if (years > 1) {
-            return {
-              key: 'nyear.ndays',
-              params: ['y', 'days']
-            };
-          }
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
-  it('Should display years and days1', function () {
-    var ele = renderer.create(React.createElement(
-      I18NProvider,
-      {
-        i18n: {
-          'nyear.ndays.later': '{0} years {1} days later',
-          yesterday: 'yesterday'
+  it('Should display years and days1', () => {
+    let ele = renderer.create( /*#__PURE__*/React.createElement(I18NProvider, {
+      i18n: {
+        'nyear.ndays.later': '{0} years {1} days later',
+        yesterday: 'yesterday'
+      }
+    }, /*#__PURE__*/React.createElement(DateTimeDiffFormat, {
+      from: "2015-08-25T05:55:28.000Z",
+      fromTzData: fromTzData,
+      to: "2017-10-25T05:55:28.000Z",
+      toTzData: toTzData,
+      format: (_ref21, pattern) => {
+        let {
+          years,
+          days,
+          months,
+          hours
+        } = _ref21;
+
+        if (years > 1) {
+          return {
+            key: 'nyear.ndays',
+            params: ['y', 'days']
+          };
         }
       },
-      React.createElement(DateTimeDiffFormat, {
-        from: '2015-08-25T05:55:28.000Z',
-        fromTzData: fromTzData,
-        to: '2017-10-25T05:55:28.000Z',
-        toTzData: toTzData,
-        format: function format(_ref21, pattern) {
-          var years = _ref21.years,
-              days = _ref21.days,
-              months = _ref21.months,
-              hours = _ref21.hours;
-
-          if (years > 1) {
-            return {
-              key: 'nyear.ndays',
-              params: ['y', 'days']
-            };
-          }
-        },
-        ago: 'ago',
-        later: 'later'
-      })
-    ));
-    var tree = ele.toJSON();
+      ago: "ago",
+      later: "later"
+    })));
+    let tree = ele.toJSON();
     expect(tree).toMatchSnapshot();
   });
 });