calcdate - npm Package Compare versions

Comparing version 1.0.2 to 2.0.0

bindings/date-fns.js

@@ -1,51 +0,9 @@
-import {
-  parseISO,
-  isValid,
-  differenceInMilliseconds,
-  isDate,
-  toDate,
-  addMilliseconds,
-  addSeconds,
-  addMinutes,
-  addHours,
-  addBusinessDays,
-  addDays,
-  addWeeks,
-  addMonths,
-  addQuarters,
-  addYears,
-  subMilliseconds,
-  subSeconds,
-  subMinutes,
-  subHours,
-  subBusinessDays,
-  subDays,
-  subWeeks,
-  subMonths,
-  subQuarters,
-  subYears
-} from "date-fns";
+export const datefns = /*#__PURE__*/ datefnslib => {
 
-const divTable = {
-  milliseconds: 1,
-  seconds: 1000,
-  minutes: 1000 * 60,
-  hours: 1000 * 60 * 60,
-  days: 1000 * 60 * 60 * 24,
-  weekdays: 1000 * 60 * 60 * 24,
-  weeks: 1000 * 60 * 60 * 24 * 7,
-  months: 1000 * 60 * 60 * 24 * 30.436875,
-  quarters: 1000 * 60 * 60 * 24 * 91.310625,
-  years: 1000 * 60 * 60 * 24 * 365.2425
-};
-Object.fromEntries =
-  Object.fromEntries ||
-  (arr =>
-    [...arr].reduce((obj, [key, val]) => {
-      obj[key] = val;
-      return obj;
-    }, {}));
-
-const ops = Object.fromEntries(
-  Object.entries({
+  const {
+    parseISO,
+    isValid,
+    differenceInMilliseconds,
+    isDate,
+    toDate,
     addMilliseconds,
@@ -55,3 +13,3 @@ addSeconds,
     addHours,
-    addWeekDays: addBusinessDays,
+    addBusinessDays,
     addDays,
@@ -66,3 +24,3 @@ addWeeks,
     subHours,
-    subWeekDays: subBusinessDays,
+    subBusinessDays,
     subDays,
@@ -72,238 +30,284 @@ subWeeks,
     subQuarters,
-    subYears,
+    subYears
+  } = datefnslib;
 
-    addUnitless: addMilliseconds,
-    subUnitless: subMilliseconds
-  }).map(([k, v]) => [k.toLowerCase(), v])
-);
-
-export const datefns = (
-  { NATIVEDATE, DATEXPRESION, DURATIONEXPRESSION, DURATIONOBJECT },
-  { console }
-) => {
-  const tostring = {
-    configurable: false,
-    enumerable: false,
-    writable: false,
-    value: function() {
-      return JSON.stringify(this);
-    }
+  const divTable = {
+    milliseconds: 1,
+    seconds: 1000,
+    minutes: 1000 * 60,
+    hours: 1000 * 60 * 60,
+    days: 1000 * 60 * 60 * 24,
+    weekdays: 1000 * 60 * 60 * 24,
+    weeks: 1000 * 60 * 60 * 24 * 7,
+    months: 1000 * 60 * 60 * 24 * 30.436875,
+    quarters: 1000 * 60 * 60 * 24 * 91.310625,
+    years: 1000 * 60 * 60 * 24 * 365.2425
   };
-  const isDurationConfig = {
-    configurable: false,
-    enumerable: false,
-    writable: false,
-    value: true
-  };
-  const isDurationSymbol = Symbol("isDuration");
-  const newDuration = () =>
-    Object.defineProperty(
-      Object.defineProperty({}, isDurationSymbol, isDurationConfig),
-      "toString",
-      tostring
-    );
-  const isDuration = x => x[isDurationSymbol] === true;
-  function makeDuration(arg) {
-    const isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
-    const match = isoRegex.exec(arg);
-    if (match) {
-      const sign = match[1] === "-" ? -1 : 1;
-      const parseFloatInIso = mat => {
-        const res = mat && parseFloat(mat.replace(",", "."));
-        return (isNaN(res) ? 0 : res) * sign;
-      };
-      return Object.assign(newDuration(), {
-        years: parseFloatInIso(match[2]),
-        months: parseFloatInIso(match[3]),
-        weeks: parseFloatInIso(match[4]),
-        days: parseFloatInIso(match[5]),
-        hours: parseFloatInIso(match[6]),
-        minutes: parseFloatInIso(match[7]),
-        seconds: parseFloatInIso(match[8])
-      });
-    }
-    try {
-      return Object.assign(newDuration(), JSON.parse(arg));
-    } catch (e) {
-      throw new Error("Found invalid duration " + arg);
-    }
-  }
+  Object.fromEntries =
+    Object.fromEntries ||
+    (arr =>
+      [...arr].reduce((obj, [key, val]) => {
+        obj[key] = val;
+        return obj;
+      }, {}));
 
-  const getType = arg => {
-    if (isValid(arg)) return "DATE";
-    if (isDuration(arg)) return "DURATION";
-    if (isDate(toDate(arg)) && !isValid(arg)) return "INVALID DATE";
-    return typeof arg;
-  };
-  const isUnitless = a => {
-    const keys = Object.keys(a);
-    return keys.length === 1 && keys[0] === "unitless";
-  };
+  const ops = Object.fromEntries(
+    Object.entries({
+      addMilliseconds,
+      addSeconds,
+      addMinutes,
+      addHours,
+      addWeekDays: addBusinessDays,
+      addDays,
+      addWeeks,
+      addMonths,
+      addQuarters,
+      addYears,
+      subMilliseconds,
+      subSeconds,
+      subMinutes,
+      subHours,
+      subWeekDays: subBusinessDays,
+      subDays,
+      subWeeks,
+      subMonths,
+      subQuarters,
+      subYears,
 
-  return {
-    makeDuration: (duration, { type }) => {
-      return {
-        [DURATIONEXPRESSION]: makeDuration,
-        [DURATIONOBJECT]: a => Object.assign(newDuration(), a)
-      }[type](duration);
-    },
-    makeDate: (date, { type }) => {
-      return {
-        [DATEXPRESION]: parseISO,
-        [NATIVEDATE]: d => d
-      }[type](date);
-    },
-    add: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless + b.unitless };
+      addUnitless: addMilliseconds,
+      subUnitless: subMilliseconds
+    }).map(([k, v]) => [k.toLowerCase(), v])
+  );
+
+  return (
+    { NATIVEDATE, DATEXPRESION, DURATIONEXPRESSION, DURATIONOBJECT },
+    { console }
+  ) => {
+    const tostring = {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: function() {
+        return JSON.stringify(this);
       }
-      if (isDuration(a) && isDuration(b)) {
-        return Object.entries(a).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: (p[k] || 0) + v
-            }),
-          b
-        );
-      }
-      if (isValid(a) && isValid(b)) {
-        throw new Error("Can't add dates to each other!");
-      }
-      if (isValid(a) && isDuration(b)) {
-        // b is duratoin
-        return Object.entries(b).reduce(
-          (date, [k, v]) => ops[`add${k}`](date, v),
-          a
-        );
-      }
-      if (isValid(b) && isDuration(a)) {
-        // a is duratoin
-        return Object.entries(a).reduce(
-          (date, [k, v]) => ops[`add${k}`](date, v),
-          b
-        );
-      }
-      const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${getType(
-        a
-      )}, ${getType(b)})`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    subtract: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless - b.unitless };
-      }
-      if (isDuration(a) && isDuration(b)) {
-        return Object.entries(a).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: (p[k] || 0) - v
-            }),
-          b
-        );
-      }
-      if (isValid(a) && isValid(b)) {
-        console.warn(
-          "subtracting two dates from each other is potentially unsafe as a loss of information occurs!"
-        );
+    };
+    const isDurationConfig = {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: true
+    };
+    const isDurationSymbol = Symbol("isDuration");
+    const newDuration = () =>
+      Object.defineProperty(
+        Object.defineProperty({}, isDurationSymbol, isDurationConfig),
+        "toString",
+        tostring
+      );
+    const isDuration = x => x[isDurationSymbol] === true;
+    function makeDuration(arg) {
+      const isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+      const match = isoRegex.exec(arg);
+      if (match) {
+        const sign = match[1] === "-" ? -1 : 1;
+        const parseFloatInIso = mat => {
+          const res = mat && parseFloat(mat.replace(",", "."));
+          return (isNaN(res) ? 0 : res) * sign;
+        };
         return Object.assign(newDuration(), {
-          milliseconds: differenceInMilliseconds(a, b)
+          years: parseFloatInIso(match[2]),
+          months: parseFloatInIso(match[3]),
+          weeks: parseFloatInIso(match[4]),
+          days: parseFloatInIso(match[5]),
+          hours: parseFloatInIso(match[6]),
+          minutes: parseFloatInIso(match[7]),
+          seconds: parseFloatInIso(match[8])
         });
       }
-      if (isValid(a) && isDuration(b)) {
-        // b is duratoin
-        return Object.entries(b).reduce(
-          (date, [k, v]) => ops[`sub${k}`](date, v),
+      try {
+        return Object.assign(newDuration(), JSON.parse(arg));
+      } catch (e) {
+        throw new Error("Found invalid duration " + arg);
+      }
+    }
+
+    const getType = arg => {
+      if (isValid(arg)) return "DATE";
+      if (isDuration(arg)) return "DURATION";
+      if (isDate(toDate(arg)) && !isValid(arg)) return "INVALID DATE";
+      return typeof arg;
+    };
+    const isUnitless = a => {
+      const keys = Object.keys(a);
+      return keys.length === 1 && keys[0] === "unitless";
+    };
+
+    return {
+      makeDuration: (duration, { type }) => {
+        return {
+          [DURATIONEXPRESSION]: makeDuration,
+          [DURATIONOBJECT]: a => Object.assign(newDuration(), a)
+        }[type](duration);
+      },
+      makeDate: (date, { type }) => {
+        return {
+          [DATEXPRESION]: parseISO,
+          [NATIVEDATE]: d => d
+        }[type](date);
+      },
+      add: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless + b.unitless };
+        }
+        if (isDuration(a) && isDuration(b)) {
+          return Object.entries(a).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: (p[k] || 0) + v
+              }),
+            b
+          );
+        }
+        if (isValid(a) && isValid(b)) {
+          throw new Error("Can't add dates to each other!");
+        }
+        if (isValid(a) && isDuration(b)) {
+          // b is duratoin
+          return Object.entries(b).reduce(
+            (date, [k, v]) => ops[`add${k}`](date, v),
+            a
+          );
+        }
+        if (isValid(b) && isDuration(a)) {
+          // a is duratoin
+          return Object.entries(a).reduce(
+            (date, [k, v]) => ops[`add${k}`](date, v),
+            b
+          );
+        }
+        const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${getType(
           a
-        );
+        )}, ${getType(b)})`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      subtract: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless - b.unitless };
+        }
+        if (isDuration(a) && isDuration(b)) {
+          return Object.entries(a).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: (p[k] || 0) - v
+              }),
+            b
+          );
+        }
+        if (isValid(a) && isValid(b)) {
+          console.warn(
+            "subtracting two dates from each other is potentially unsafe as a loss of information occurs!"
+          );
+          return Object.assign(newDuration(), {
+            milliseconds: differenceInMilliseconds(a, b)
+          });
+        }
+        if (isValid(a) && isDuration(b)) {
+          // b is duratoin
+          return Object.entries(b).reduce(
+            (date, [k, v]) => ops[`sub${k}`](date, v),
+            a
+          );
+        }
+        if (isValid(b) && isDuration(a)) {
+          // a is duratoin
+          return Object.entries(a).reduce(
+            (date, [k, v]) => ops[`sub${k}`](date, v),
+            b
+          );
+        }
+        const e = `Invalid arguments for 'subtract', expected (date, duration), (duration, date), (duration, duration) but found (${getType(
+          a
+        )}, ${getType(b)})`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      multiply: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless * b.unitless };
+        }
+        if (isDuration(a) && isUnitless(b)) {
+          return Object.entries(a).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * b.unitless
+              }),
+            newDuration()
+          );
+        }
+        if (isDuration(b) && isUnitless(a)) {
+          return Object.entries(b).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * a.unitless
+              }),
+            newDuration()
+          );
+        }
+        const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${getType(
+          a
+        )}, ${getType(b)})`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      divide: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless / b.unitless };
+        }
+        if (isDuration(a) && isUnitless(b)) {
+          return Object.entries(a).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v / b.unitless
+              }),
+            newDuration()
+          );
+        }
+        if (isDuration(b) && isUnitless(a)) {
+          return Object.entries(b).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: a.unitless / v
+              }),
+            newDuration()
+          );
+        }
+        if (isDuration(a) && isDuration(b)) {
+          console.warn(
+            `Dividing one duration by another is potentially unsafe! Assuming conversion table ${JSON.stringify(
+              divTable,
+              null,
+              "  "
+            )}!`
+          );
+          const bInMs = Object.entries(b).reduce(
+            (p, [k, v]) => p + divTable[k] * v,
+            0
+          );
+          const aInMs = Object.entries(a).reduce(
+            (p, [k, v]) => p + divTable[k] * v,
+            0
+          );
+          return { unitless: aInMs / bInMs };
+        }
+        const e = `Invalid arguments for divide, expected (duration, unitless) or (unitless, duration) but found (${getType(
+          a
+        )}, ${getType(b)})`;
+        console.error(e, a, b);
+        throw new Error(e);
       }
-      if (isValid(b) && isDuration(a)) {
-        // a is duratoin
-        return Object.entries(a).reduce(
-          (date, [k, v]) => ops[`sub${k}`](date, v),
-          b
-        );
-      }
-      const e = `Invalid arguments for 'subtract', expected (date, duration), (duration, date), (duration, duration) but found (${getType(
-        a
-      )}, ${getType(b)})`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    multiply: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless * b.unitless };
-      }
-      if (isDuration(a) && isUnitless(b)) {
-        return Object.entries(a).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * b.unitless
-            }),
-          newDuration()
-        );
-      }
-      if (isDuration(b) && isUnitless(a)) {
-        return Object.entries(b).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * a.unitless
-            }),
-          newDuration()
-        );
-      }
-      const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${getType(
-        a
-      )}, ${getType(b)})`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    divide: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless / b.unitless };
-      }
-      if (isDuration(a) && isUnitless(b)) {
-        return Object.entries(a).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v / b.unitless
-            }),
-          newDuration()
-        );
-      }
-      if (isDuration(b) && isUnitless(a)) {
-        return Object.entries(b).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: a.unitless / v
-            }),
-          newDuration()
-        );
-      }
-      if (isDuration(a) && isDuration(b)) {
-        console.warn(
-          `Dividing one duration by another is potentially unsafe! Assuming conversion table ${JSON.stringify(
-            divTable,
-            null,
-            "  "
-          )}!`
-        );
-        const bInMs = Object.entries(b).reduce(
-          (p, [k, v]) => p + divTable[k] * v,
-          0
-        );
-        const aInMs = Object.entries(a).reduce(
-          (p, [k, v]) => p + divTable[k] * v,
-          0
-        );
-        return { unitless: aInMs / bInMs };
-      }
-      const e = `Invalid arguments for divide, expected (duration, unitless) or (unitless, duration) but found (${getType(
-        a
-      )}, ${getType(b)})`;
-      console.error(e, a, b);
-      throw new Error(e);
-    }
+    };
   };
