@orioro/util 0.10.0 → 0.11.1

package/dist/index.mjs

@@ -1,8 +1,19 @@
+import { keyBy, set, get } from 'lodash-es';
 import EventEmitter from 'eventemitter3';
 import copy from 'fast-copy';
-import { getProperty, setProperty } from 'dot-prop';
 import traverse from 'traverse';
 import { backOff } from 'exponential-backoff';
+import { isPlainObject } from 'is-plain-object';
+import memoizeOne from 'memoize-one';
+import queryString from 'query-string';
+
+function arrayChunk(array, chunkSize) {
+  var chunks = [];
+  for (var i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
 
 function _typeof(o) {
   "@babel/helpers - typeof";
@@ -28,7 +39,7 @@ 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 */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 var _extendStatics = function extendStatics(d, b) {
   _extendStatics = Object.setPrototypeOf || {
@@ -58,14 +69,6 @@ var _assign = function __assign() {
   };
   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) {
@@ -106,12 +109,8 @@ function __generator(thisArg, body) {
     f,
     y,
     t,
-    g;
-  return g = {
-    next: verb(0),
-    "throw": verb(1),
-    "return": verb(2)
-  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
     return this;
   }), g;
   function verb(n) {
@@ -195,6 +194,104 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function _isTupleDatasetInput(input) {
+  return Array.isArray(input) && typeof input[0] === 'string' && Array.isArray(input[1]);
+}
+function _parseDatasetInput(defaultOnKey, datasetInput) {
+  var _a;
+  if (_isTupleDatasetInput(datasetInput)) {
+    var keyInput = datasetInput[0];
+    var key = keyInput;
+    var srcKey = null;
+    if (typeof keyInput === 'string') {
+      var keySplit = keyInput.split(':');
+      if (keySplit.length === 1) {
+        srcKey = null;
+        key = keyInput;
+      } else {
+        srcKey = keySplit[0];
+        key = keySplit[1];
+      }
+    }
+    return {
+      srcKey: srcKey,
+      key: key,
+      entries: datasetInput[1],
+      path: (_a = datasetInput[2]) !== null && _a !== void 0 ? _a : null
+    };
+  }
+  return {
+    srcKey: null,
+    key: defaultOnKey,
+    entries: datasetInput,
+    path: null
+  };
+}
+function dataJoin(datasets, _a) {
+  var _b = _a === void 0 ? {} : _a,
+    _c = _b.key,
+    defaultOnKey = _c === void 0 ? 'id' : _c,
+    _d = _b.mode,
+    mode = _d === void 0 ? 'left' : _d;
+  var base = datasets[0],
+    others = datasets.slice(1);
+  //
+  // Base dataset requires no byKey dict
+  //
+  var baseDataset = _parseDatasetInput(defaultOnKey, base);
+  //
+  // Other datasets require byKey dict
+  //
+  var otherSets = others.map(function (setInput) {
+    var parsed = _parseDatasetInput(defaultOnKey, setInput);
+    return _assign(_assign({}, parsed), {
+      byKey: keyBy(parsed.entries, parsed.key)
+    });
+  });
+  //
+  // Prepare a set of functions that
+  // retrieve a given entry's key relative
+  // to another dataset
+  //
+  function _entryKey(entry, otherSet) {
+    var _a;
+    return ((_a = otherSet.srcKey ? get(entry, otherSet.srcKey) : get(entry, baseDataset.key)) !== null && _a !== void 0 ? _a : '').toString();
+  }
+  //
+  // If mode === inner, filter out missing data
+  //
+  var baseEntries = mode === 'inner' ? baseDataset.entries.filter(function (entry) {
+    return otherSets.every(function (set) {
+      return set.byKey[_entryKey(entry, set)];
+    });
+  }) : baseDataset.entries;
+  //
+  // Loop over baseDataset.entries joining it with other data
+  //
+  return baseEntries.map(function (entry) {
+    var _a;
+    //
+    // Setup a base entry over which data will be set
+    //
+    var baseEntry = baseDataset.path ? (_a = {}, _a[baseDataset.path] = entry, _a) : Object.assign({}, entry);
+    //
+    // Loop over all other sets to pick up data
+    //
+    return otherSets.reduce(function (acc, otherSet) {
+      var entryKey = _entryKey(entry, otherSet);
+      var otherEntry = otherSet.byKey[entryKey];
+      if (otherEntry) {
+        if (otherSet.path) {
+          set(acc, otherSet.path, otherEntry);
+        } else {
+          Object.assign(acc, otherEntry);
+        }
+      }
+      return acc;
+    }, baseEntry);
+  });
+}
+
 var PromiseLikeEventEmitter = /** @class */function (_super) {
   __extends(PromiseLikeEventEmitter, _super);
   function PromiseLikeEventEmitter() {
@@ -282,13 +379,22 @@ function generateDeterministicId(args) {
   return simpleHash(argsString);
 }
 
-function debugFn(fnName, fn, logCall, logResult) {
+function sequentialCallIdGenerator() {
+  var count = 0;
+  return function () {
+    return count += 1;
+  };
+}
+function debugFn(fnName, fn, logCall, logResult, generateCallId) {
+  if (generateCallId === void 0) {
+    generateCallId = generateDeterministicId;
+  }
   return function () {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
       args[_i] = arguments[_i];
     }
-    var callId = generateDeterministicId(__spreadArray([fnName, fn], args, true));
+    var callId = generateCallId(__spreadArray([fnName, fn], args, true));
     if (typeof logCall === 'function') {
       // Deep clone args, so that we may detect mutations later on
       logCall({
@@ -335,7 +441,12 @@ function debugFn(fnName, fn, logCall, logResult) {
  *
  * @const {RegExp} INTERPOLATION_REGEXP
  */
-var INTERPOLATION_REGEXP = /\$\{\s*([\w$.]+)\s*\}/g;
+var INTERPOLATION_REGEXP = /\$\{\s*([\w$.=\s]+)\s*\}/g;
+var DEFAULT_SIGN = '=';
+function _parsePathExpr(pathExpr) {
+  var splitRes = pathExpr.split(DEFAULT_SIGN);
+  return splitRes.length > 1 ? [splitRes[0].trim(), splitRes.slice(1).join(DEFAULT_SIGN).trim()] : [splitRes[0].trim()];
+}
 /**
  * @function $stringInterpolate
  * @param {String} template Basic JS template string like `${value.path}` value
@@ -352,8 +463,12 @@ function interpolate(template, data, _a) {
   if (template.length > maxLength) {
     throw new Error("Template exceeds maxLength ".concat(maxLength));
   }
-  return template.replace(INTERPOLATION_REGEXP, function (_, path) {
-    var value = getProperty(data, path);
+  data = _typeof(data) === 'object' ? data : [data];
+  return template.replace(INTERPOLATION_REGEXP, function (_, pathExpr) {
+    var _a = _parsePathExpr(pathExpr),
+      path = _a[0],
+      defaultValue = _a[1];
+    var value = get(data, path);
     switch (_typeof(value)) {
       case 'number':
         {
@@ -365,8 +480,12 @@ function interpolate(template, data, _a) {
         }
       default:
         {
-          console.warn("Attempting to use non interpolatable value in interpolate ".concat(value));
-          return '';
+          if (typeof value === 'undefined' || value === null) {
+            return typeof defaultValue === 'string' ? defaultValue : '';
+          } else {
+            console.warn("Attempting to use non interpolatable value in interpolate ".concat(value));
+            return '';
+          }
         }
     }
   });
@@ -386,13 +505,13 @@ function pickPaths(sourceObj, paths) {
       targetPath = _a[0],
       resolver = _a[1],
       defaultValue = _a[2];
-    var value = typeof resolver === 'string' ? getProperty(sourceObj, resolver) : resolver(sourceObj);
+    var value = typeof resolver === 'string' ? get(sourceObj, resolver) : resolver(sourceObj);
     var valueAfterDefault = typeof value === 'undefined' ? defaultValue : value;
     //
     // Undefined values are skipped in order to avoid nested
     // setting undefined values
     //
-    return typeof valueAfterDefault !== 'undefined' ? setProperty(acc, targetPath, valueAfterDefault) : acc;
+    return typeof valueAfterDefault !== 'undefined' ? set(acc, targetPath, valueAfterDefault) : acc;
   }, {});
 }
 
@@ -475,14 +594,6 @@ function resolveNestedPromises(node, options, ctx) {
   });
 }
 
-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 TimeoutError = /** @class */function (_super) {
   __extends(TimeoutError, _super);
   function TimeoutError(message) {
@@ -693,6 +804,267 @@ function makeDeferred() {
   };
 }
 
+function isPromise(value) {
+  return value !== null && _typeof(value) === 'object' && typeof value.then === 'function';
+}
+
+//
+// Checks whether the input itself is a promise
+// or has any nested promises
+// 
+// TODO: implement maxDepth
+//
+function hasNestedPromises(input) {
+  if (isPromise(input)) {
+    return true;
+  } else if (Array.isArray(input) || isPlainObject(input)) {
+    return traverse(input).reduce(function (acc, value) {
+      return acc === true ? true : isPromise(value);
+      // if (acc === true) {
+      //   //
+      //   // Stop is not well documented
+      //   //
+      //   this.stop()
+      //   return true
+      // } else {
+      //   return isPromise(value)
+      // }
+    }, false);
+  } else {
+    return false;
+  }
+}
+function _makeDefaultAsyncExpFn(syncFn) {
+  return function defaultAsyncExpFn() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      var resolvedArgs;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, Promise.all(args.map(function (arg) {
+              return resolveNestedPromises(arg);
+            }))];
+          case 1:
+            resolvedArgs = _a.sent();
+            return [2 /*return*/, syncFn.apply(void 0, resolvedArgs)];
+        }
+      });
+    });
+  };
+}
+function _defaultArgsContainPromises(args) {
+  return args.some(function (arg) {
+    return hasNestedPromises(arg);
+  });
+}
+/**
+ * Takes in a function and optionally takes in
+ * an async version of that same function.
+ * If no async version is defined, a default async
+ * version is prepared.
+ *
+ * Returns a new function that, before executing the wrapped
+ * functions verifies if there are any promises
+ * in the inputs and executes sync or async versions
+ * accordingly
+ */
+function maybeAsyncFn(_a) {
+  var syncFn = _a.syncFn,
+    _b = _a.asyncFn,
+    asyncFn = _b === void 0 ? _makeDefaultAsyncExpFn(syncFn) : _b,
+    //
+    // By default, argsContainPromises checks
+    // if the any of the arguments provided are
+    // themselves a promise or if they have a nested promise
+    //
+    // Allow the argsContainPromises to be configurable.
+    // This allows for more specialized checks that
+    // would perform better, some examples:
+    // - If the first argument includes a promise
+    // - If some deeply nested argument is set
+    //   to a value that will incur in the need
+    //   for async resolution, even if the input arg
+    //   itself is not a promise
+    //
+    _c = _a.argsContainPromises,
+    //
+    // By default, argsContainPromises checks
+    // if the any of the arguments provided are
+    // themselves a promise or if they have a nested promise
+    //
+    // Allow the argsContainPromises to be configurable.
+    // This allows for more specialized checks that
+    // would perform better, some examples:
+    // - If the first argument includes a promise
+    // - If some deeply nested argument is set
+    //   to a value that will incur in the need
+    //   for async resolution, even if the input arg
+    //   itself is not a promise
+    //
+    argsContainPromises = _c === void 0 ? _defaultArgsContainPromises : _c;
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return argsContainPromises(args) ? asyncFn.apply(void 0, args) : syncFn.apply(void 0, args);
+  };
+}
+
+function untilConditionIsSatisfiedReducer(condition, reduce) {
+  return function reducer(acc, value, index, allValues) {
+    if (isPromise(acc) || condition(acc)) {
+      //
+      // Has already resolved, as any false value
+      // should render the whole $and expression to false
+      //
+      //
+      // The previous condition returned a promise,
+      // thus assume it will properly handle resolution
+      //
+      return acc;
+    } else {
+      //
+      // Resolve currentValue
+      //
+      var syncResult = reduce(acc, value, index, allValues);
+      if (isPromise(syncResult)) {
+        var remainingValues_1 = allValues.slice(index + 1);
+        return syncResult.then(function (asyncResult) {
+          return condition(asyncResult) ? asyncResult : remainingValues_1.reduce(reducer, asyncResult);
+        });
+      } else {
+        return syncResult;
+      }
+    }
+  };
+}
+
+function maybeReturnPromise(result, parseResult) {
+  return isPromise(result) ? result.then(parseResult) : parseResult(result);
+}
+
+function syntheticJson(str) {
+  // Step 1: Replace single quotes with double quotes
+  var normalized = str.replace(/'/g, '"');
+  // Step 2: Add quotes around unquoted keys (letters, digits, underscores)
+  normalized = normalized.replace(/([a-zA-Z0-9_]+)\s*:/g, '"$1":');
+  // Step 3: Parse as JSON
+  try {
+    return JSON.parse(normalized);
+  } catch (error) {
+    throw new Error("Invalid synthetic JSON: ".concat(str));
+  }
+}
+
+function _jsonLikeParseArgs(argsStr) {
+  try {
+    argsStr = "[".concat(argsStr, "]");
+    return syntheticJson(argsStr);
+    // // Replace single quotes with double quotes
+    // argsStr = argsStr.replace(/'/g, '"')
+    // // Add double quotes around unquoted keys
+    // argsStr = argsStr.replace(/(\w+)\s*:/g, '"$1":')
+    // return JSON.parse(argsStr)
+  } catch (err) {
+    throw new Error("Failed to parse arguments: ".concat(err.message));
+  }
+}
+// Utility to escape regex special characters
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function strExpr(_a) {
+  var expressions = _a.expressions,
+    _b = _a.pipe,
+    pipe = _b === void 0 ? '|' : _b,
+    _c = _a.parseArgs,
+    parseArgs = _c === void 0 ? _jsonLikeParseArgs : _c;
+  var _d = Array.isArray(expressions) ? [expressions, null] : [Object.keys(expressions), expressions],
+    expressionIds = _d[0],
+    expressionFns = _d[1];
+  if (expressionIds.length === 0) {
+    throw new Error('No expressions provided');
+  }
+  //
+  // Used to split piping expressions
+  //
+  var PIPE_RE = new RegExp('\\s*' + escapeRegExp(pipe) + '\\s*', 'g');
+  //
+  // Matches and captures the name of the expression
+  //
+  var EXP_NAME_PART = "(".concat(expressionIds.map(escapeRegExp).join('|'), ")");
+  //
+  // Optionally matches and captures arguments ("value1", "value2")
+  //
+  var PARAMS_PART = "(?:\\(([^)]*)\\))?";
+  var EXPRESSIONS_RE = new RegExp("^".concat(EXP_NAME_PART).concat(PARAMS_PART, "$"));
+  //
+  // Takes a string in the format:
+  // 'expr1("param", "param2") | expr2() | expr3()'
+  //
+  // and returns an array denoting expression name and arguments
+  //
+  var parse = memoizeOne(function parse(expr) {
+    var parts = expr.split(PIPE_RE).map(function (expr) {
+      return expr.trim();
+    });
+    return parts.map(function (part) {
+      var exprMatch = part.match(EXPRESSIONS_RE);
+      if (!exprMatch) {
+        throw new Error("Invalid expression part '".concat(part, "'"));
+      }
+      var exprName = exprMatch[1];
+      var exprArgsStr = exprMatch[2] ? exprMatch[2].trim() : '';
+      return [exprName, exprArgsStr ? parseArgs(exprArgsStr) : []];
+    });
+  });
+  //
+  // Applies the expression against a provided input
+  //
+  var apply = expressionFns ? function apply(exprParts, input) {
+    exprParts = typeof exprParts === 'string' ? parse(exprParts) : exprParts;
+    return exprParts.reduce(function (acc, part) {
+      var exprName = part[0];
+      var exprArgs = part[1];
+      var exprFn = expressionFns[exprName];
+      if (!exprFn) {
+        throw new Error("Expression '".concat(exprName, "' not found"));
+      }
+      //
+      // It seems fn.apply is significantly faster than spread operator
+      // Some references:
+      // - https://jonlinnell.co.uk/articles/spread-operator-performance
+      //
+      var _withExprArgs = exprFn.apply(null, exprArgs);
+      // const _withExprArgs = exprFn(...exprArgs)
+      return maybeReturnPromise(acc, function (accRes) {
+        return _withExprArgs(accRes);
+      });
+    }, input);
+  } : function () {
+    throw new Error('Cannot apply expression: No expression functions provided');
+  };
+  //
+  // Compiles an expression into an executable function
+  //
+  function compile(expr) {
+    var parsed = parse(expr);
+    return function (input) {
+      return apply(parsed, input);
+    };
+  }
+  return {
+    parse: parse,
+    apply: apply,
+    compile: compile
+  };
+}
+
 function testCriteria(criteria, input) {
   switch (_typeof(criteria)) {
     case 'function':
@@ -733,37 +1105,6 @@ function switchExec(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
@@ -838,729 +1179,6 @@ var DEFAULT_TYPES = typeMap({
 });
 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));
-        }
-    }
-  }
-  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,
-    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
-          }];
-      }
-    });
-  });
-}
-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)];
-                  }
-                });
-              });
-            }, []);
-          }
-        })];
-      });
-    });
-  };
-}
-
-//
-// 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;
-
 function defaultParseResponse(response) {
   return response.json();
 }
