@orioro/util 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { getProperty } from 'dot-prop';
-import traverse from 'traverse';
-import copy from 'fast-copy';
 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";
@@ -13,340 +13,84 @@ function _typeof(o) {
   }, _typeof(o);
 }
 
-/*!
- * 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;
-
-  // 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;
+/******************************************************************************
+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 */
 
-  // If constructor does not have an Object-specific method
-  if (prot.hasOwnProperty('isPrototypeOf') === false) {
-    return false;
+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;
   }
-
-  // Most likely a plain Object
-  return true;
-}
-
-//
-// The only role of this function is to let typescript
-// be aware of the available types
-//
-function typeMap(typeMap) {
-  return typeMap;
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
-function makeTypeOf(typeMap) {
-  return function typeOf(value) {
-    for (var typeName in typeMap) {
-      if (typeMap[typeName](value)) {
-        return typeName;
-      }
+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 null;
-  };
-}
-function basicType(typeName) {
-  return function (value) {
-    return _typeof(value) === typeName;
+    return t;
   };
-}
-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);
-
-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;
-      }
+  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 switchValue(input, cases) {
-  if (Array.isArray(cases)) {
-    var matching = cases.find(function (case_) {
-      return case_.length === 1 || testCriteria(case_[0], input);
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
     });
-    return matching ? matching.length === 1 ? matching[0] : matching[1] : undefined;
-  } else {
-    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);
-}
-
-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];
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
       }
-    default:
-      {
-        throw new Error("Invalid expectedType ".concat(expectedTypesInput));
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
       }
-  }
-}
-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;
-  };
-}
-
-/******************************************************************************
-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 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 _ = {
@@ -450,171 +194,121 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-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 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;
   }
-  var nestedErrors = collectNestedErrors();
-  return nestedErrors.length === 0 ? true : {
-    input: input,
-    nestedErrors: nestedErrors
+  PromiseLikeEventEmitter.prototype.then = function (onFulfilled, onRejected) {
+    return this.promise.then(onFulfilled, onRejected);
   };
-}
-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);
-        }, []);
-      }
-    });
+  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 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 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);
       }
     });
-  };
-}
-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);
-        }, []);
+  } 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);
       }
     });
-  };
-}
-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);
-        }, []);
-      }
-    });
-  };
+  }
+  return object;
 }
 
-function defaultErrorMessage(_a) {
-  var input = _a.input,
-    message = _a.message,
-    nestedErrors = _a.nestedErrors,
-    expectedTypes = _a.expectedTypes;
-  if (message) {
-    return message;
+function stringifyReplacer(key, value) {
+  if (typeof value === 'function') {
+    // Convert functions to a consistent string representation
+    return "function:".concat(value.toString());
   }
-  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 {
-    return "Invalid input: '".concat(input, "'.");
+  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 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), ")"));
-      }
-    }));
-  }
+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;
+  };
 }
 
 /**
@@ -677,154 +371,33 @@ function interpolate(template, data, _a) {
   });
 }
 
-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));
-        }
-    }
+function maybeFn(input) {
+  var args = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    args[_i - 1] = arguments[_i];
   }
-  //
-  // 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)];
+  return typeof input === 'function' ? input.apply(void 0, args) : input;
 }
 
-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
+function promiseReduce(inputArr, reducerFn, initial) {
+  return inputArr.reduce(function (prevPromise, input, index) {
+    return prevPromise.then(function (acc) {
+      return reducerFn(acc, input, index);
     });
-  } 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
-  });
+  }, Promise.resolve(initial));
 }
 
-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);
-
-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 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 DEFAULT_OPTIONS = {
-  mode: 'eager',
-  maxDepth: 30,
-  clone: copy
-};
-function _echo(input) {
-  return input;
-}
-function resolveNestedPromises(node, options, ctx) {
-  if (options === void 0) {
-    options = {};
+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 = {
@@ -893,28 +466,6 @@ function arrayChunk(array, chunkSize) {
   return chunks;
 }
 
-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);
-
 var SKIPPED = Symbol();
 function batchFn(fn, _a) {
   var _b = _a === void 0 ? {} : _a,
@@ -1021,28 +572,590 @@ function batchFn(fn, _a) {
     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)
-      });
+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);
+  }, {});
+}
+
+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 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;
+
+  // 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;
+  }
+
+  // Most likely a plain Object
+  return true;
+}
+
+//
+// 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 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);
+        }, []);
+      }
+    });
+  };
+}
+
+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 {
+    return "Invalid input: '".concat(input, "'.");
+  }
+}
+
+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), ")"));
+      }
+    }));
+  }
+}
+
+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));
+        }
     }
-  }, {
-    results: [],
-    errors: [],
-    skipped: []
+  }
+  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
+    });
+  } 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
   });
 }
 
+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);
+
+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,
@@ -1359,107 +1472,4 @@ validateAsync.or = or;
 validateAsync.not = not;
 validateAsync.assertValid = assertValidAsync;
 
-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 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 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 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;
-  };
-}
-
-export { PromiseLikeEventEmitter, SKIPPED, ValidationError, batchFn, debugFn, deepFreeze, interpolate, makeTypeOf, maybeFn, parseBatchedResults, promiseReduce, resolveNestedPromises, switchExec, switchValue, typeMap, typeOf, validate, validateAsync, wait };
+export { PromiseLikeEventEmitter, SKIPPED, ValidationError, batchFn, debugFn, deepFreeze, interpolate, makeTypeOf, maybeFn, parseBatchedResults, promiseReduce, resolveNestedPromises, resolvePaths, switchExec, switchValue, typeMap, typeOf, validate, validateAsync, wait };