-};
+}
+
 export default datefns;

bindings/luxon.js

@@ -1,247 +0,341 @@
-import { DateTime, Interval, Duration } from "luxon";
+export const luxon = /*#__PURE__*/ luxonlib => {
+  const { DateTime, Interval, Duration } = luxonlib;
 
-const isUnitless = a => {
-  const keys = Object.keys(a);
-  return keys.length === 1 && keys[0] === "unitless";
-};
+  const isUnitless = a => {
+    const keys = Object.keys(a);
+    return keys.length === 1 && keys[0] === "unitless";
+  };
 
-export const luxon = (
-  {
-    NATIVEDATE,
-    DATEXPRESION,
-    DURATIONEXPRESSION,
-    DURATIONOBJECT,
-    INTERVALEXPRESION,
-    INTERVALOBJECT
-  },
-  { console }
-) => {
-  return {
-    makeInterval: (interval, { type }) => {
-      return {
-        [INTERVALEXPRESION]: text => {
-          return Interval.fromISO(text);
-        },
-        [INTERVALOBJECT]: ([from, to]) => {
-          if (DateTime.isDateTime(from) && DateTime.isDateTime(from)) {
-            return Interval.fromDateTimes(from, to);
-          }
-          if (DateTime.isDateTime(from) && Duration.isDuration(to)) {
-            return Interval.after(from, to);
-          }
-          if (DateTime.isDateTime(to) && Duration.isDuration(from)) {
-            return Interval.before(from, to);
-          }
-          const e = `Invalid arguments for 'makeInterval', expected (date, duration), (duration, date), (date, date) but found (${
-            from.invalidExplanation
-              ? `Invalid date ${from.invalidExplanation}`
-              : typeof from
-          }, ${
-            to.invalidExplanation
-              ? `Invalid date ${to.invalidExplanation}`
-              : typeof to
-          })`;
-          console.error(e, from, to);
-          throw new Error(e);
-        }
-      }[type](interval);
+  return (
+    {
+      NATIVEDATE,
+      DATEXPRESION,
+      DURATIONEXPRESSION,
+      DURATIONOBJECT,
+      INTERVALEXPRESION,
+      INTERVALOBJECT
     },
-    makeDuration: (duration, { type }) => {
-      return {
-        [DURATIONEXPRESSION]: a => {
-          try {
-            const maybedurationobject = JSON.parse(a);
-            if (Array.isArray(maybedurationobject)) {
-              return Duration.fromObject(
-                maybedurationobject[0],
-                Object.assign(
-                  { conversionAccuracy: "longterm" },
-                  maybedurationobject[1]
-                )
-              );
-            } else if (typeof maybedurationobject === "string") {
-              return Duration.fromISO(maybedurationobject, {
-                conversionAccuracy: "longterm"
-              });
-            } else if (typeof maybedurationobject === "number") {
-              return Duration.fromMillis(maybedurationobject, {
-                conversionAccuracy: "longterm"
-              });
-            } else {
-              return Duration.fromObject(maybedurationobject, {
-                conversionAccuracy: "longterm"
-              });
+    { console }
+  ) => {
+    return {
+      makeInterval: (interval, { type }) => {
+        return {
+          [INTERVALEXPRESION]: text => {
+            return Interval.fromISO(text);
+          },
+          [INTERVALOBJECT]: ([from, to]) => {
+            if (DateTime.isDateTime(from) && DateTime.isDateTime(from)) {
+              return Interval.fromDateTimes(from, to);
             }
-          } catch (e) {
-            return Duration.fromISO(a, { conversionAccuracy: "longterm" });
+            if (DateTime.isDateTime(from) && Duration.isDuration(to)) {
+              return Interval.after(from, to);
+            }
+            if (DateTime.isDateTime(to) && Duration.isDuration(from)) {
+              return Interval.before(from, to);
+            }
+            const e = `Invalid arguments for 'makeInterval', expected (date, duration), (duration, date), (date, date) but found (${
+              from.invalidExplanation
+                ? `Invalid date ${from.invalidExplanation}`
+                : typeof from
+            }, ${
+              to.invalidExplanation
+                ? `Invalid date ${to.invalidExplanation}`
+                : typeof to
+            })`;
+            console.error(e, from, to);
+            throw new Error(e);
           }
-        },
-        [DURATIONOBJECT]: o =>
-          Duration.fromObject(o, { conversionAccuracy: "longterm" })
-      }[type](duration);
-    },
-    makeDate: (date, { type }) => {
-      return {
-        [DATEXPRESION]: a => {
-          try {
-            const maybedateobject = JSON.parse(a);
-            if (Array.isArray(maybedateobject)) {
-              if (
-                typeof maybedateobject[0] === "string" &&
-                typeof maybedateobject[1] === "string"
-              ) {
-                return DateTime.fromFormat(
+        }[type](interval);
+      },
+      makeDuration: (duration, { type }) => {
+        return {
+          [DURATIONEXPRESSION]: a => {
+            try {
+              const maybedurationobject = JSON.parse(a);
+              if (Array.isArray(maybedurationobject)) {
+                return Duration.fromObject(
+                  maybedurationobject[0],
+                  Object.assign(
+                    { conversionAccuracy: "longterm" },
+                    maybedurationobject[1]
+                  )
+                );
+              } else if (typeof maybedurationobject === "string") {
+                return Duration.fromISO(maybedurationobject, {
+                  conversionAccuracy: "longterm"
+                });
+              } else if (typeof maybedurationobject === "number") {
+                return Duration.fromMillis(maybedurationobject, {
+                  conversionAccuracy: "longterm"
+                });
+              } else {
+                return Duration.fromObject(maybedurationobject, {
+                  conversionAccuracy: "longterm"
+                });
+              }
+            } catch (e) {
+              return Duration.fromISO(a, { conversionAccuracy: "longterm" });
+            }
+          },
+          [DURATIONOBJECT]: o =>
+            Duration.fromObject(o, { conversionAccuracy: "longterm" })
+        }[type](duration);
+      },
+      makeDate: (date, { type }) => {
+        return {
+          [DATEXPRESION]: a => {
+            try {
+              const maybedateobject = JSON.parse(a);
+              if (Array.isArray(maybedateobject)) {
+                if (
+                  typeof maybedateobject[0] === "string" &&
+                  typeof maybedateobject[1] === "string"
+                ) {
+                  return DateTime.fromFormat(
+                    maybedateobject[0],
+                    maybedateobject[1]
+                  );
+                }
+                return DateTime.fromObject(
                   maybedateobject[0],
                   maybedateobject[1]
                 );
+              } else if (typeof maybedateobject === "string") {
+                return DateTime.fromISO(maybedateobject);
+              } else if (typeof maybedateobject === "number") {
+                return DateTime.fromMillis(maybedateobject);
+              } else {
+                return DateTime.fromObject(maybedateobject);
               }
-              return DateTime.fromObject(
-                maybedateobject[0],
-                maybedateobject[1]
-              );
-            } else if (typeof maybedateobject === "string") {
-              return DateTime.fromISO(maybedateobject);
-            } else if (typeof maybedateobject === "number") {
-              return DateTime.fromMillis(maybedateobject);
-            } else {
-              return DateTime.fromObject(maybedateobject);
+            } catch (e) {
+              return DateTime.fromISO(a);
             }
-          } catch (e) {
-            return DateTime.fromISO(a);
+          },
+          [NATIVEDATE]: DateTime.fromJSDate
+        }[type](date);
+      },
+      add: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless + b.unitless };
+        }
+        if (Interval.isInterval(a) && Interval.isInterval(b)) {
+          return a.union(b);
+        }
+        if (Interval.isInterval(a) && Duration.isDuration(b)) {
+          return a.mapEndpoints(ep => ep.plus(b));
+        }
+        if (Interval.isInterval(b) && Duration.isDuration(a)) {
+          return b.mapEndpoints(ep => ep.plus(a));
+        }
+        if (Interval.isInterval(a) && DateTime.isDateTime(b)) {
+          if (a.isAfter(b)) {
+            return Interval.fromDateTimes(b, a.end);
           }
-        },
-        [NATIVEDATE]: DateTime.fromJSDate
-      }[type](date);
-    },
-    add: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless + b.unitless };
-      }
-      if (Interval.isInterval(a) && Interval.isInterval(b)) {
-        return a.union(b);
-      }
-      if (Interval.isInterval(a) && Duration.isDuration(b)) {
-        return a.mapEndpoints(ep => ep.plus(b));
-      }
-      if (Interval.isInterval(b) && Duration.isDuration(a)) {
-        return b.mapEndpoints(ep => ep.plus(a));
-      }
-      if (Interval.isInterval(a) && DateTime.isDateTime(b)) {
-        if (a.isAfter(b)) {
-          return Interval.fromDateTimes(b, a.end);
+          if (a.isBefore(b)) {
+            return Interval.fromDateTimes(a.start, b);
+          }
+          return b;
         }
-        if (a.isBefore(b)) {
+        if (Interval.isInterval(b) && DateTime.isDateTime(a)) {
+          return a.plus(b.toDuration());
+        }
+        if (Duration.isDuration(a) && Duration.isDuration(b)) {
+          return a.plus(b);
+        }
+        if (DateTime.isDateTime(a) && DateTime.isDateTime(b)) {
+          throw new Error("Can't add dates to each other!");
+        }
+        if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
+          // b is duratoin
+          return a.plus(b);
+        }
+        if (DateTime.isDateTime(b) && b.isValid && Duration.isDuration(a)) {
+          // a is duratoin
+          return b.plus(a);
+        }
+        const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      subtract: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless - b.unitless };
+        }
+        if (Interval.isInterval(a) && Interval.isInterval(b)) {
+          const inter = a.intersection(b);
+          if (inter) return inter;
+          return Interval.fromDateTimes(
+            a.isBefore(b) ? a.end : b.end,
+            a.isBefore(b) ? b.start : a.start
+          );
+        }
+        if (Interval.isInterval(a) && Duration.isDuration(b)) {
+          return Interval.fromDateTimes(a.start.minus(b), a.end.minus(b));
+        }
+        if (Interval.isInterval(b) && Duration.isDuration(a)) {
+          return Interval.fromDateTimes(b.start.minus(a), b.end.minus(a));
+        }
+        if (Duration.isDuration(a) && Duration.isDuration(b)) {
+          return a.minus(b);
+        }
+        if (Interval.isInterval(a) && DateTime.isDateTime(b)) {
+          if (a.isBefore(b)) {
+            return Interval.fromDateTimes(a.end, b);
+          }
+          if (a.isAfter(b)) {
+            return Interval.fromDateTimes(b, a.start);
+          }
           return Interval.fromDateTimes(a.start, b);
         }
-        return b;
-      }
-      if (Interval.isInterval(b) && DateTime.isDateTime(a)) {
-        return a.plus(b.toDuration());
-      }
-      if (Duration.isDuration(a) && Duration.isDuration(b)) {
-        return a.plus(b);
-      }
-      if (DateTime.isDateTime(a) && DateTime.isDateTime(b)) {
-        throw new Error("Can't add dates to each other!");
-      }
-      if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
-        // b is duratoin
-        return a.plus(b);
-      }
-      if (DateTime.isDateTime(b) && b.isValid && Duration.isDuration(a)) {
-        // a is duratoin
-        return b.plus(a);
-      }
-      const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    subtract: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless - b.unitless };
-      }
-      if (Interval.isInterval(a) && Interval.isInterval(b)) {
-        const inter = a.intersection(b);
-        if (inter) return inter;
-        return Interval.fromDateTimes(
-          a.isBefore(b) ? a.end : b.end,
-          a.isBefore(b) ? b.start : a.start
-        );
-      }
-      if (Interval.isInterval(a) && Duration.isDuration(b)) {
-        return Interval.fromDateTimes(a.start.minus(b), a.end.minus(b));
-      }
-      if (Interval.isInterval(b) && Duration.isDuration(a)) {
-        return Interval.fromDateTimes(b.start.minus(a), b.end.minus(a));
-      }
-      if (Duration.isDuration(a) && Duration.isDuration(b)) {
-        return a.minus(b);
-      }
-      if (Interval.isInterval(a) && DateTime.isDateTime(b)) {
-        if (a.isBefore(b)) {
-          return Interval.fromDateTimes(a.end, b);
+        if (Interval.isInterval(b) && DateTime.isDateTime(a)) {
+          return a.minus(b.toDuration());
         }
-        if (a.isAfter(b)) {
-          return Interval.fromDateTimes(b, a.start);
+        if (
+          DateTime.isDateTime(a) &&
+          a.isValid &&
+          DateTime.isDateTime(b) &&
+          b.isValid
+        ) {
+          return Interval.fromDateTimes(a, b);
         }
-        return Interval.fromDateTimes(a.start, b);
-      }
-      if (Interval.isInterval(b) && DateTime.isDateTime(a)) {
-        return a.minus(b.toDuration());
-      }
-      if (
-        DateTime.isDateTime(a) &&
-        a.isValid &&
-        DateTime.isDateTime(b) &&
-        b.isValid
-      ) {
-        return Interval.fromDateTimes(a, b);
-      }
-      if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
-        // b is duratoin
-        return a.minus(b);
-      }
-      if (DateTime.isDateTime(b) && b.isValid && Duration.isDuration(a)) {
-        // a is duratoin
-        return b.minus(a);
-      }
-      const e = `Invalid arguments for 'subtract', expected (date, duration), (duration, date), (duration, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    multiply: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless * b.unitless };
-      }
-      if (Duration.isDuration(a) && isUnitless(b)) {
-        const tmp = Object.entries(a.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * b.unitless
-            }),
-          {}
-        );
-        return a.set(tmp);
-      }
-      if (Duration.isDuration(b) && isUnitless(a)) {
-        const tmp = Object.entries(b.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * a.unitless
-            }),
-          {}
-        );
-        return b.set(tmp);
-      }
-      if (Interval.isInterval(a) && isUnitless(b)) {
-        const tmp = Object.entries(
-          a
+        if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
+          // b is duratoin
+          return a.minus(b);
+        }
+        if (DateTime.isDateTime(b) && b.isValid && Duration.isDuration(a)) {
+          // a is duratoin
+          return b.minus(a);
+        }
+        const e = `Invalid arguments for 'subtract', expected (date, duration), (duration, date), (duration, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      multiply: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless * b.unitless };
+        }
+        if (Duration.isDuration(a) && isUnitless(b)) {
+          const tmp = Object.entries(a.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * b.unitless
+              }),
+            {}
+          );
+          return a.set(tmp);
+        }
+        if (Duration.isDuration(b) && isUnitless(a)) {
+          const tmp = Object.entries(b.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * a.unitless
+              }),
+            {}
+          );
+          return b.set(tmp);
+        }
+        if (Interval.isInterval(a) && isUnitless(b)) {
+          const tmp = Object.entries(
+            a
+              .toDuration(
+                [
+                  "years",
+                  "months",
+                  "days",
+                  "hours",
+                  "minutes",
+                  "seconds",
+                  "milliseconds"
+                ],
+                {
+                  conversionAccuracy: "longterm"
+                }
+              )
+              .toObject()
+          ).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * b.unitless
+              }),
+            {}
+          );
+          return Interval.fromDateTimes(a.start, a.end.plus(tmp));
+        }
+        if (Interval.isInterval(b) && isUnitless(a)) {
+          const tmp = Object.entries(
+            b
+              .toDuration(
+                [
+                  "years",
+                  "months",
+                  "days",
+                  "hours",
+                  "minutes",
+                  "seconds",
+                  "milliseconds"
+                ],
+                {
+                  conversionAccuracy: "longterm"
+                }
+              )
+              .toObject()
+          ).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * a.unitless
+              }),
+            {}
+          );
+          return Interval.fromDateTimes(b.start.minus(tmp), b.end);
+        }
+        const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      divide: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless / b.unitless };
+        }
+        if (isUnitless(a) && a.unitless === 1 && Interval.isInterval(b)) {
+          return Interval.fromDateTimes(b.end, b.start);
+        }
+        if (Duration.isDuration(a) && isUnitless(b)) {
+          const tmp = Object.entries(a.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v / b.unitless
+              }),
+            {}
+          );
+          return a.set(tmp);
+        }
+        if (Duration.isDuration(b) && isUnitless(a)) {
+          const tmp = Object.entries(b.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: a.unitless / v
+              }),
+            {}
+          );
+          return b.set(tmp);
+        }
+        if (Duration.isDuration(a) && Duration.isDuration(b)) {
+          console.warn(`Dividing one duration by another is potentially unsafe!`);
+          return { unitless: a.valueOf() / b.valueOf() };
+        }
+        if (Interval.isInterval(a) && isUnitless(b)) {
+          return a
+            .divideEqually(b.unitless)[0]
             .toDuration(
@@ -260,145 +354,53 @@ [
               }
-            )
-            .toObject()
-        ).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * b.unitless
-            }),
-          {}
-        );
-        return Interval.fromDateTimes(a.start, a.end.plus(tmp));
-      }
-      if (Interval.isInterval(b) && isUnitless(a)) {
-        const tmp = Object.entries(
-          b
-            .toDuration(
-              [
-                "years",
-                "months",
-                "days",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds"
-              ],
-              {
-                conversionAccuracy: "longterm"
-              }
-            )
-            .toObject()
-        ).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * a.unitless
-            }),
-          {}
-        );
-        return Interval.fromDateTimes(b.start.minus(tmp), b.end);
-      }
-      const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    divide: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless / b.unitless };
-      }
-      if (isUnitless(a) && a.unitless === 1 && Interval.isInterval(b)) {
-        return Interval.fromDateTimes(b.end, b.start);
-      }
-      if (Duration.isDuration(a) && isUnitless(b)) {
-        const tmp = Object.entries(a.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v / b.unitless
-            }),
-          {}
-        );
-        return a.set(tmp);
-      }
-      if (Duration.isDuration(b) && isUnitless(a)) {
-        const tmp = Object.entries(b.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: a.unitless / v
-            }),
-          {}
-        );
-        return b.set(tmp);
-      }
-      if (Duration.isDuration(a) && Duration.isDuration(b)) {
-        console.warn(`Dividing one duration by another is potentially unsafe!`);
-        return { unitless: a.valueOf() / b.valueOf() };
-      }
-      if (Interval.isInterval(a) && isUnitless(b)) {
-        return a
-          .divideEqually(b.unitless)[0]
-          .toDuration(
-            [
-              "years",
-              "months",
-              "days",
-              "hours",
-              "minutes",
-              "seconds",
-              "milliseconds"
-            ],
-            {
-              conversionAccuracy: "longterm"
-            }
+            );
+        }
+        if (Interval.isInterval(a) && Duration.isDuration(b)) {
+          return { unitless: a.splitBy(b).length };
+        }
+        if (
+          DateTime.isDateTime(a) &&
+          a.isValid &&
+          DateTime.isDateTime(b) &&
+          b.isValid
+        ) {
+          return Interval.fromDateTimes(a, b);
+        }
+        if (Interval.isInterval(a) && isUnitless(b)) {
+          const tmp = Object.entries(
+            a
+              .toDuration(
+                [
+                  "years",
+                  "months",
+                  "days",
+                  "hours",
+                  "minutes",
+                  "seconds",
+                  "milliseconds"
+                ],
+                {
+                  conversionAccuracy: "longterm"
+                }
+              )
+              .toObject()
+          ).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * (b.unitless / 2)
+              }),
+            {}
           );