@@ -1617,7 +1235,7 @@ function fetchAllPages(_a) {
         case 1:
           return [4 /*yield*/, store.getSize()];
         case 2:
-          currentOffset = _d.sent() + 1;
+          currentOffset = _d.sent();
           return [4 /*yield*/, fetchPage({
             offset: currentOffset,
             pageSize: pageSize
@@ -1644,13 +1262,68 @@ function fetchAllPages(_a) {
   });
 }
 
-function normalizeString(str) {
-  return str.normalize('NFD') // Decompose accented characters
-  .replace(/[\u0300-\u036f]/g, '') // Remove diacritical marks
+function deprecateFn(fn, message) {
+  // Creating a new function that wraps the original function
+  var wrappedFunction = function wrappedFunction() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      console.warn(["[deprecated][fn] ".concat(fn.name, " is deprecated"), message].filter(Boolean).join(': '));
+    }
+    return fn.apply(void 0, args);
+  };
+  // Copying the original function's properties to the new function
+  Object.assign(wrappedFunction, fn);
+  // Setting the name property explicitly to preserve the original function's name
+  Object.defineProperty(wrappedFunction, 'name', {
+    value: "".concat(fn.name, "_DEPRECATED"),
+    configurable: true
+  });
+  return wrappedFunction;
+}
+function deprecateProperty(obj, key, value, message) {
+  // Create a new object that includes all properties of the original object
+  var newObj = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+  Object.defineProperty(newObj, key, {
+    get: function get() {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn(["[deprecated][property] ".concat(key, " is deprecated"), message].filter(Boolean).join(': '));
+      }
+      return value;
+    }
+  });
+  return newObj;
+}
+function deprecateInput(inputValue, message, convert) {
+  if (typeof inputValue === 'undefined') {
+    return undefined;
+  } else {
+    if (process.env.NODE_ENV !== 'production') {
+      console.warn("[deprecated][input] ".concat(message, " | received: ").concat(inputValue));
+    }
+    return typeof convert === 'function' ? convert(inputValue) : inputValue;
+  }
+}
+
+function slugify(str, delimiter) {
+  if (delimiter === void 0) {
+    delimiter = '-';
+  }
+  // Escape the delimiter for safe use in regex
+  var safeDelimiter = delimiter.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+  var CONSECUTIVE_DELIMITER_RE = new RegExp("".concat(safeDelimiter, "+"), 'g');
+  var LEADING_TRAILING_DELIMITER_RE = new RegExp("^".concat(safeDelimiter, "+|").concat(safeDelimiter, "+$"), 'g');
+  return str.trim() // Trim leading and trailing spaces
   .toLowerCase() // Convert to lowercase
-  .replace(/\s+/g, '-') // Replace multiple spaces with a single space
-  .trim(); // Trim leading and trailing spaces
+  .normalize('NFD') // Decompose accented characters
+  .replace(/[\u0300-\u036f]/g, '') // Remove diacritics
+  .replace(/[^a-z0-9]+/g, delimiter) // Replace non-alphanumeric with hyphens
+  .replace(CONSECUTIVE_DELIMITER_RE, delimiter) // Collapse consecutive hyphens
+  .replace(LEADING_TRAILING_DELIMITER_RE, ''); // Remove leading/trailing hyphens
 }
