@orioro/util 0.12.0 → 0.13.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { keyBy, set, get } from 'lodash-es';
+import { keyBy, get, set } from 'lodash-es';
 import EventEmitter from 'eventemitter3';
 import copy from 'fast-copy';
 import traverse from 'traverse';
@@ -8,6 +8,7 @@ import memoizeOne from 'memoize-one';
 import queryString from 'query-string';
 
 function arrayChunk(array, chunkSize) {
+  console.warn('arrayChunk is deprecated, prefer lodash-es chunk');
   var chunks = [];
   for (var i = 0; i < array.length; i += chunkSize) {
     chunks.push(array.slice(i, i + chunkSize));
@@ -15,6 +16,366 @@ function arrayChunk(array, chunkSize) {
   return chunks;
 }
 
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw new Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw new Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
 function _typeof(o) {
   "@babel/helpers - typeof";
 
@@ -24,175 +385,206 @@ function _typeof(o) {
     return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
   }, _typeof(o);
 }
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-var _extendStatics = function extendStatics(d, b) {
-  _extendStatics = Object.setPrototypeOf || {
-    __proto__: []
-  } instanceof Array && function (d, b) {
-    d.__proto__ = b;
-  } || function (d, b) {
-    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-  };
-  return _extendStatics(d, b);
-};
-function __extends(d, b) {
-  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-  _extendStatics(d, b);
-  function __() {
-    this.constructor = d;
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
-  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  return obj;
 }
-var _assign = function __assign() {
-  _assign = Object.assign || function __assign(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
     }
-    return t;
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
   };
-  return _assign.apply(this, arguments);
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeFunction(fn) {
+  try {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  } catch (e) {
+    return typeof fn === "function";
   }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
     }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
     }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
     }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
 }
-function __generator(thisArg, body) {
-  var _ = {
-      label: 0,
-      sent: function sent() {
-        if (t[0] & 1) throw t[1];
-        return t[1];
-      },
-      trys: [],
-      ops: []
-    },
-    f,
-    y,
-    t,
-    g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
-    return this;
-  }), g;
-  function verb(n) {
-    return function (v) {
-      return step([n, v]);
-    };
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
   }
-  function step(op) {
-    if (f) throw new TypeError("Generator is already executing.");
-    while (g && (g = 0, op[0] && (_ = 0)), _) try {
-      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [op[0] & 2, t.value];
-      switch (op[0]) {
-        case 0:
-        case 1:
-          t = op;
-          break;
-        case 4:
-          _.label++;
+  return self;
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toArray(arr) {
+  return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
           return {
-            value: op[1],
-            done: false
+            done: false,
+            value: o[i++]
           };
-        case 5:
-          _.label++;
-          y = op[1];
-          op = [0];
-          continue;
-        case 7:
-          op = _.ops.pop();
-          _.trys.pop();
-          continue;
-        default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-            _ = 0;
-            continue;
-          }
-          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-            _.label = op[1];
-            break;
-          }
-          if (op[0] === 6 && _.label < t[1]) {
-            _.label = t[1];
-            t = op;
-            break;
-          }
-          if (t && _.label < t[2]) {
-            _.label = t[2];
-            _.ops.push(op);
-            break;
-          }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
-          continue;
-      }
-      op = body.call(thisArg, _);
-    } catch (e) {
-      op = [6, e];
-      y = 0;
-    } finally {
-      f = t = 0;
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
     }
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: true
-    };
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-}
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
     }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