+          return Interval.fromDateTimes(a.start.plus(tmp), a.end.minus(tmp));
+        }
+        const e = `Invalid arguments for divide, expected (duration, unitless) or (unitless, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
       }
-      if (Interval.isInterval(a) && Duration.isDuration(b)) {
-        return { unitless: a.splitBy(b).length };
-      }
-      if (
-        DateTime.isDateTime(a) &&
-        a.isValid &&
-        DateTime.isDateTime(b) &&
-        b.isValid
-      ) {
-        return Interval.fromDateTimes(a, b);
-      }
-      if (Interval.isInterval(a) && isUnitless(b)) {
-        const tmp = Object.entries(
-          a
-            .toDuration(
-              [
-                "years",
-                "months",
-                "days",
-                "hours",
-                "minutes",
-                "seconds",
-                "milliseconds"
-              ],
-              {
-                conversionAccuracy: "longterm"
-              }
-            )
-            .toObject()
-        ).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * (b.unitless / 2)
-            }),
-          {}
-        );
-        return Interval.fromDateTimes(a.start.plus(tmp), a.end.minus(tmp));
-      }
-      const e = `Invalid arguments for divide, expected (duration, unitless) or (unitless, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    }
+    };
   };
-};
+}
 export default luxon;

bindings/moment.js

