@orioro/util 0.0.0 → 0.2.0

package/dist/index.mjs

@@ -1,111 +1,1475 @@
-function _typeof(obj) {
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function (obj) {
-      return typeof obj;
+import EventEmitter from 'eventemitter3';
+import copy from 'fast-copy';
+import { getProperty, setProperty } from 'dot-prop';
+import traverse from 'traverse';
+
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (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 */
+
+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;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+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];
+    }
+    return t;
+  };
+  return _assign.apply(this, arguments);
+};
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}
+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());
+  });
+}
+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;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
     };
-  } else {
-    _typeof = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }
+  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 {
+            value: op[1],
+            done: false
+          };
+        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;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
     };
   }
+}
+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];
+    }
+  }
+  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;
+};
 
-  return _typeof(obj);
+var PromiseLikeEventEmitter = /** @class */function (_super) {
+  __extends(PromiseLikeEventEmitter, _super);
+  function PromiseLikeEventEmitter() {
+    var _this = _super.call(this) || this;
+    _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);
+  };
+  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 _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+function deepFreeze(object) {
+  Object.freeze(object);
+  if (Array.isArray(object)) {
+    // Handle the array case
+    object.forEach(function (item) {
+      if (item && _typeof(item) === 'object' && !Object.isFrozen(item)) {
+        deepFreeze(item);
+      }
+    });
+  } else {
+    // Handle the object case
+    Object.keys(object).forEach(function (key) {
+      var value = object[key];
+      if (value && _typeof(value) === 'object' && !Object.isFrozen(value)) {
+        deepFreeze(value);
+      }
+    });
+  }
+  return object;
 }
 
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) {
-    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+function stringifyReplacer(key, value) {
+  if (typeof value === 'function') {
+    // Convert functions to a consistent string representation
+    return "function:".concat(value.toString());
+  }
+  return value;
+}
+function simpleHash(str) {
+  var hash = 0;
+  for (var i = 0; i < str.length; i++) {
+    var _char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + _char;
+    hash |= 0; // Convert to 32bit integer
+  }
+  // Ensure the hash is positive to avoid '-' signals
+  hash = Math.abs(hash);
+  return hash.toString(36); // Convert to base36 to ensure the result is alphanumeric
+}
+function generateDeterministicId(args) {
+  // Convert arguments to a JSON string using the custom replacer
+  var argsString = JSON.stringify(args, stringifyReplacer);
+  // Generate a simple hash of the string
+  return simpleHash(argsString);
+}
+
+function debugFn(fnName, fn, logCall, logResult) {
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    var callId = generateDeterministicId(__spreadArray([fnName, fn], args, true));
+    if (typeof logCall === 'function') {
+      // Deep clone args, so that we may detect mutations later on
+      logCall({
+        type: 'call',
+        callId: callId,
+        args: copy(args),
+        fnName: fnName
+      });
+    }
+    var result = fn.apply(void 0, args);
+    if (typeof logResult === 'function') {
+      logResult({
+        type: 'result',
+        callId: callId,
+        args: args,
+        result: result,
+        fnName: fnName
+      });
+    }
+    return result;
+  };
+}
 