+  };
 }
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
 
 function _isTupleDatasetInput(input) {
   return Array.isArray(input) && typeof input[0] === 'string' && Array.isArray(input[1]);
@@ -208,10 +600,15 @@ function _parseDatasetInput(defaultOnKey, datasetInput) {
       if (keySplit.length === 1) {
         srcKey = null;
         key = keyInput;
-      } else {
+      } else if (keySplit.length === 2) {
         srcKey = keySplit[0];
         key = keySplit[1];
+      } else {
+        throw new Error("Invalid keyInput: ".concat(keyInput, " - contains too many colons (:)"));
       }
+    } else if (Array.isArray(keyInput)) {
+      srcKey = keyInput[0];
+      key = keyInput[1];
     }
     return {
       srcKey: srcKey,
@@ -227,14 +624,15 @@ function _parseDatasetInput(defaultOnKey, datasetInput) {
     path: null
   };
 }
-function dataJoin(datasets, _a) {
-  var _b = _a === void 0 ? {} : _a,
-    _c = _b.key,
-    defaultOnKey = _c === void 0 ? 'id' : _c,
-    _d = _b.mode,
-    mode = _d === void 0 ? 'left' : _d;
-  var base = datasets[0],
-    others = datasets.slice(1);
+function dataJoin(datasets) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$key = _ref.key,
+    defaultOnKey = _ref$key === void 0 ? 'id' : _ref$key,
+    _ref$mode = _ref.mode,
+    mode = _ref$mode === void 0 ? 'left' : _ref$mode;
+  var _datasets = _toArray(datasets),
+    base = _datasets[0],
+    others = _datasets.slice(1);
   //
   // Base dataset requires no byKey dict
   //
@@ -244,7 +642,7 @@ function dataJoin(datasets, _a) {
   //
   var otherSets = others.map(function (setInput) {
     var parsed = _parseDatasetInput(defaultOnKey, setInput);
-    return _assign(_assign({}, parsed), {
+    return Object.assign(Object.assign({}, parsed), {
       byKey: keyBy(parsed.entries, parsed.key)
     });
   });
@@ -254,35 +652,36 @@ function dataJoin(datasets, _a) {
   // to another dataset
   //
   function _entryKey(entry, otherSet) {
-    var _a;
-    return ((_a = otherSet.srcKey ? get(entry, otherSet.srcKey) : get(entry, baseDataset.key)) !== null && _a !== void 0 ? _a : '').toString();
+    var key = otherSet.srcKey ? get(entry, otherSet.srcKey) : get(entry, baseDataset.key);
+    return typeof key === 'string' || typeof key === 'number' ? key : null;
   }
   //
   // If mode === inner, filter out missing data
   //
   var baseEntries = mode === 'inner' ? baseDataset.entries.filter(function (entry) {
     return otherSets.every(function (set) {
-      return set.byKey[_entryKey(entry, set)];
+      var entryKey = _entryKey(entry, set);
+      return entryKey === null ? false : typeof set.byKey[entryKey] !== 'undefined';
     });
   }) : baseDataset.entries;
   //
   // Loop over baseDataset.entries joining it with other data
   //
   return baseEntries.map(function (entry) {
-    var _a;
     //
     // Setup a base entry over which data will be set
     //
-    var baseEntry = baseDataset.path ? (_a = {}, _a[baseDataset.path] = entry, _a) : Object.assign({}, entry);
+    var baseEntry = baseDataset.path ? _defineProperty({}, baseDataset.path, entry) : Object.assign({}, entry);
     //
     // Loop over all other sets to pick up data
     //
     return otherSets.reduce(function (acc, otherSet) {
       var entryKey = _entryKey(entry, otherSet);
-      var otherEntry = otherSet.byKey[entryKey];
+      var otherEntry = entryKey === null ? null : otherSet.byKey[entryKey];
       if (otherEntry) {
         if (otherSet.path) {
-          set(acc, otherSet.path, otherEntry);
+          var currVal = get(acc, otherSet.path) || {};
+          set(acc, otherSet.path, Object.assign({}, _typeof(currVal) === 'object' ? currVal : {}, otherEntry));
         } else {
           Object.assign(acc, otherEntry);
         }
@@ -292,46 +691,161 @@ function dataJoin(datasets, _a) {
   });
 }
 
-var PromiseLikeEventEmitter = /** @class */function (_super) {
-  __extends(PromiseLikeEventEmitter, _super);
+function arrayLikeIterable(makeIterable) {
+  return _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, Symbol.iterator, function () {
+    return makeIterable()[Symbol.iterator]();
+  }), "map", function map(fn) {
+    var i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var result = [];
+    var _iterator = _createForOfIteratorHelper(makeIterable()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var item = _step.value;
+        result.push(fn(item, i++));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result;
+  }), "forEach", function forEach(fn) {
+    var i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var _iterator2 = _createForOfIteratorHelper(makeIterable()),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var item = _step2.value;
+        fn(item, i++);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }), "reduce", function reduce(fn, acc) {
+    var i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    var _iterator3 = _createForOfIteratorHelper(makeIterable()),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var item = _step3.value;
+        acc = fn(acc, item, i++);
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    return acc;
+  }), "toArray", function toArray() {
+    return _toConsumableArray(makeIterable());
+  }), "filter", function filter(fn) {
+    var i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var result = [];
+    var _iterator4 = _createForOfIteratorHelper(makeIterable()),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var item = _step4.value;
+        if (fn(item, i++)) result.push(item);
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    return result;
+  });
+}
+
+var PromiseLikeEventEmitter = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(PromiseLikeEventEmitter, _EventEmitter);
   function PromiseLikeEventEmitter() {
-    var _this = _super.call(this) || this;
+    var _this;
+    _classCallCheck(this, PromiseLikeEventEmitter);
+    _this = _callSuper(this, PromiseLikeEventEmitter);
     _this.promise = new Promise(function (resolve, reject) {
       _this.resolve = resolve;
       _this.reject = reject;
     });
     return _this;
   }
-  PromiseLikeEventEmitter.prototype.then = function (onFulfilled, onRejected) {
-    return this.promise.then(onFulfilled, onRejected);
-  };
-  PromiseLikeEventEmitter.prototype["catch"] = function (onRejected) {
-    return this.promise["catch"](onRejected);
-  };
-  PromiseLikeEventEmitter.prototype["finally"] = function (onFinally) {
-    return this.promise["finally"](onFinally);
-  };
+  _createClass(PromiseLikeEventEmitter, [{
+    key: "then",
+    value: function then(onFulfilled, onRejected) {
+      return this.promise.then(onFulfilled, onRejected);
+    }
+  }, {
+    key: "catch",
+    value: function _catch(onRejected) {
+      return this.promise["catch"](onRejected);
+    }
+  }, {
+    key: "finally",
+    value: function _finally(onFinally) {
+      return this.promise["finally"](onFinally);
+    }
+  }]);
   return PromiseLikeEventEmitter;
 }(EventEmitter);
 
-function wait(ms, result) {
-  if (ms === void 0) {
-    ms = 1000;
-  }
-  return __awaiter(this, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-      return [2 /*return*/, new Promise(function (resolve, reject) {
-        setTimeout(function () {
-          if (result instanceof Error) {
-            reject(result);
-          } else {
-            resolve(result);
-          }
-        }, ms);
-      })];
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
     });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 }
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function wait() {
+  var ms = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1000;
+  var result = arguments.length > 1 ? arguments[1] : undefined;
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", new Promise(function (resolve, reject) {
+            setTimeout(function () {
+              if (result instanceof Error) {
+                reject(result);
+              } else {
+                resolve(result);
+              }
+            }, ms);
+          }));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+}
 
 function deepFreeze(object) {
   Object.freeze(object);
@@ -385,16 +899,13 @@ function sequentialCallIdGenerator() {
     return count += 1;
   };
 }