@@ -1,112 +0,115 @@
-import m from "moment";
+export const moment = /*#__PURE__*/ momentlib => {
 
-const isUnitless = a => {
-  const keys = Object.keys(a);
-  return keys.length === 1 && keys[0] === "unitless";
-};
+  const m = momentlib;
+    
+  const isUnitless = a => {
+    const keys = Object.keys(a);
+    return keys.length === 1 && keys[0] === "unitless";
+  };
 
-export const moment = (
-  { NATIVEDATE, DATEXPRESION, DURATIONEXPRESSION, DURATIONOBJECT },
-  { console }
-) => {
-  return {
-    makeDuration: (duration, { type }) => {
-      return {
-        [DURATIONEXPRESSION]: a => {
-          try {
-            return m.duration(JSON.parse(a));
-          } catch (e) {
-            return m.duration(a);
-          }
-        },
-        [DURATIONOBJECT]: o => m.duration(o)
-      }[type](duration);
-    },
-    makeDate: (date, { type }) => {
-      return {
-        [DATEXPRESION]: a => {
-          try {
-            return m(JSON.parse(a));
-          } catch (e) {
-            return m(a);
-          }
-        },
-        [NATIVEDATE]: a => m(a)
-      }[type](date);
-    },
-    add: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless + b.unitless };
+  return (
+    { NATIVEDATE, DATEXPRESION, DURATIONEXPRESSION, DURATIONOBJECT },
+    { console }
+  ) => {
+    return {
+      makeDuration: (duration, { type }) => {
+        return {
+          [DURATIONEXPRESSION]: a => {
+            try {
+              return m.duration(JSON.parse(a));
+            } catch (e) {
+              return m.duration(a);
+            }
+          },
+          [DURATIONOBJECT]: o => m.duration(o)
+        }[type](duration);
+      },
+      makeDate: (date, { type }) => {
+        return {
+          [DATEXPRESION]: a => {
+            try {
+              return m(JSON.parse(a));
+            } catch (e) {
+              return m(a);
+            }
+          },
+          [NATIVEDATE]: a => m(a)
+        }[type](date);
+      },
+      add: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless + b.unitless };
+        }
+        if (m.isDuration(a) && m.isDuration(b)) {
+          return a.add(b);
+        }
+        if (m.isMoment(a) && a.isValid && m.isDuration(b)) {
+          return a.add(b);
+        }
+        if (m.isMoment(b) && b.isValid && m.isDuration(a)) {
+          return b.add(a);
+        }
+        const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      subtract: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless - b.unitless };
+        }
+        if (m.isDuration(a) && m.isDuration(b)) {
+          return a.subtract(b);
+        }
+        if (m.isMoment(a) && a.isValid && m.isDuration(b)) {
+          // date - duration
+          return a.subtract(b);
+        }
+        const e = `Invalid arguments for 'subtract', expected (date, duration) or (duration, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      multiply: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless * b.unitless };
+        }
+        if (m.isDuration(a) && isUnitless(b)) {
+          return m.duration(a.as("milliseconds") * b.unitless);
+        }
+        if (m.isDuration(b) && isUnitless(a)) {
+          return m.duration(b.as("milliseconds") * a.unitless);
+        }
+        const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      divide: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless / b.unitless };
+        }
+        if (m.isDuration(a) && isUnitless(b)) {
+          return m.duration(a.as("milliseconds") / b.unitless);
+        }
+        const e = `Invalid arguments for divide, expected (duration, unitless) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
       }