-    return arr2;
+/**
+ * /\$\{\s*([\w$.]+)\s*\}/g
+ * ![](docs/resources/interpolation_regexp.png)
+ *
+ * RegExp used for matching interpolation expressions.
+ * Allows a non-interrupted sequence of alphanumeric chars ([A-Za-z0-9_]),
+ * dollar signs ($) and dots (.) wrapped in curly braces ({})
+ * with or without any number of whitespace chars (' ') between braces and the
+ * value identifier.
+ *
+ * Some resources on RegExp safety concerning RegExp Denial of Service (ReDOS)
+ * through Catastrophic backtracking, for future study and reference:
+ *
+ * - [Catastrophic backtracking](https://www.regular-expressions.info/catastrophic.html)
+ * - [Regular expression visualizer](https://github.com/CJex/regulex)
+ * - [Validator.js](https://github.com/validatorjs/validator.js)
+ * - [Stack Overflow interesting question](https://stackoverflow.com/questions/63127145/safe-regex-patterns-from-redos-attack)
+ * - [Catastrophic backtracking - JavaScript Info](https://javascript.info/regexp-catastrophic-backtracking#preventing-backtracking)
+ * - [Google re2 library](https://github.com/google/re2)
+ * - [Google re2 for Node.js - re2](https://github.com/uhop/node-re2/)
+ *
+ * @const {RegExp} INTERPOLATION_REGEXP
+ */
+var INTERPOLATION_REGEXP = /\$\{\s*([\w$.]+)\s*\}/g;
+/**
+ * @function $stringInterpolate
+ * @param {String} template Basic JS template string like `${value.path}` value
+ *                          interpolation. It is possible to access nested properties
+ *                          through dot `.` notation. Keywords between braces are
+ *                          only interpreted as paths to the value. No logic
+ *                          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;
+  if (template.length > maxLength) {
+    throw new Error("Template exceeds maxLength ".concat(maxLength));
   }
+  return template.replace(INTERPOLATION_REGEXP, function (_, path) {
+    var value = getProperty(data, path);
+    switch (_typeof(value)) {
+      case 'number':
+        {
+          return value + '';
+        }
+      case 'string':
+        {
+          return value;
+        }
+      default:
+        {
+          console.warn("Attempting to use non interpolatable value in interpolate ".concat(value));
+          return '';
+        }
+    }
+  });
 }
 
-function _iterableToArray(iter) {
-  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+function maybeFn(input) {
+  var args = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    args[_i - 1] = arguments[_i];
+  }
+  return typeof input === 'function' ? input.apply(void 0, args) : input;
 }
 
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance");
+function promiseReduce(inputArr, reducerFn, initial) {
+  return inputArr.reduce(function (prevPromise, input, index) {
+    return prevPromise.then(function (acc) {
+      return reducerFn(acc, input, index);
+    });
+  }, Promise.resolve(initial));
 }
 
-var mingo = require('mingo');
+var DEFAULT_OPTIONS = {
+  mode: 'eager',
+  maxDepth: 30,
+  clone: copy
+};
+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 () {
+    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*/];
+                }
+              });
+            });
+          });
+          promises = __spreadArray(__spreadArray([], promises, true), [updatePromise], false);
+        }
+      });
+      return [2 /*return*/, Promise.all(promises).then(function () {
+        return resolved;
+      })];
+    });
+  });
+}
 
-var _test = function _test(criteria) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
+function arrayChunk(array, chunkSize) {
+  var chunks = [];
+  for (var i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
   }
+  return chunks;
+}
+
+var SKIPPED = Symbol();
+function batchFn(fn, _a) {
+  var _b = _a === void 0 ? {} : _a,
+    _c = _b.batchSize,
+    batchSize = _c === void 0 ? 10 : _c,
+    skip = _b.skip;
+  return function batchExec(items) {
+    var _this = this;
+    var batches = arrayChunk(items, batchSize);
+    var promise = new PromiseLikeEventEmitter();
+    // const events = new EventEmitter<EventTypes>()
+    var progressCount = 0;
+    var resultsPromise = promiseReduce(batches, function (acc, batchItems, index) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var batch, batchResults;
+        var _this = this;
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              batch = {
+                index: index,
+                items: batchItems
+              };
+              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;
+                  return __generator(this, function (_b) {
+                    switch (_b.label) {
+                      case 0:
+                        _b.trys.push([0, 5,, 6]);
+                        promise.emit('itemStart', {
+                          batch: batch,
+                          item: item
+                        });
+                        return [4 /*yield*/, typeof skip === 'function' && skip(item)];
+                      case 1:
+                        itemSkip = _b.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*/, fn(item)];
+                      case 3:
+                        _a = _b.sent();
+                        _b.label = 4;
+                      case 4:
+                        itemResult = _a;
+                        progressCount += 1;
+                        promise.emit('progress', {
+                          type: itemSkip ? 'skip' : 'data',
+                          batch: batch,
+                          progress: progressCount / items.length,
+                          item: item,
+                          result: itemResult
+                        });
+                        return [2 /*return*/, itemResult];
+                      case 5:
+                        err_1 = _b.sent();
+                        progressCount += 1;
+                        promise.emit('progress', {
+                          type: 'error',
+                          batch: batch,
+                          progress: progressCount / items.length,
+                          item: item,
+                          result: err_1
+                        });
+                        return [2 /*return*/, err_1];
+                      case 6:
+                        return [2 /*return*/];
+                    }
+                  });
+                });
+              }))];
+            case 1:
+              batchResults = _a.sent();
+              promise.emit('batchProgress', {
+                batch: batch,
+                progress: batch.index + 1 / batches.length,
+                results: batchResults
+              });
+              return [2 /*return*/, __spreadArray(__spreadArray([], acc, true), batchResults, true)];
+          }
+        });
+      });
+    }, []);
+    resultsPromise.then(function (results) {
+      promise.resolve(results);
+      promise.emit('results', {
+        results: results
+      });
+    }, function (err) {
+      promise.reject(err);
+      promise.emit('error', err);
+    });
+    return promise;
+  };
+}
+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)
+      });
+    } else if (result instanceof Error) {
+      return _assign(_assign({}, acc), {
+        errors: __spreadArray(__spreadArray([], acc.errors, true), [result], false)
+      });
+    } else {
+      return _assign(_assign({}, acc), {
+        results: __spreadArray(__spreadArray([], acc.results, true), [result], false)
+      });
+    }
+  }, {
+    results: [],
+    errors: [],
+    skipped: []
+  });
+}
+
+function resolvePaths(sourceObj, paths) {
+  return paths.reduce(function (acc, path) {
+    var _a = Array.isArray(path) ? path : [path, path],
+      targetPath = _a[0],
+      resolver = _a[1];
+    var value = typeof resolver === 'string' ? getProperty(sourceObj, resolver) : resolver(sourceObj);
+    return setProperty(acc, targetPath, value);
+  }, {});
+}
 