+var normalizeString = deprecateFn(slugify, 'normalizeString is depreacted, use @orioro/util -> slugify instead');
 
 //
 // Hook module
@@ -1726,4 +1399,73 @@ function hookFn(fn, _a) {
   };
 }
 
-export { PromiseLikeEventEmitter, SKIPPED, TimeoutError, ValidationError, batchFn, debugFn, deepFreeze, fetchAllPages, hookFn, inMemoryDataStore, interpolate, makeDeferred, makeTypeOf, maybeFn, normalizeString, paginatedHttpFetch, parseBatchedResults, pickPaths, promiseReduce, resolveNestedPromises, switchExec, switchValue, typeMap, typeOf, validate, validateAsync, wait, withTimeout };
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (_a) {
+    return false;
+  }
+}
+
+//
+// https://nodejs.org/api/url.html#url-strings-and-url-objects
+//
+// ┌────────────────────────────────────────────────────────────────────────────────────────────────┐
+// │                                              href                                              │
+// ├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤
+// │ protocol │  │        auth         │          host          │           path            │ hash  │
+// │          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │
+// │          │  │                     │    hostname     │ port │ pathname │     search     │       │
+// │          │  │                     │                 │      │          ├─┬──────────────┤       │
+// │          │  │                     │                 │      │          │ │    query     │       │
+// "  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash "
+// │          │  │          │          │    hostname     │ port │          │                │       │
+// │          │  │          │          ├─────────────────┴──────┤          │                │       │
+// │ protocol │  │ username │ password │          host          │          │                │       │
+// ├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │
+// │   origin    │                     │         origin         │ pathname │     search     │ hash  │
+// ├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤
+// │                                              href                                              │
+// └────────────────────────────────────────────────────────────────────────────────────────────────┘
+//
+var DEFAULT_PROTOCOL = 'https:';
+function _protocol(protocol) {
+  return !protocol ? DEFAULT_PROTOCOL : protocol.endsWith(':') ? protocol : "".concat(protocol, ":");
+}
+function _baseHref(spec) {
+  if (spec.href) {
+    return spec.href;
+  } else {
+    var protocol = _protocol(spec.protocol);
+    var host = spec.host || spec.hostname;
+    if (!host) {
+      throw new Error("Invalid URL spec: either 'href', 'host' or 'hostname' must be defined.");
+    }
+    return "".concat(protocol, "//").concat(host);
+  }
+}
+function url(spec) {
+  if (typeof spec === 'string') {
+    return new URL(spec).href;
+  } else {
+    var url_1 = new URL(_baseHref(spec));
+    if (spec.protocol) url_1.protocol = spec.protocol;
+    if (spec.username) url_1.username = spec.username;
+    if (spec.password) url_1.password = spec.password;
+    if (spec.host) url_1.host = spec.host;
+    if (spec.hostname) url_1.hostname = spec.hostname;
+    if (spec.port) url_1.port = spec.port;
+    if (spec.pathname) url_1.pathname = spec.pathname;
+    if (spec.search) url_1.search = spec.search;
+    // Handle searchParams
+    if (spec.searchParams) {
+      var searchString = Array.isArray(spec.searchParams) ? queryString.stringify(spec.searchParams[0], spec.searchParams[1]) : queryString.stringify(spec.searchParams);
+      url_1.search = searchString;
+    }
+    if (spec.hash) url_1.hash = spec.hash;
+    return url_1.href;
+  }
+}
+
+export { DEFAULT_TYPES, PromiseLikeEventEmitter, SKIPPED, TimeoutError, arrayChunk, batchFn, dataJoin, debugFn, deepFreeze, deprecateFn, deprecateInput, deprecateProperty, fetchAllPages, hasNestedPromises, hookFn, inMemoryDataStore, interpolate, isPromise, isValidUrl, makeDeferred, makeTypeOf, maybeAsyncFn, maybeFn, maybeReturnPromise, normalizeString, paginatedHttpFetch, parseBatchedResults, pickPaths, promiseReduce, resolveNestedPromises, sequentialCallIdGenerator, slugify, strExpr, switchExec, switchValue, syntheticJson, typeMap, typeOf, untilConditionIsSatisfiedReducer, url, wait, withTimeout };