-      if (m.isDuration(a) && m.isDuration(b)) {
-        return a.add(b);
-      }
-      if (m.isMoment(a) && a.isValid && m.isDuration(b)) {
-        return a.add(b);
-      }
-      if (m.isMoment(b) && b.isValid && m.isDuration(a)) {
-        return b.add(a);
-      }
-      const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    subtract: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless - b.unitless };
-      }
-      if (m.isDuration(a) && m.isDuration(b)) {
-        return a.subtract(b);
-      }
-      if (m.isMoment(a) && a.isValid && m.isDuration(b)) {
-        // date - duration
-        return a.subtract(b);
-      }
-      const e = `Invalid arguments for 'subtract', expected (date, duration) or (duration, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    multiply: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless * b.unitless };
-      }
-      if (m.isDuration(a) && isUnitless(b)) {
-        return m.duration(a.as("milliseconds") * b.unitless);
-      }
-      if (m.isDuration(b) && isUnitless(a)) {
-        return m.duration(b.as("milliseconds") * a.unitless);
-      }
-      const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    divide: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless / b.unitless };
-      }
-      if (m.isDuration(a) && isUnitless(b)) {
-        return m.duration(a.as("milliseconds") / b.unitless);
-      }
-      const e = `Invalid arguments for divide, expected (duration, unitless) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    }
+    };
   };