-  if (_typeof(criteria) === 'object') {
-    var query = new mingo.Query(criteria);
-    return query.test(args[0]);
-  } else if (typeof criteria === 'function') {
-    return criteria.apply(void 0, args);
+function testCriteria(criteria, input) {
+  switch (_typeof(criteria)) {
+    case 'function':
+      {
+        return criteria(input);
+      }
+    case 'object':
+      {
+        if (criteria instanceof RegExp) {
+          return criteria.test(input);
+        } else {
+          throw new Error('Unsupported criteria');
+        }
+      }
+    case 'string':
+    case 'symbol':
+      {
+        return criteria === input;
+      }
+  }
+}
+function switchValue(input, cases) {
+  if (Array.isArray(cases)) {
+    var matching = cases.find(function (case_) {
+      return case_.length === 1 || testCriteria(case_[0], input);
+    });
+    return matching ? matching.length === 1 ? matching[0] : matching[1] : undefined;
   } else {
-    return criteria;
+    return cases[input] || cases["default"];
   }
-};
+}
+function switchExec(input, cases) {
+  var args = [];
+  for (var _i = 2; _i < arguments.length; _i++) {
+    args[_i - 2] = arguments[_i];
+  }
+  var fn = switchValue(input, cases);
+  return fn.apply(void 0, args);
+}
+
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+function isObject(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+}
+function isPlainObject(o) {
+  var ctor, prot;
+  if (isObject(o) === false) return false;
 
-var _fnApply = function _fnApply(fnSpec) {
-  for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-    args[_key2 - 1] = arguments[_key2];
+  // If has modified constructor
+  ctor = o.constructor;
+  if (ctor === undefined) return true;
+
+  // If has modified prototype
+  prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+
+  // If constructor does not have an Object-specific method
+  if (prot.hasOwnProperty('isPrototypeOf') === false) {
+    return false;
   }
 
-  return typeof fnSpec === 'function' ? fnSpec.apply(void 0, args) : fnSpec.fn.apply(fnSpec, args);
-};
+  // Most likely a plain Object
+  return true;
+}
 