-function debugFn(fnName, fn, logCall, logResult, generateCallId) {
-  if (generateCallId === void 0) {
-    generateCallId = generateDeterministicId;
-  }
+function debugFn(fnName, fn, logCall, logResult) {
+  var generateCallId = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : generateDeterministicId;
   return function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    var callId = generateCallId(__spreadArray([fnName, fn], args, true));
+    var callId = generateCallId([fnName, fn].concat(args));
     if (typeof logCall === 'function') {
       // Deep clone args, so that we may detect mutations later on
       logCall({
@@ -456,18 +967,19 @@ function _parsePathExpr(pathExpr) {
  *                          supported: loops, conditionals, etc.
  * @param {Object | Array} data Data context to be used for interpolation
  */
-function interpolate(template, data, _a) {
-  var _b = _a === void 0 ? {} : _a,
-    _c = _b.maxLength,
-    maxLength = _c === void 0 ? 10000 : _c;
+function interpolate(template, data) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+    _ref$maxLength = _ref.maxLength,
+    maxLength = _ref$maxLength === void 0 ? 10000 : _ref$maxLength;
   if (template.length > maxLength) {
     throw new Error("Template exceeds maxLength ".concat(maxLength));
   }
   data = _typeof(data) === 'object' ? data : [data];
   return template.replace(INTERPOLATION_REGEXP, function (_, pathExpr) {
-    var _a = _parsePathExpr(pathExpr),
-      path = _a[0],
-      defaultValue = _a[1];
+    var _parsePathExpr2 = _parsePathExpr(pathExpr),
+      _parsePathExpr3 = _slicedToArray(_parsePathExpr2, 2),
+      path = _parsePathExpr3[0],
+      defaultValue = _parsePathExpr3[1];
     var value = get(data, path);
     switch (_typeof(value)) {
       case 'number':
@@ -492,19 +1004,19 @@ function interpolate(template, data, _a) {
 }
 
 function maybeFn(input) {
-  var args = [];
-  for (var _i = 1; _i < arguments.length; _i++) {
-    args[_i - 1] = arguments[_i];
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
   }
   return typeof input === 'function' ? input.apply(void 0, args) : input;
 }
 
 function pickPaths(sourceObj, paths) {
   return paths.reduce(function (acc, path) {
-    var _a = Array.isArray(path) ? path : [path, path],
-      targetPath = _a[0],
-      resolver = _a[1],
-      defaultValue = _a[2];
+    var _ref = Array.isArray(path) ? path : [path, path],
+      _ref2 = _slicedToArray(_ref, 3),
+      targetPath = _ref2[0],
+      resolver = _ref2[1],
+      defaultValue = _ref2[2];
     var value = typeof resolver === 'string' ? get(sourceObj, resolver) : resolver(sourceObj);
     var valueAfterDefault = typeof value === 'undefined' ? defaultValue : value;
     //
@@ -531,89 +1043,107 @@ var DEFAULT_OPTIONS = {
 function _echo(input) {
   return input;
 }
-function resolveNestedPromises(node, options, ctx) {
-  if (options === void 0) {
-    options = {};
-  }
-  if (ctx === void 0) {
-    ctx = {
-      root: node,
-      depth: 0
-    };
-  }
-  return __awaiter(this, void 0, void 0, function () {
+function resolveNestedPromises(node) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var ctx = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    root: node,
+    depth: 0
+  };
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
     var opts, promises, _cloneFn, clonedNode, resolved;
-    return __generator(this, function (_a) {
-      opts = _assign(_assign({}, DEFAULT_OPTIONS), options);
-      promises = [];
-      _cloneFn = opts.clone || _echo;
-      clonedNode = _cloneFn(node);
-      resolved = traverse(clonedNode).forEach(function (value) {
-        var _this = this;
-        var depth = ctx.depth + this.path.length;
-        if (depth > opts.maxDepth) {
-          throw new Error("Max depth exceeded: { depth: ".concat(depth, ", maxDepth: ").concat(opts.maxDepth, " }"));
-        }
-        if (value instanceof Promise) {
-          var updatePromise = value.then(function (resolvedValue) {
-            return __awaiter(_this, void 0, void 0, function () {
-              var _a, _b;
-              return __generator(this, function (_c) {
-                switch (_c.label) {
-                  case 0:
-                    // Arrow function;
-                    // this refers to outside this ctx
-                    _a = this.update;
-                    if (!(opts.mode === 'eager')) return [3 /*break*/, 2];
-                    return [4 /*yield*/, resolveNestedPromises(resolvedValue, opts, _assign(_assign({}, ctx), {
-                      // pass the base depth of the current value
-                      depth: depth
-                    }))];
-                  case 1:
-                    _b = _c.sent();
-                    return [3 /*break*/, 3];
-                  case 2:
-                    _b = resolvedValue;
-                    _c.label = 3;
-                  case 3:
-                    // Arrow function;
-                    // this refers to outside this ctx
-                    _a.apply(this, [_b]);
-                    return [2 /*return*/];
-                }
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+          promises = []; //
+          // Allow consumers to provide a clone function.
+          // There are multiple nuances regarding cloning. Here are some
+          // we've faced:
+          // - clone-deep (https://www.npmjs.com/package/clone-deep) does
+          //   creates new versions of symbols
+          // - fast-copy (default export) does not clone array custom properties
+          //   (but allows for creating a copier function that does)
+          //
+          // It would be incorrect to use copyStrict (from fast-copy) by default, thus
+          // we allow consumers to provide their copy functions
+          //
+          // If opts.clone is set to false, use the _echo function
+          //
+          _cloneFn = opts.clone || _echo;
+          clonedNode = _cloneFn(node);
+          resolved = traverse(clonedNode).forEach(function (value) {
+            var _this = this;
+            var depth = ctx.depth + this.path.length;
+            if (depth > opts.maxDepth) {
+              throw new Error("Max depth exceeded: { depth: ".concat(depth, ", maxDepth: ").concat(opts.maxDepth, " }"));
+            }
+            if (value instanceof Promise) {
+              var updatePromise = value.then(function (resolvedValue) {
+                return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                  return _regeneratorRuntime().wrap(function _callee$(_context) {
+                    while (1) switch (_context.prev = _context.next) {
+                      case 0:
+                        _context.t0 = this;
+                        if (!(opts.mode === 'eager')) {
+                          _context.next = 7;
+                          break;
+                        }
+                        _context.next = 4;
+                        return resolveNestedPromises(resolvedValue, opts, Object.assign(Object.assign({}, ctx), {
+                          // pass the base depth of the current value
+                          depth: depth
+                        }));
+                      case 4:
+                        _context.t1 = _context.sent;
+                        _context.next = 8;
+                        break;
+                      case 7:
+                        _context.t1 = resolvedValue;
+                      case 8:
+                        _context.t2 = _context.t1;
+                        _context.t0.update.call(_context.t0, _context.t2);
+                      case 10:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }, _callee, this);
+                }));
               });
-            });
+              promises = [].concat(_toConsumableArray(promises), [updatePromise]);
+            }
           });
-          promises = __spreadArray(__spreadArray([], promises, true), [updatePromise], false);
-        }
-      });
-      return [2 /*return*/, Promise.all(promises).then(function () {
-        return resolved;
-      })];
-    });
-  });
+          return _context2.abrupt("return", Promise.all(promises).then(function () {
+            return resolved;
+          }));
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
 }
 
-var TimeoutError = /** @class */function (_super) {
-  __extends(TimeoutError, _super);
+var TimeoutError = /*#__PURE__*/function (_Error) {
+  _inherits(TimeoutError, _Error);
   function TimeoutError(message) {
-    var _this = _super.call(this, message) || this;
+    var _this;
+    _classCallCheck(this, TimeoutError);
+    _this = _callSuper(this, TimeoutError, [message]);
     _this.name = 'TimeoutError';
     _this.code = 'ETIMEDOUT';
     _this.timestamp = new Date();
     // Maintain proper stack trace (only available in V8 engines, e.g., Chrome and Node.js)
     if (Error.captureStackTrace) {
-      Error.captureStackTrace(_this, TimeoutError);
+      Error.captureStackTrace(_assertThisInitialized(_this), TimeoutError);
     }
     return _this;
   }
-  return TimeoutError;
-}(Error);
+  return _createClass(TimeoutError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
 function withTimeout(fn, timeout) {
   return function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
     return new Promise(function (resolve, reject) {
       var timer = setTimeout(function () {
@@ -627,15 +1157,15 @@ function withTimeout(fn, timeout) {
 }
 
 var SKIPPED = Symbol();
-function batchFn(itemFn, _a) {
-  var _b = _a === void 0 ? {} : _a,
-    _c = _b.batchSize,
-    batchSize = _c === void 0 ? 10 : _c,
-    skip = _b.skip,
-    _d = _b.retry,
-    retry = _d === void 0 ? false : _d,
-    timeout = _b.timeout,
-    rollback = _b.rollback;
+function batchFn(itemFn) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$batchSize = _ref.batchSize,
+    batchSize = _ref$batchSize === void 0 ? 10 : _ref$batchSize,
+    skip = _ref.skip,
+    _ref$retry = _ref.retry,
+    retry = _ref$retry === void 0 ? false : _ref$retry,
+    timeout = _ref.timeout,
+    rollback = _ref.rollback;
   //
   // Optionally wrap itemFn into timeout
   //
@@ -647,11 +1177,11 @@ function batchFn(itemFn, _a) {
     // const events = new EventEmitter<EventTypes>()
     var progressCount = 0;
     var resultsPromise = promiseReduce(batches, function (acc, batchItems, index) {
-      return __awaiter(_this, void 0, void 0, function () {
+      return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var _this2 = this;
         var batch, batchResults;
-        var _this = this;
-        return __generator(this, function (_a) {
-          switch (_a.label) {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
             case 0:
               batch = {
                 index: index,
@@ -660,40 +1190,49 @@ function batchFn(itemFn, _a) {
               promise.emit('batchStart', {
                 batch: batch
               });
-              return [4 /*yield*/, Promise.all(batchItems.map(function (item) {
-                return __awaiter(_this, void 0, void 0, function () {
-                  var itemSkip, itemResult, _a, err_1, rollbackErr_1;
-                  return __generator(this, function (_b) {
-                    switch (_b.label) {
+              //
+              // A batch items are executed in parallell
+              //
+              _context2.next = 4;
+              return Promise.all(batchItems.map(function (item) {
+                return __awaiter(_this2, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                  var itemSkip, itemResult;
+                  return _regeneratorRuntime().wrap(function _callee$(_context) {
+                    while (1) switch (_context.prev = _context.next) {
                       case 0:
-                        _b.trys.push([0, 5,, 10]);
+                        _context.prev = 0;
                         promise.emit('itemStart', {
                           batch: batch,
                           item: item
                         });
-                        return [4 /*yield*/, typeof skip === 'function' && skip(item)];
-                      case 1:
-                        itemSkip = _b.sent();
+                        _context.next = 4;
+                        return typeof skip === 'function' && skip(item);
+                      case 4:
+                        itemSkip = _context.sent;
                         if (itemSkip) {
                           promise.emit('itemSkip', {
                             batch: batch,
                             item: item
                           });
                         }
-                        if (!itemSkip) return [3 /*break*/, 2];
-                        _a = SKIPPED;
-                        return [3 /*break*/, 4];
-                      case 2:
-                        return [4 /*yield*/, retry === true ? backOff(function () {
+                        if (!itemSkip) {
+                          _context.next = 10;
+                          break;
+                        }
+                        _context.t0 = SKIPPED;
+                        _context.next = 13;
+                        break;
+                      case 10:
+                        _context.next = 12;
+                        return retry === true ? backOff(function () {
                           return itemFn(item);
                         }) : _typeof(retry) === 'object' && retry !== null ? backOff(function () {
                           return itemFn(item);
-                        }, retry) : itemFn(item)];
-                      case 3:
-                        _a = _b.sent();
-                        _b.label = 4;
-                      case 4:
-                        itemResult = _a;
+                        }, retry) : itemFn(item);
+                      case 12:
+                        _context.t0 = _context.sent;
+                      case 13:
+                        itemResult = _context.t0;
                         progressCount += 1;
                         promise.emit('progress', {
                           type: itemSkip ? 'skip' : 'data',
@@ -702,48 +1241,55 @@ function batchFn(itemFn, _a) {
                           item: item,
                           result: itemResult
                         });
-                        return [2 /*return*/, itemResult];
-                      case 5:
-                        err_1 = _b.sent();
+                        return _context.abrupt("return", itemResult);
+                      case 19:
+                        _context.prev = 19;
+                        _context.t1 = _context["catch"](0);
                         progressCount += 1;
                         promise.emit('progress', {
                           type: 'error',
                           batch: batch,
                           progress: progressCount / items.length,
                           item: item,
-                          result: err_1
+                          result: _context.t1
                         });
-                        if (!(typeof rollback === 'function')) return [3 /*break*/, 9];
-                        _b.label = 6;
-                      case 6:
-                        _b.trys.push([6, 8,, 9]);
-                        return [4 /*yield*/, rollback(item, err_1)];
-                      case 7:
-                        _b.sent();
-                        return [3 /*break*/, 9];
-                      case 8:
-                        rollbackErr_1 = _b.sent();
-                        console.error('Failure rolling back', rollbackErr_1);
-                        return [3 /*break*/, 9];
-                      case 9:
-                        return [2 /*return*/, err_1];
-                      case 10:
-                        return [2 /*return*/];
+                        if (!(typeof rollback === 'function')) {
+                          _context.next = 32;
+                          break;
+                        }
+                        _context.prev = 24;
+                        _context.next = 27;
+                        return rollback(item, _context.t1);
+                      case 27:
+                        _context.next = 32;
+                        break;
+                      case 29:
+                        _context.prev = 29;
+                        _context.t2 = _context["catch"](24);
+                        console.error('Failure rolling back', _context.t2);
+                      case 32:
+                        return _context.abrupt("return", _context.t1);
+                      case 33:
+                      case "end":
+                        return _context.stop();
                     }
-                  });
-                });
-              }))];
-            case 1:
-              batchResults = _a.sent();
+                  }, _callee, null, [[0, 19], [24, 29]]);
+                }));
+              }));
+            case 4:
+              batchResults = _context2.sent;
               promise.emit('batchProgress', {
                 batch: batch,
                 progress: batch.index + 1 / batches.length,
                 results: batchResults
               });
-              return [2 /*return*/, __spreadArray(__spreadArray([], acc, true), batchResults, true)];
+              return _context2.abrupt("return", [].concat(_toConsumableArray(acc), _toConsumableArray(batchResults)));
+            case 7:
+            case "end":
+              return _context2.stop();
           }
-        });
-      });
+        }, _callee2);
+      }));
     }, []);
     resultsPromise.then(function (results) {
       promise.resolve(results);
@@ -760,16 +1306,16 @@ function batchFn(itemFn, _a) {
 function parseBatchedResults(inputs, results) {
   return results.reduce(function (acc, result, index) {
     if (result === SKIPPED) {
-      return _assign(_assign({}, acc), {
-        skipped: __spreadArray(__spreadArray([], acc.skipped, true), [inputs[index]], false)
+      return Object.assign(Object.assign({}, acc), {
+        skipped: [].concat(_toConsumableArray(acc.skipped), [inputs[index]])
       });
     } else if (result instanceof Error) {
-      return _assign(_assign({}, acc), {
-        errors: __spreadArray(__spreadArray([], acc.errors, true), [result], false)
+      return Object.assign(Object.assign({}, acc), {
+        errors: [].concat(_toConsumableArray(acc.errors), [result])
       });
     } else {
-      return _assign(_assign({}, acc), {
-        results: __spreadArray(__spreadArray([], acc.results, true), [result], false)
+      return Object.assign(Object.assign({}, acc), {
+        results: [].concat(_toConsumableArray(acc.results), [result])
       });
     }
   }, {
@@ -836,24 +1382,27 @@ function hasNestedPromises(input) {
 }
 function _makeDefaultAsyncExpFn(syncFn) {
   return function defaultAsyncExpFn() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    return __awaiter(this, void 0, void 0, function () {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
       var resolvedArgs;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
           case 0:
-            return [4 /*yield*/, Promise.all(args.map(function (arg) {
+            _context.next = 2;
+            return Promise.all(args.map(function (arg) {
               return resolveNestedPromises(arg);
-            }))];
-          case 1:
-            resolvedArgs = _a.sent();
-            return [2 /*return*/, syncFn.apply(void 0, resolvedArgs)];
+            }));
+          case 2:
+            resolvedArgs = _context.sent;
+            return _context.abrupt("return", syncFn.apply(void 0, _toConsumableArray(resolvedArgs)));
+          case 4:
+          case "end":
+            return _context.stop();
         }
-      });
-    });
+      }, _callee);
+    }));
   };
 }
 function _defaultArgsContainPromises(args) {
@@ -872,44 +1421,15 @@ function _defaultArgsContainPromises(args) {
  * in the inputs and executes sync or async versions
  * accordingly
  */
-function maybeAsyncFn(_a) {
-  var syncFn = _a.syncFn,
-    _b = _a.asyncFn,
-    asyncFn = _b === void 0 ? _makeDefaultAsyncExpFn(syncFn) : _b,
-    //
-    // By default, argsContainPromises checks
-    // if the any of the arguments provided are
-    // themselves a promise or if they have a nested promise
-    //
-    // Allow the argsContainPromises to be configurable.
-    // This allows for more specialized checks that
-    // would perform better, some examples:
-    // - If the first argument includes a promise
-    // - If some deeply nested argument is set
-    //   to a value that will incur in the need
-    //   for async resolution, even if the input arg
-    //   itself is not a promise
-    //
-    _c = _a.argsContainPromises,
-    //
-    // By default, argsContainPromises checks
-    // if the any of the arguments provided are
-    // themselves a promise or if they have a nested promise
-    //
-    // Allow the argsContainPromises to be configurable.
-    // This allows for more specialized checks that
-    // would perform better, some examples:
-    // - If the first argument includes a promise
-    // - If some deeply nested argument is set
-    //   to a value that will incur in the need
-    //   for async resolution, even if the input arg
-    //   itself is not a promise
-    //
-    argsContainPromises = _c === void 0 ? _defaultArgsContainPromises : _c;
+function maybeAsyncFn(_ref) {
+  var syncFn = _ref.syncFn,
+    _ref$asyncFn = _ref.asyncFn,
+    asyncFn = _ref$asyncFn === void 0 ? _makeDefaultAsyncExpFn(syncFn) : _ref$asyncFn,
+    _ref$argsContainPromi = _ref.argsContainPromises,
+    argsContainPromises = _ref$argsContainPromi === void 0 ? _defaultArgsContainPromises : _ref$argsContainPromi;
   return function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
     }
     return argsContainPromises(args) ? asyncFn.apply(void 0, args) : syncFn.apply(void 0, args);
   };
@@ -933,9 +1453,9 @@ function untilConditionIsSatisfiedReducer(condition, reduce) {
       //
       var syncResult = reduce(acc, value, index, allValues);
       if (isPromise(syncResult)) {
-        var remainingValues_1 = allValues.slice(index + 1);
+        var remainingValues = allValues.slice(index + 1);
         return syncResult.then(function (asyncResult) {
-          return condition(asyncResult) ? asyncResult : remainingValues_1.reduce(reducer, asyncResult);
+          return condition(asyncResult) ? asyncResult : remainingValues.reduce(reducer, asyncResult);
         });
       } else {
         return syncResult;
@@ -948,10 +1468,8 @@ function maybeReturnPromise(result, parseResult) {
   return isPromise(result) ? result.then(parseResult) : parseResult(result);
 }
 
-function syntheticJson(str, maxLength) {
-  if (maxLength === void 0) {
-    maxLength = 10000;
-  }
+function syntheticJson(str) {
+  var maxLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10000;
   // Step 0: Reject overly long input early to prevent
   // any possible vulnerability with ReDoS
   if (str.length > maxLength) {
@@ -993,15 +1511,16 @@ function _jsonLikeParseArgs(argsStr) {
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function strExpr(_a) {
-  var expressions = _a.expressions,
-    _b = _a.pipe,
-    pipe = _b === void 0 ? '|' : _b,
-    _c = _a.parseArgs,
-    parseArgs = _c === void 0 ? _jsonLikeParseArgs : _c;
-  var _d = Array.isArray(expressions) ? [expressions, null] : [Object.keys(expressions), expressions],
-    expressionIds = _d[0],
-    expressionFns = _d[1];
+function strExpr(_ref) {
+  var expressions = _ref.expressions,
+    _ref$pipe = _ref.pipe,
+    pipe = _ref$pipe === void 0 ? '|' : _ref$pipe,
+    _ref$parseArgs = _ref.parseArgs,
+    parseArgs = _ref$parseArgs === void 0 ? _jsonLikeParseArgs : _ref$parseArgs;
+  var _ref2 = Array.isArray(expressions) ? [expressions, null] : [Object.keys(expressions), expressions],
+    _ref3 = _slicedToArray(_ref2, 2),
+    expressionIds = _ref3[0],
+    expressionFns = _ref3[1];
   if (expressionIds.length === 0) {
     throw new Error('No expressions provided');
   }
@@ -1112,11 +1631,10 @@ function switchValue(input, cases) {
   }
 }
 function switchExec(input, cases) {
-  var args = [];
-  for (var _i = 2; _i < arguments.length; _i++) {
-    args[_i - 2] = arguments[_i];
-  }
   var fn = switchValue(input, cases);
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
   return fn.apply(void 0, args);
 }
 
@@ -1197,26 +1715,31 @@ var typeOf = makeTypeOf(DEFAULT_TYPES);
 function defaultParseResponse(response) {
   return response.json();
 }
-function paginatedHttpFetch(_a) {
-  var pageUrl = _a.pageUrl,
-    _b = _a.parseResponse,
-    parseResponse = _b === void 0 ? defaultParseResponse : _b;
+function paginatedHttpFetch(_ref) {
+  var pageUrl = _ref.pageUrl,
+    _ref$parseResponse = _ref.parseResponse,
+    parseResponse = _ref$parseResponse === void 0 ? defaultParseResponse : _ref$parseResponse;
   return function (params) {
-    return __awaiter(this, void 0, void 0, function () {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
       var response, data;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
           case 0:
-            return [4 /*yield*/, fetch(pageUrl(params))];
-          case 1:
-            response = _a.sent();
-            return [4 /*yield*/, parseResponse(response)];
+            _context.next = 2;
+            return fetch(pageUrl(params));
           case 2:
-            data = _a.sent();
-            return [2 /*return*/, data];
+            response = _context.sent;
+            _context.next = 5;
+            return parseResponse(response);
+          case 5:
+            data = _context.sent;
+            return _context.abrupt("return", data);
+          case 7:
+          case "end":
+            return _context.stop();
         }
-      });
-    });
+      }, _callee);
+    }));
   };
 }
 function inMemoryDataStore() {
@@ -1226,68 +1749,69 @@ function inMemoryDataStore() {
       return data.length;
     },
     storePage: function storePage(pageData) {
-      data = __spreadArray(__spreadArray([], data, true), pageData, true);
+      data = [].concat(_toConsumableArray(data), _toConsumableArray(pageData));
     },
     getResult: function getResult() {
       return data;
     }
   };
 }
-function fetchAllPages(_a) {
-  var fetchPage = _a.fetchPage,
-    _b = _a.pageSize,
-    pageSize = _b === void 0 ? 50 : _b,
-    _c = _a.dataStore,
-    dataStore = _c === void 0 ? inMemoryDataStore : _c;
-  return __awaiter(this, void 0, void 0, function () {
+function fetchAllPages(_ref2) {
+  var fetchPage = _ref2.fetchPage,
+    _ref2$pageSize = _ref2.pageSize,
+    pageSize = _ref2$pageSize === void 0 ? 50 : _ref2$pageSize,
+    _ref2$dataStore = _ref2.dataStore,
+    dataStore = _ref2$dataStore === void 0 ? inMemoryDataStore : _ref2$dataStore;
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
     var store, currentPageData, currentOffset, result;
-    return __generator(this, function (_d) {
-      switch (_d.label) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
         case 0:
           store = dataStore();
           currentPageData = null;
-          _d.label = 1;
-        case 1:
-          return [4 /*yield*/, store.getSize()];
         case 2:
-          currentOffset = _d.sent();
-          return [4 /*yield*/, fetchPage({
+          _context2.next = 4;
+          return store.getSize();
+        case 4:
+          currentOffset = _context2.sent;
+          _context2.next = 7;
+          return fetchPage({
             offset: currentOffset,
             pageSize: pageSize
-          })];
-        case 3:
-          currentPageData = _d.sent();
-          return [4 /*yield*/, store.storePage(currentPageData, {
+          });
+        case 7:
+          currentPageData = _context2.sent;
+          _context2.next = 10;
+          return store.storePage(currentPageData, {
             offset: currentOffset,
             pageSize: pageSize
-          })];
-        case 4:
-          _d.sent();
-          _d.label = 5;
-        case 5:
-          if (currentPageData.length === pageSize) return [3 /*break*/, 1];
-          _d.label = 6;
-        case 6:
-          return [4 /*yield*/, store.getResult()];
-        case 7:
-          result = _d.sent();
-          return [2 /*return*/, result];
+          });
+        case 10:
+          if (currentPageData.length === pageSize) {
+            _context2.next = 2;
+            break;
+          }
+        case 11:
+          _context2.next = 13;
+          return store.getResult();
+        case 13:
+          result = _context2.sent;
+          return _context2.abrupt("return", result);
+        case 15:
+        case "end":
+          return _context2.stop();
       }
-    });
-  });
+    }, _callee2);
+  }));
 }
 
 function deprecateFn(fn, message) {
   // Creating a new function that wraps the original function
   var wrappedFunction = function wrappedFunction() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
-    }
     if (process.env.NODE_ENV !== 'production') {
       console.warn(["[deprecated][fn] ".concat(fn.name, " is deprecated"), message].filter(Boolean).join(': '));
     }
-    return fn.apply(void 0, args);
+    return fn.apply(void 0, arguments);
   };
   // Copying the original function's properties to the new function
   Object.assign(wrappedFunction, fn);
@@ -1322,10 +1846,8 @@ function deprecateInput(inputValue, message, convert) {
   }
 }
 
-function slugify(str, delimiter) {
-  if (delimiter === void 0) {
-    delimiter = '-';
-  }
+function slugify(str) {
+  var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '-';
   // Escape the delimiter for safe use in regex
   var safeDelimiter = delimiter.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
   var CONSECUTIVE_DELIMITER_RE = new RegExp("".concat(safeDelimiter, "+"), 'g');
@@ -1340,77 +1862,95 @@ function slugify(str, delimiter) {
 }
 var normalizeString = deprecateFn(slugify, 'normalizeString is depreacted, use @orioro/util -> slugify instead');
 
-//
-// Hook module
-//
-function hookFn(fn, _a) {
-  var input = _a.input,
-    validate = _a.validate,
-    before = _a.before,
-    output = _a.output,
-    after = _a.after;
+function hookFn(fn, _ref) {
+  var input = _ref.input,
+    validate = _ref.validate,
+    before = _ref.before,
+    output = _ref.output,
+    after = _ref.after;
   return function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    return __awaiter(this, void 0, void 0, function () {
-      var _input, _a, validationResult, error, rawResult, result, _b;
-      return __generator(this, function (_c) {
-        switch (_c.label) {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var _input, validationResult, error, rawResult, result;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
           case 0:
-            if (!(typeof input === 'function')) return [3 /*break*/, 2];
-            return [4 /*yield*/, input.apply(void 0, args)];
-          case 1:
-            _a = _c.sent();
-            return [3 /*break*/, 3];
-          case 2:
-            _a = args;
-            _c.label = 3;
-          case 3:
-            _input = _a;
-            if (!Array.isArray(_input)) {
-              throw new TypeError('Input hook must resolve an array of args');
+            if (!(typeof input === 'function')) {
+              _context.next = 6;
+              break;
             }
-            if (!(typeof validate === 'function')) return [3 /*break*/, 5];
-            return [4 /*yield*/, validate.apply(void 0, _input)];
-          case 4:
-            validationResult = _c.sent();
-            if (validationResult !== true) {
-              error = typeof validationResult === 'string' ? new Error(validationResult) : validationResult instanceof Error ? validationResult : new Error('Invalid input');
-              throw error;
-            }
-            _c.label = 5;
-          case 5:
-            if (!(typeof before === 'function')) return [3 /*break*/, 7];
-            return [4 /*yield*/, before.apply(void 0, _input)];
+            _context.next = 3;
+            return input.apply(void 0, args);
+          case 3:
+            _context.t0 = _context.sent;
+            _context.next = 7;
+            break;
           case 6:
-            _c.sent();
-            _c.label = 7;
+            _context.t0 = args;
           case 7:
-            return [4 /*yield*/, fn.apply(void 0, _input)];
-          case 8:
-            rawResult = _c.sent();
-            if (!(typeof output === 'function')) return [3 /*break*/, 10];
-            return [4 /*yield*/, output(rawResult)];
-          case 9:
-            _b = _c.sent();
-            return [3 /*break*/, 11];
+            _input = _context.t0;
+            if (Array.isArray(_input)) {
+              _context.next = 10;
+              break;
+            }
+            throw new TypeError('Input hook must resolve an array of args');
           case 10:
-            _b = rawResult;
-            _c.label = 11;
-          case 11:
-            result = _b;
-            if (!(typeof after === 'function')) return [3 /*break*/, 13];
-            return [4 /*yield*/, after.apply(void 0, __spreadArray([result], _input, false))];
-          case 12:
-            _c.sent();
-            _c.label = 13;
+            if (!(typeof validate === 'function')) {
+              _context.next = 17;
+              break;
+            }
+            _context.next = 13;
+            return validate.apply(void 0, _toConsumableArray(_input));
           case 13:
-            return [2 /*return*/, result];
+            validationResult = _context.sent;
+            if (!(validationResult !== true)) {
+              _context.next = 17;
+              break;
+            }
+            error = typeof validationResult === 'string' ? new Error(validationResult) : validationResult instanceof Error ? validationResult : new Error('Invalid input');
+            throw error;
+          case 17:
+            if (!(typeof before === 'function')) {
+              _context.next = 20;
+              break;
+            }
+            _context.next = 20;
+            return before.apply(void 0, _toConsumableArray(_input));
+          case 20:
+            _context.next = 22;
+            return fn.apply(void 0, _toConsumableArray(_input));
+          case 22:
+            rawResult = _context.sent;
+            if (!(typeof output === 'function')) {
+              _context.next = 29;
+              break;
+            }
+            _context.next = 26;
+            return output(rawResult);
+          case 26:
+            _context.t1 = _context.sent;
+            _context.next = 30;
+            break;
+          case 29:
+            _context.t1 = rawResult;
+          case 30:
+            result = _context.t1;
+            if (!(typeof after === 'function')) {
+              _context.next = 34;
+              break;
+            }
+            _context.next = 34;
+            return after.apply(void 0, [result].concat(_toConsumableArray(_input)));
+          case 34:
+            return _context.abrupt("return", result);
+          case 35:
+          case "end":
+            return _context.stop();
         }
-      });
-    });
+      }, _callee);
+    }));
   };
 }
 
@@ -1464,23 +2004,23 @@ function url(spec) {
   if (typeof spec === 'string') {
     return new URL(spec).href;
   } else {
-    var url_1 = new URL(_baseHref(spec));
-    if (spec.protocol) url_1.protocol = spec.protocol;
-    if (spec.username) url_1.username = spec.username;
-    if (spec.password) url_1.password = spec.password;
-    if (spec.host) url_1.host = spec.host;
-    if (spec.hostname) url_1.hostname = spec.hostname;
-    if (spec.port) url_1.port = spec.port;
-    if (spec.pathname) url_1.pathname = spec.pathname;
-    if (spec.search) url_1.search = spec.search;
+    var _url = new URL(_baseHref(spec));
+    if (spec.protocol) _url.protocol = spec.protocol;
+    if (spec.username) _url.username = spec.username;
+    if (spec.password) _url.password = spec.password;
+    if (spec.host) _url.host = spec.host;
+    if (spec.hostname) _url.hostname = spec.hostname;
+    if (spec.port) _url.port = spec.port;
+    if (spec.pathname) _url.pathname = spec.pathname;
+    if (spec.search) _url.search = spec.search;
     // Handle searchParams
     if (spec.searchParams) {
       var searchString = Array.isArray(spec.searchParams) ? queryString.stringify(spec.searchParams[0], spec.searchParams[1]) : queryString.stringify(spec.searchParams);
-      url_1.search = searchString;
+      _url.search = searchString;
     }
-    if (spec.hash) url_1.hash = spec.hash;
-    return url_1.href;
+    if (spec.hash) _url.hash = spec.hash;
+    return _url.href;
   }
 }
 
-export { DEFAULT_TYPES, PromiseLikeEventEmitter, SKIPPED, TimeoutError, arrayChunk, batchFn, dataJoin, debugFn, deepFreeze, deprecateFn, deprecateInput, deprecateProperty, fetchAllPages, hasNestedPromises, hookFn, inMemoryDataStore, interpolate, isPromise, isValidUrl, makeDeferred, makeTypeOf, maybeAsyncFn, maybeFn, maybeReturnPromise, normalizeString, paginatedHttpFetch, parseBatchedResults, pickPaths, promiseReduce, resolveNestedPromises, sequentialCallIdGenerator, slugify, strExpr, switchExec, switchValue, syntheticJson, typeMap, typeOf, untilConditionIsSatisfiedReducer, url, wait, withTimeout };
+export { DEFAULT_TYPES, PromiseLikeEventEmitter, SKIPPED, TimeoutError, arrayChunk, arrayLikeIterable, batchFn, dataJoin, debugFn, deepFreeze, deprecateFn, deprecateInput, deprecateProperty, fetchAllPages, hasNestedPromises, hookFn, inMemoryDataStore, interpolate, isPromise, isValidUrl, makeDeferred, makeTypeOf, maybeAsyncFn, maybeFn, maybeReturnPromise, normalizeString, paginatedHttpFetch, parseBatchedResults, pickPaths, promiseReduce, resolveNestedPromises, sequentialCallIdGenerator, slugify, strExpr, switchExec, switchValue, syntheticJson, typeMap, typeOf, untilConditionIsSatisfiedReducer, url, wait, withTimeout };