-};
+}
 export default moment;

bindings/simple.js

@@ -1,2 +0,2 @@
-export const simple = ({
+export const simple = /*#__PURE__*/ () => ({
   NATIVEDATE,
@@ -3,0 +3,0 @@ DATEXPRESION,

bindings/simpleluxon.js

@@ -1,166 +0,169 @@
-import { DateTime, Duration } from "luxon";
+export const simpleluxon = /*#__PURE__*/ luxonlib => {
 
-const isUnitless = a => {
-  const keys = Object.keys(a);
-  return keys.length === 1 && keys[0] === "unitless";
-};
+  const { DateTime, Duration } = luxonlib;
 
-export const simpleluxon = (
-  { NATIVEDATE, DATEXPRESION, DURATIONEXPRESSION, DURATIONOBJECT },
-  { console }
-) => {
-  return {
-    makeDuration: (duration, { type }) => {
-      return {
-        [DURATIONEXPRESSION]: a => {
-          try {
-            const maybedurationobject = JSON.parse(a);
-            if (Array.isArray(maybedurationobject)) {
-              return Duration.fromObject(
-                maybedurationobject[0],
-                maybedurationobject[1]
-              );
-            } else if (typeof maybedurationobject === "string") {
-              return Duration.fromISO(maybedurationobject);
-            } else if (typeof maybedurationobject === "number") {
-              return Duration.fromMillis(maybedurationobject);
-            } else {
-              return Duration.fromObject(maybedurationobject);
+  const isUnitless = a => {
+    const keys = Object.keys(a);
+    return keys.length === 1 && keys[0] === "unitless";
+  };
+  
+  return (
+    { NATIVEDATE, DATEXPRESION, DURATIONEXPRESSION, DURATIONOBJECT },
+    { console }
+  ) => {
+    return {
+      makeDuration: (duration, { type }) => {
+        return {
+          [DURATIONEXPRESSION]: a => {
+            try {
+              const maybedurationobject = JSON.parse(a);
+              if (Array.isArray(maybedurationobject)) {
+                return Duration.fromObject(
+                  maybedurationobject[0],
+                  maybedurationobject[1]
+                );
+              } else if (typeof maybedurationobject === "string") {
+                return Duration.fromISO(maybedurationobject);
+              } else if (typeof maybedurationobject === "number") {
+                return Duration.fromMillis(maybedurationobject);
+              } else {
+                return Duration.fromObject(maybedurationobject);
+              }
+            } catch (e) {
+              return Duration.fromISO(a);
             }
-          } catch (e) {
-            return Duration.fromISO(a);
-          }
-        },
-        [DURATIONOBJECT]: o => Duration.fromObject(o)
-      }[type](duration);
-    },
-    makeDate: (date, { type }) => {
-      return {
-        [DATEXPRESION]: a => {
-          try {
-            const maybedateobject = JSON.parse(a);
-            if (Array.isArray(maybedateobject)) {
-              if (
-                typeof maybedateobject[0] === "string" &&
-                typeof maybedateobject[1] === "string"
-              ) {
-                return DateTime.fromFormat(
+          },
+          [DURATIONOBJECT]: o => Duration.fromObject(o)
+        }[type](duration);
+      },
+      makeDate: (date, { type }) => {
+        return {
+          [DATEXPRESION]: a => {
+            try {
+              const maybedateobject = JSON.parse(a);
+              if (Array.isArray(maybedateobject)) {
+                if (
+                  typeof maybedateobject[0] === "string" &&
+                  typeof maybedateobject[1] === "string"
+                ) {
+                  return DateTime.fromFormat(
+                    maybedateobject[0],
+                    maybedateobject[1]
+                  );
+                }
+                return DateTime.fromObject(
                   maybedateobject[0],
                   maybedateobject[1]
                 );
+              } else if (typeof maybedateobject === "string") {
+                return DateTime.fromISO(maybedateobject);
+              } else if (typeof maybedateobject === "number") {
+                return DateTime.fromMillis(maybedateobject);
+              } else {
+                return DateTime.fromObject(maybedateobject);
               }
-              return DateTime.fromObject(
-                maybedateobject[0],
-                maybedateobject[1]
-              );
-            } else if (typeof maybedateobject === "string") {
-              return DateTime.fromISO(maybedateobject);
-            } else if (typeof maybedateobject === "number") {
-              return DateTime.fromMillis(maybedateobject);
-            } else {
-              return DateTime.fromObject(maybedateobject);
+            } catch (e) {
+              return DateTime.fromISO(a);
             }
-          } catch (e) {
-            return DateTime.fromISO(a);
-          }
-        },
-        [NATIVEDATE]: DateTime.fromJSDate
-      }[type](date);
-    },
-    add: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless + b.unitless };
+          },
+          [NATIVEDATE]: DateTime.fromJSDate
+        }[type](date);
+      },
+      add: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless + b.unitless };
+        }
+        if (Duration.isDuration(a) && Duration.isDuration(b)) {
+          return a.plus(b);
+        }
+        if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
+          return a.plus(b);
+        }
+        if (DateTime.isDateTime(b) && b.isValid && Duration.isDuration(a)) {
+          return b.plus(a);
+        }
+        const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      subtract: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless - b.unitless };
+        }
+        if (Duration.isDuration(a) && Duration.isDuration(b)) {
+          return a.minus(b);
+        }
+        if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
+          // date - duration
+          return a.minus(b);
+        }
+        const e = `Invalid arguments for 'subtract', expected (date, duration) or (duration, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      multiply: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless * b.unitless };
+        }
+        if (Duration.isDuration(a) && isUnitless(b)) {
+          const tmp = Object.entries(a.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * b.unitless
+              }),
+            {}
+          );
+          return a.set(tmp);
+        }
+        if (Duration.isDuration(b) && isUnitless(a)) {
+          const tmp = Object.entries(b.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v * a.unitless
+              }),
+            {}
+          );
+          return b.set(tmp);
+        }
+        const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
+      },
+      divide: (a, b) => {
+        if (isUnitless(a) && isUnitless(b)) {
+          return { unitless: a.unitless / b.unitless };
+        }
+        if (Duration.isDuration(a) && isUnitless(b)) {
+          const tmp = Object.entries(a.toObject()).reduce(
+            (p, [k, v]) =>
+              Object.assign(p, {
+                [k]: v / b.unitless
+              }),
+            {}
+          );
+          return a.set(tmp);
+        }
+        const e = `Invalid arguments for divide, expected (duration, unitless) but found (${
+          a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
+        }, ${
+          b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
+        })`;
+        console.error(e, a, b);
+        throw new Error(e);
       }
-      if (Duration.isDuration(a) && Duration.isDuration(b)) {
-        return a.plus(b);
-      }
-      if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
-        return a.plus(b);
-      }
-      if (DateTime.isDateTime(b) && b.isValid && Duration.isDuration(a)) {
-        return b.plus(a);
-      }
-      const e = `Invalid arguments for 'add', expected (date, duration), (duration, date), (duration, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    subtract: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless - b.unitless };
-      }
-      if (Duration.isDuration(a) && Duration.isDuration(b)) {
-        return a.minus(b);
-      }
-      if (DateTime.isDateTime(a) && a.isValid && Duration.isDuration(b)) {
-        // date - duration
-        return a.minus(b);
-      }
-      const e = `Invalid arguments for 'subtract', expected (date, duration) or (duration, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    multiply: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless * b.unitless };
-      }
-      if (Duration.isDuration(a) && isUnitless(b)) {
-        const tmp = Object.entries(a.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * b.unitless
-            }),
-          {}
-        );
-        return a.set(tmp);
-      }
-      if (Duration.isDuration(b) && isUnitless(a)) {
-        const tmp = Object.entries(b.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v * a.unitless
-            }),
-          {}
-        );
-        return b.set(tmp);
-      }
-      const e = `Invalid arguments for multiply, expected (duration, unitless) or (unitless, duration) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    },
-    divide: (a, b) => {
-      if (isUnitless(a) && isUnitless(b)) {
-        return { unitless: a.unitless / b.unitless };
-      }
-      if (Duration.isDuration(a) && isUnitless(b)) {
-        const tmp = Object.entries(a.toObject()).reduce(
-          (p, [k, v]) =>
-            Object.assign(p, {
-              [k]: v / b.unitless
-            }),
-          {}
-        );
-        return a.set(tmp);
-      }
-      const e = `Invalid arguments for divide, expected (duration, unitless) but found (${
-        a.invalidExplanation ? `Invalid date ${a.invalidExplanation}` : typeof a
-      }, ${
-        b.invalidExplanation ? `Invalid date ${b.invalidExplanation}` : typeof b
-      })`;
-      console.error(e, a, b);
-      throw new Error(e);
-    }
+    };
   };
-};
+}
 export default simpleluxon;