-var applyMatching = function applyMatching(fnSpecList) {
-  for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-    args[_key3 - 1] = arguments[_key3];
+//
+// The only role of this function is to let typescript
+// be aware of the available types
+//
+function typeMap(typeMap) {
+  return typeMap;
+}
+function makeTypeOf(typeMap) {
+  return function typeOf(value) {
+    for (var typeName in typeMap) {
+      if (typeMap[typeName](value)) {
+        return typeName;
+      }
+    }
+    return null;
+  };
+}
+function basicType(typeName) {
+  return function (value) {
+    return _typeof(value) === typeName;
+  };
+}
+var DEFAULT_TYPES = typeMap({
+  //
+  // Primitives
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#primitive_values
+  //
+  "null": function _null(value) {
+    return value === null;
+  },
+  undefined: basicType('undefined'),
+  "boolean": basicType('boolean'),
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+  number: function number(value) {
+    return typeof value === 'number' && !Number.isNaN(value);
+  },
+  bigint: basicType('bigint'),
+  string: basicType('string'),
+  symbol: basicType('symbol'),
+  "function": basicType('function'),
+  object: isPlainObject,
+  array: function array(value) {
+    return Array.isArray(value);
+  },
+  regexp: function regexp(value) {
+    return value instanceof RegExp;
+  },
+  nan: function nan(value) {
+    return Number.isNaN(value);
+  },
+  date: function date(value) {
+    return value instanceof Date;
+  },
+  map: function map(value) {
+    return value instanceof Map;
+  },
+  weakmap: function weakmap(value) {
+    return value instanceof WeakMap;
+  },
+  set: function set(value) {
+    return value instanceof Set;
+  },
+  weakset: function weakset(value) {
+    return value instanceof WeakSet;
+  },
+  promise: function promise(value) {
+    return value instanceof Promise;
+  },
+  error: function error(value) {
+    return value instanceof Error;
   }
+});
+var typeOf = makeTypeOf(DEFAULT_TYPES);
 
-  var matching = fnSpecList.find(function (fnSpec) {
-    return _test.apply(void 0, [fnSpec.criteria].concat(args));
-  });
+var TYPE_RE = /([a-z0-9]+)(\!)?$/i;
+var TYPE_SEPARATOR_RE = /\s*\|\s*/g;
+function parseSingleType(typeInput) {
+  var match = typeInput.match(TYPE_RE);
+  if (!match) {
+    throw new Error("Invalid type ".concat(typeInput));
+  } else {
+    var typeName = match[1],
+      requiredSignal = match[2];
+    return {
+      type: typeName,
+      required: requiredSignal === '!'
+    };
+  }
+}
+function serializeExpectedTypes(expectedTypes) {
+  return expectedTypes.map(function (expectedType) {
+    return "".concat(expectedType.type).concat(expectedType.required ? '!' : '');
+  }).join(' | ');
+}
+function parseExpectedTypes(expectedTypesInput) {
+  switch (typeOf(expectedTypesInput)) {
+    case 'string':
+      {
+        return expectedTypesInput.split(TYPE_SEPARATOR_RE).map(function (typeInput) {
+          return parseSingleType(typeInput);
+        });
+      }
+    case 'array':
+      {
+        return expectedTypesInput.map(function (expectedType) {
+          return typeof expectedType === 'string' ? parseSingleType(expectedType) : expectedType;
+        });
+      }
+    case 'object':
+      {
+        return [expectedTypesInput];
+      }
+    default:
+      {
+        throw new Error("Invalid expectedType ".concat(expectedTypesInput));
+      }
+  }
+}
+function typeValidator(expectedTypesInput) {
+  var expectedTypes = parseExpectedTypes(expectedTypesInput);
+  return function validateType(input) {
+    var inputType = typeOf(input);
+    var nullOrUndefined = function nullOrUndefined() {
+      return expectedTypes.some(function (expectedType) {
+        return expectedType.type === 'undefined' || expectedType.type === 'null' || expectedType.required === false;
+      });
+    };
+    var isValid = switchExec(inputType, {
+      "null": nullOrUndefined,
+      undefined: nullOrUndefined,
+      "default": function _default() {
+        return expectedTypes.some(function (expectedType) {
+          return expectedType.type === inputType;
+        });
+      }
+    });
+    if (isValid) {
+      return true;
+    } else {
+      return {
+        expectedTypes: serializeExpectedTypes(expectedTypes),
+        input: input
+      };
+    }
+  };
+}
+
+//
+// And operator (serial)
+//
+function and$1(validators) {
+  return function validateAnd(input, _a) {
+    var validateSync = _a.validateSync;
+    var result = validators.reduce(function (acc, validator) {
+      return acc !== true ? acc : validateSync(validator, input);
+    }, true);
+    if (result === true) {
+      return true;
+    } else {
+      return result;
+    }
+  };
+}
+//
+// Or operator (serial)
+//
+function or$1(validators) {
+  return function validateOr(input, _a) {
+    var validateSync = _a.validateSync;
+    var someIsValid = validators.some(function (validator) {
+      return validateSync(validator, input) === true;
+    });
+    return someIsValid;
+  };
+}
+//
+// Not
+//
+function not$1(validator) {
+  return function validateNot(input, _a) {
+    var validateSync = _a.validateSync;
+    return validateSync(validator, input) !== true;
+  };
+}
+
+function _shapeGeneralValidator$1(_a) {
+  var input = _a.input,
+    baseType = _a.baseType,
+    collectNestedErrors = _a.collectNestedErrors,
+    validateSync = _a.validateSync;
+  var baseTypeValidation = validateSync(typeValidator({
+    type: baseType,
+    required: true
+  }), input);
+  if (baseTypeValidation !== true) {
+    return baseTypeValidation;
+  }
+  var nestedErrors = collectNestedErrors();
+  return nestedErrors.length === 0 ? true : {
+    input: input,
+    nestedErrors: nestedErrors
+  };
+}
+function obj$1(objShape) {
+  return function validateObject(input, _a) {
+    var validateSync = _a.validateSync;
+    return _shapeGeneralValidator$1({
+      input: input,
+      baseType: 'object',
+      validateSync: validateSync,
+      collectNestedErrors: function collectNestedErrors() {
+        return Object.entries(objShape).reduce(function (acc, _a) {
+          var path = _a[0],
+            pathValidator = _a[1];
+          var pathInput = getProperty(input, path);
+          var pathResult = validateSync(pathValidator, pathInput);
+          return pathResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, pathResult), {
+            path: path
+          })], false);
+        }, []);
+      }
+    });
+  };
+}
+function objOf$1(ofType) {
+  return function validateObjOf(input, _a) {
+    var validateSync = _a.validateSync;
+    return _shapeGeneralValidator$1({
+      input: input,
+      baseType: 'object',
+      validateSync: validateSync,
+      collectNestedErrors: function collectNestedErrors() {
+        return Object.entries(input).reduce(function (acc, _a) {
+          var key = _a[0],
+            keyInput = _a[1];
+          var indexResult = validateSync(ofType, keyInput);
+          return indexResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, indexResult), {
+            path: key
+          })], false);
+        }, []);
+      }
+    });
+  };
+}
+function tuple$1(tupleShape) {
+  return function validateTuple(input, _a) {
+    var validateSync = _a.validateSync;
+    return _shapeGeneralValidator$1({
+      input: input,
+      baseType: 'array',
+      validateSync: validateSync,
+      collectNestedErrors: function collectNestedErrors() {
+        return tupleShape.reduce(function (acc, indexValidator, index) {
+          var indexInput = input[index];
+          var indexResult = validateSync(indexValidator, indexInput);
+          return indexResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, indexResult), {
+            path: index + ''
+          })], false);
+        }, []);
+      }
+    });
+  };
+}
+function arrayOf$1(ofType) {
+  return function validateArrayOf(input, _a) {
+    var validateSync = _a.validateSync;
+    return _shapeGeneralValidator$1({
+      input: input,
+      baseType: 'array',
+      validateSync: validateSync,
+      collectNestedErrors: function collectNestedErrors() {
+        return input.reduce(function (acc, indexInput, index) {
+          var indexResult = validateSync(ofType, indexInput);
+          return indexResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, indexResult), {
+            path: index + ''
+          })], false);
+        }, []);
+      }
+    });
+  };
+}
 
-  if (matching) {
-    return _fnApply.apply(void 0, [matching].concat(args));
+function defaultErrorMessage(_a) {
+  var input = _a.input,
+    message = _a.message,
+    nestedErrors = _a.nestedErrors,
+    expectedTypes = _a.expectedTypes;
+  if (message) {
+    return message;
+  }
+  if (nestedErrors) {
+    return "Invalid input: `".concat(JSON.stringify(input), "`.\n").concat(nestedErrors.map(function (error) {
+      return "  - ".concat(error.path, ": ").concat(error.message);
+    }).join('\n'));
+  } else if (expectedTypes) {
+    var inputType = typeOf(input);
+    return "Invalid input: '".concat(input, "'. Expected type(s) `").concat(expectedTypes, "`, but got type `").concat(inputType === null ? 'unknown' : inputType, "`");
   } else {
-    throw new Error('No matching spec');
+    return "Invalid input: '".concat(input, "'.");
   }
-};
+}
 
-var applyMatchingReduce = function applyMatchingReduce(fnSpecList, arg) {
-  var injectArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  return fnSpecList.reduce(function (acc, fnSpec) {
-    return _test(fnSpec.criteria, acc) ? _fnApply.apply(void 0, [fnSpec, acc].concat(_toConsumableArray(injectArgs))) : acc;
-  }, arg);
-};
+function resolveValidationResult(_a) {
+  var input = _a.input,
+    result = _a.result,
+    errorMessage = _a.errorMessage;
+  if (result === true) {
+    return true;
+  } else {
+    var _falseLikeResult = function _falseLikeResult() {
+      return {
+        message: errorMessage({
+          input: input
+        })
+      };
+    };
+    return _assign({
+      input: input
+    }, switchExec(typeOf(result), {
+      string: function string() {
+        return {
+          message: result
+        };
+      },
+      error: function error() {
+        return {
+          message: result.message,
+          error: result
+        };
+      },
+      object: function object() {
+        var result_ = result;
+        return _assign(_assign({}, result_), {
+          message: errorMessage(result_)
+        });
+      },
+      //
+      // Boolean result here MUST be false, as true was tested earlier
+      //
+      "boolean": _falseLikeResult,
+      "null": _falseLikeResult,
+      undefined: _falseLikeResult,
+      //
+      // Unsupported validation result
+      //
+      "default": function _default() {
+        throw new Error("Invalid validation result: ".concat(result, " (").concat(typeOf(result), ")"));
+      }
+    }));
+  }
+}
 