bindings/testbindings.js

@@ -1,2 +0,2 @@
-export const test = (
+export const test = /*#__PURE__*/ () => (
   __,
@@ -3,0 +3,0 @@ { makeInterval, makeDuration, makeDate, add, subtract, multiply, divide }

index.js

 import parser from "./dateCalculator";
-import { simple } from "./bindings/simple";
-import { datefns } from "./bindings/date-fns";
-import { luxon } from "./bindings/luxon";
-import { simpleluxon } from "./bindings/simpleluxon";
-import { moment } from "./bindings/moment";
 
-const customConsole = {
-  log: console.log.bind(console),
-  warn: console.warn.bind(console),
-  error: console.error.bind(console),
-  info: console.info.bind(console),
-  debug: console.debug.bind(console)
-};
-export const simpleCalculator = parser(
-  simple(parser, {
-    console: customConsole
-  })
-);
-export const calc = simpleCalculator;
-export const datefnsCalculator = parser(
-  datefns(parser, {
-    console: customConsole
-  })
-);
-export const datefnscalc = datefnsCalculator;
-export const luxonCalculator = parser(
-  luxon(parser, {
-    console: customConsole
-  })
-);
-export const luxoncalc = luxonCalculator;
-export const simpleluxonCalculator = parser(
-  simpleluxon(parser, {
-    console: customConsole
-  })
-);
-export const luxonsimplecalc = simpleluxonCalculator;
-export const momentCalculator = parser(
-  moment(parser, {
-    console: customConsole
-  })
-);
-export const momentcalc = momentCalculator;
-export default parser(
-  simple(parser, {
-    console: customConsole
-  })
-);
+export * from "./calc";
+export * from "./datefnscalc";
+export * from "./datefnsCalculator";
+export * from "./luxoncalc";
+export * from "./luxonCalculator";
+export * from "./luxonsimplecalc";
+export * from "./simpleluxonCalculator";
+export * from "./momentcalc";
+export * from "./momentCalculator";
+export * from "./simpleCalculator";
+export default parser;

package.json

 {
   "name": "calcdate",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Evalate a date expression calc`now + 3 days`)!",
@@ -8,3 +8,3 @@ "main": "dist/datecalculator.js",
     "build": "webpack",
-    "test": "jest",
+    "test": "env TZ=UTC jest",
     "build:all": "yarn build:browser && yarn build:node",
@@ -11,0 +11,0 @@ "build:browser": "webpack && cp dist/datecalculator.js examples/browser",

tests/calculator.test.js

@@ -13,4 +13,4 @@ import parser from "../dateCalculator";
 it("Instanciation works", () => {
-  expect(testbinding({}, {})).toEqual({});
-  expect(parser(testbinding(parser, {}))).toBeInstanceOf(Function);
+  expect(testbinding()({}, {})).toEqual({});
+  expect(parser(testbinding()(parser, {}))).toBeInstanceOf(Function);
 });
@@ -41,5 +41,5 @@
     operations.divide = jest.fn((a, b) => ({ divide: [a, b] }));
-    calculator = parser(testbinding(parser, operations));
+    calculator = parser(testbinding()(parser, operations));
     /*
-    const xcalc = parser(testbinding(parser, operations));
+    const xcalc = parser(testbinding()(parser, operations));
     calculator = (a, ...args) => {
@@ -579,3 +579,3 @@ try {
         expect(result).toBeDefined();
-        expect(`${i} = ${result.date}`).toMatchSnapshot();
+        expect(`${i} = ${result.date.getTime()}`).toMatchSnapshot();
       })
@@ -587,3 +587,3 @@ );
         expect(result).toBeDefined();
-        expect(`${i} = ${result.date}`).toMatchSnapshot();
+        expect(`${i} = ${result.date.getTime()}`).toMatchSnapshot();
       })
@@ -701,3 +701,2 @@ );
       "2009-05-19",
-      " 2009-05-19 ",
       "2009-05",
@@ -716,3 +715,2 @@ "2009-001",
       "20090519",
-      " 20090519 ",
       "200905",
@@ -737,4 +735,6 @@ "2009001",
           expect(result).toBeDefined();
+          expect(result.interval[0].date).toBeDefined();
+          expect(result.interval[1].date).toBeDefined();
           expect(
-            `${a}/${b} = ${JSON.stringify(result.duration)}`
+            `${a}/${b} = ${result.interval[0].date.getTime()}/${result.interval[1].date.getTime()}`
           ).toMatchSnapshot();
@@ -749,9 +749,17 @@ });
           expect(result).toBeDefined();
+          expect(result.interval[0].date).toBeDefined();
+          expect(result.interval[1].duration).toBeDefined();
           expect(
-            `${date}/${duration} = ${JSON.stringify(result.duration)}`
+            `${date}/${duration} = ${result.interval[0].date.getTime()}/${JSON.stringify(
+              result.interval[1].duration
+            )}`
           ).toMatchSnapshot();
           const result2 = calculator`${duration}/${date}`;
           expect(result2).toBeDefined();
+          expect(result2.interval[0].duration).toBeDefined();
+          expect(result2.interval[1].date).toBeDefined();
           expect(
-            `${duration}/${date} = ${JSON.stringify(result2.interval)}`
+            `${duration}/${date} = ${JSON.stringify(
+              result2.interval[0].duration
+            )}/${result2.interval[1].date.getTime()}`
           ).toMatchSnapshot();
@@ -758,0 +766,0 @@ });

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1039177

increased by1.86%

Number of package files

36

increased by44%

Lines of code

4951

increased by2.7%

Number of low quality alerts

0

decreased by-100%

Number of lines in readme file

628

increased by6.26%

Number of low supply chain risk alerts

0

decreased by-100%

No dependency changes