-var applyMatchingReduceAsync = function applyMatchingReduceAsync(fnSpecList, arg) {
-  var injectArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  return fnSpecList.reduce(function (previous, fnSpec) {
-    return previous.then(function (res) {
-      return _test(fnSpec.criteria, res) ? Promise.resolve(_fnApply.apply(void 0, [fnSpec, res].concat(_toConsumableArray(injectArgs)))) : Promise.resolve(res);
+function parseValidatorInput(_a, validatorInput) {
+  var objValidator = _a.objValidator;
+  //
+  // Parses the validator fn.
+  // If provided with a string, will return a type validator
+  // If provided with a function, will return the function itself
+  //
+  function _parseValidatorFn(fnInput) {
+    switch (typeOf(fnInput)) {
+      case 'string':
+        {
+          return typeValidator(fnInput);
+        }
+      case 'object':
+        {
+          return objValidator(fnInput);
+        }
+      case 'function':
+        {
+          return fnInput;
+        }
+      default:
+        {
+          throw new TypeError("Unsupported fnInput ".concat(fnInput));
+        }
+    }
+  }
+  function _parseValidatorErrorMessageFn(fnInput) {
+    switch (_typeof(fnInput)) {
+      case 'string':
+        {
+          return function (details) {
+            return interpolate(fnInput, details);
+          };
+        }
+      case 'function':
+        {
+          return fnInput;
+        }
+      default:
+        {
+          throw new TypeError("Unsupported error message input ".concat(fnInput));
+        }
+    }
+  }
+  //
+  // Parses the validator input. For more details, see:
+  // types/common.ts -> ValidatorSystem
+  //
+  // Ensures the return result is always of the following format:
+  // [ValidatorFn, ValidatorErrorMessageInput]
+  //
+  var _b = Array.isArray(validatorInput) ? validatorInput : [validatorInput, defaultErrorMessage],
+    fnInput = _b[0],
+    errorMessageInput = _b[1];
+  return [_parseValidatorFn(fnInput), _parseValidatorErrorMessageFn(errorMessageInput)];
+}
+
+function validateSyncFn(validatorInput, input) {
+  var result;
+  var _a = parseValidatorInput({
+      objValidator: obj$1
+    }, validatorInput),
+    validatorFn = _a[0],
+    errorMessage = _a[1];
+  try {
+    result = validatorFn(input, {
+      validateSync: validateSyncFn
     });
-  }, Promise.resolve(arg));
-};
+  } catch (err) {
+    result = err;
+  }
+  if (result instanceof Promise) {
+    throw new Error('Promises not supported in sync validation method');
+  }
+  return resolveValidationResult({
+    errorMessage: errorMessage,
+    input: input,
+    result: result
+  });
+}
 
-module.exports = {
-  applyMatching: applyMatching,
-  applyMatchingReduce: applyMatchingReduce,
-  applyMatchingReduceAsync: applyMatchingReduceAsync
-};
+var ValidationError = /** @class */function (_super) {
+  __extends(ValidationError, _super);
+  function ValidationError(_a) {
+    var _this = this;
+    var message = _a.message,
+      details = __rest(_a, ["message"]);
+    _this = _super.call(this, message || "Invalid input ".concat(details.input)) || this;
+    _this.name = 'ValidationError';
+    // Capture correct stack trace in V8 environments (Node.js, Google Chrome)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(_this, ValidationError);
+    }
+    Object.assign(_this, details);
+    return _this;
+  }
+  ValidationError.prototype.toJSON = function () {
+    return {
+      message: this.message,
+      input: this.input,
+      code: this.code,
+      error: this.error,
+      path: this.path,
+      nestedErrors: this.nestedErrors
+    };
+  };
+  return ValidationError;
+}(Error);
 
-var arrayReduceAsync = function arrayReduceAsync(arr, fn, initial) {
-  return arr.reduce(function (previousPromise, item, index) {
-    return previousPromise.then(function (acc) {
-      return Promise.resolve(fn(acc, item, index, arr));
+function assertValidSync(validator, input) {
+  var validationResult = validate(validator, input);
+  if (validationResult === true) {
+    return input;
+  } else {
+    throw new ValidationError(validationResult);
+  }
+}
+var validate = validateSyncFn;
+validate.type = typeValidator;
+validate.obj = obj$1;
+validate.objOf = objOf$1;
+validate.tuple = tuple$1;
+validate.arrayOf = arrayOf$1;
+validate.and = and$1;
+validate.or = or$1;
+validate.not = not$1;
+validate.assertValid = assertValidSync;
+
+function _shapeGeneralValidator(_a) {
+  var input = _a.input,
+    baseType = _a.baseType,
+    validateAsync = _a.validateAsync,
+    collectNestedErrors = _a.collectNestedErrors;
+  return __awaiter(this, void 0, void 0, function () {
+    var objectValidation, nestedErrors;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          return [4 /*yield*/, validateAsync(typeValidator({
+            type: baseType,
+            required: true
+          }), input)];
+        case 1:
+          objectValidation = _b.sent();
+          if (objectValidation !== true) {
+            return [2 /*return*/, objectValidation];
+          }
+          return [4 /*yield*/, collectNestedErrors()];
+        case 2:
+          nestedErrors = _b.sent();
+          return [2 /*return*/, nestedErrors.length === 0 ? true : {
+            input: input,
+            nestedErrors: nestedErrors
+          }];
+      }
     });
-  }, Promise.resolve(initial));
-};
+  });
+}
+function obj(objShape) {
+  return function asyncValidateObj(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var _this = this;
+      return __generator(this, function (_b) {
+        return [2 /*return*/, _shapeGeneralValidator({
+          input: input,
+          baseType: 'object',
+          validateAsync: validateAsync,
+          collectNestedErrors: function collectNestedErrors() {
+            return promiseReduce(Object.entries(objShape), function (acc, _a) {
+              var path = _a[0],
+                pathValidator = _a[1];
+              return __awaiter(_this, void 0, void 0, function () {
+                var pathInput, pathResult;
+                return __generator(this, function (_b) {
+                  switch (_b.label) {
+                    case 0:
+                      pathInput = getProperty(input, path);
+                      return [4 /*yield*/, validateAsync(pathValidator, pathInput)];
+                    case 1:
+                      pathResult = _b.sent();
+                      return [2 /*return*/, pathResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, pathResult), {
+                        path: path
+                      })], false)];
+                  }
+                });
+              });
+            }, []);
+          }
+        })];
+      });
+    });
+  };
+}
+function objOf(ofType) {
+  return function asyncValidateObjOf(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var _this = this;
+      return __generator(this, function (_b) {
+        return [2 /*return*/, _shapeGeneralValidator({
+          input: input,
+          baseType: 'object',
+          validateAsync: validateAsync,
+          collectNestedErrors: function collectNestedErrors() {
+            return promiseReduce(Object.entries(input), function (acc, _a) {
+              var key = _a[0],
+                keyInput = _a[1];
+              return __awaiter(_this, void 0, void 0, function () {
+                var indexResult;
+                return __generator(this, function (_b) {
+                  switch (_b.label) {
+                    case 0:
+                      return [4 /*yield*/, validateAsync(ofType, keyInput)];
+                    case 1:
+                      indexResult = _b.sent();
+                      return [2 /*return*/, indexResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, indexResult), {
+                        path: key
+                      })], false)];
+                  }
+                });
+              });
+            }, []);
+          }
+        })];
+      });
+    });
+  };
+}
+function tuple(tupleShape) {
+  return function asyncValidateTuple(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var _this = this;
+      return __generator(this, function (_b) {
+        return [2 /*return*/, _shapeGeneralValidator({
+          input: input,
+          baseType: 'array',
+          validateAsync: validateAsync,
+          collectNestedErrors: function collectNestedErrors() {
+            return promiseReduce(tupleShape, function (acc, indexValidator, index) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var indexInput, indexResult;
+                return __generator(this, function (_a) {
+                  switch (_a.label) {
+                    case 0:
+                      indexInput = input[index];
+                      return [4 /*yield*/, validateAsync(indexValidator, indexInput)];
+                    case 1:
+                      indexResult = _a.sent();
+                      return [2 /*return*/, indexResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, indexResult), {
+                        path: index + ''
+                      })], false)];
+                  }
+                });
+              });
+            }, []);
+          }
+        })];
+      });
+    });
+  };
+}
+function arrayOf(ofType) {
+  return function asyncValidateArrayOf(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var _this = this;
+      return __generator(this, function (_b) {
+        return [2 /*return*/, _shapeGeneralValidator({
+          input: input,
+          baseType: 'array',
+          validateAsync: validateAsync,
+          collectNestedErrors: function collectNestedErrors() {
+            return promiseReduce(input, function (acc, indexInput, index) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var indexResult;
+                return __generator(this, function (_a) {
+                  switch (_a.label) {
+                    case 0:
+                      return [4 /*yield*/, validateAsync(ofType, indexInput)];
+                    case 1:
+                      indexResult = _a.sent();
+                      return [2 /*return*/, indexResult === true ? acc : __spreadArray(__spreadArray([], acc, true), [_assign(_assign({}, indexResult), {
+                        path: index + ''
+                      })], false)];
+                  }
+                });
+              });
+            }, []);
+          }
+        })];
+      });
+    });
+  };
+}
 
-var array = {
-  arrayReduceAsync: arrayReduceAsync
-};
-var array_1 = array.arrayReduceAsync;
+//
+// And operator (serial)
+//
+function and(validators) {
+  return function validateAnd(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var result;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4 /*yield*/, promiseReduce(validators, function (acc, validator) {
+              return acc !== true ? acc : validateAsync(validator, input);
+            }, true)];
+          case 1:
+            result = _b.sent();
+            if (result === true) {
+              return [2 /*return*/, true];
+            } else {
+              return [2 /*return*/, result];
+            }
+        }
+      });
+    });
+  };
+}
+//
+// Or operator (serial)
+//
+function or(validators) {
+  return function validateOr(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var someIsValid;
+      var _this = this;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4 /*yield*/, promiseReduce(validators, function (acc, validator) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                  switch (_b.label) {
+                    case 0:
+                      _a = acc === true;
+                      if (_a) return [3 /*break*/, 2];
+                      return [4 /*yield*/, validateAsync(validator, input)];
+                    case 1:
+                      _a = _b.sent() === true;
+                      _b.label = 2;
+                    case 2:
+                      return [2 /*return*/, _a];
+                  }
+                });
+              });
+            }, false)];
+          case 1:
+            someIsValid = _b.sent();
+            return [2 /*return*/, someIsValid];
+        }
+      });
+    });
+  };
+}
+//
+// Not
+//
+function not(validator) {
+  return function validateNot(input, _a) {
+    var validateAsync = _a.validateAsync;
+    return __awaiter(this, void 0, void 0, function () {
+      var result;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4 /*yield*/, validateAsync(validator, input)];
+          case 1:
+            result = _b.sent();
+            return [2 /*return*/, result !== true];
+        }
+      });
+    });
+  };
+}
+
+function validateAsyncFn(validatorInput, input) {
+  return __awaiter(this, void 0, void 0, function () {
+    var result, _a, validatorFn, errorMessage, err_1;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          _a = parseValidatorInput({
+            objValidator: obj
+          }, validatorInput), validatorFn = _a[0], errorMessage = _a[1];
+          _b.label = 1;
+        case 1:
+          _b.trys.push([1, 3,, 4]);
+          return [4 /*yield*/, validatorFn(input, {
+            validateAsync: validateAsyncFn
+          })];
+        case 2:
+          result = _b.sent();
+          return [3 /*break*/, 4];
+        case 3:
+          err_1 = _b.sent();
+          result = err_1;
+          return [3 /*break*/, 4];
+        case 4:
+          return [2 /*return*/, resolveValidationResult({
+            errorMessage: errorMessage,
+            input: input,
+            result: result
+          })];
+      }
+    });
+  });
+}
+
+function assertValidAsync(validator, input) {
+  return __awaiter(this, void 0, void 0, function () {
+    var validationResult;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          return [4 /*yield*/, validateAsync(validator, input)];
+        case 1:
+          validationResult = _a.sent();
+          if (validationResult === true) {
+            return [2 /*return*/, input];
+          } else {
+            throw new ValidationError(validationResult);
+          }
+      }
+    });
+  });
+}
+var validateAsync = validateAsyncFn;
+validateAsync.type = typeValidator;
+validateAsync.obj = obj;
+validateAsync.objOf = objOf;
+validateAsync.tuple = tuple;
+validateAsync.arrayOf = arrayOf;
+validateAsync.and = and;
+validateAsync.or = or;
+validateAsync.not = not;
+validateAsync.assertValid = assertValidAsync;
 
-export { array as __moduleExports, array_1 as arrayReduceAsync };
+export { PromiseLikeEventEmitter, SKIPPED, ValidationError, batchFn, debugFn, deepFreeze, interpolate, makeTypeOf, maybeFn, parseBatchedResults, promiseReduce, resolveNestedPromises, resolvePaths, switchExec, switchValue, typeMap, typeOf, validate, validateAsync, wait };