@orioro/util 0.10.0 → 0.11.2

package/dist/index.js

@@ -0,0 +1,1514 @@
+'use strict';
+
+var lodashEs = require('lodash-es');
+var EventEmitter = require('eventemitter3');
+var copy = require('fast-copy');
+var traverse = require('traverse');
+var exponentialBackoff = require('exponential-backoff');
+var isPlainObject = require('is-plain-object');
+var memoizeOne = require('memoize-one');
+var queryString = require('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";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var _extendStatics = function extendStatics(d, b) {
+  _extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+  };
+  return _extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  _extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  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 __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+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: lodashEs.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 ? lodashEs.get(entry, otherSet.srcKey) : lodashEs.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) {
+          lodashEs.set(acc, otherSet.path, otherEntry);
+        } else {
+          Object.assign(acc, otherEntry);
+        }
+      }
+      return acc;
+    }, baseEntry);
+  });
+}
+
+var PromiseLikeEventEmitter = /** @class */function (_super) {
+  __extends(PromiseLikeEventEmitter, _super);
+  function PromiseLikeEventEmitter() {
+    var _this = _super.call(this) || this;
+    _this.promise = new Promise(function (resolve, reject) {
+      _this.resolve = resolve;
+      _this.reject = reject;
+    });
+    return _this;
+  }
+  PromiseLikeEventEmitter.prototype.then = function (onFulfilled, onRejected) {
+    return this.promise.then(onFulfilled, onRejected);
+  };
+  PromiseLikeEventEmitter.prototype["catch"] = function (onRejected) {
+    return this.promise["catch"](onRejected);
+  };
+  PromiseLikeEventEmitter.prototype["finally"] = function (onFinally) {
+    return this.promise["finally"](onFinally);
+  };
+  return PromiseLikeEventEmitter;
+}(EventEmitter);
+
+function wait(ms, result) {
+  if (ms === void 0) {
+    ms = 1000;
+  }
+  return __awaiter(this, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+      return [2 /*return*/, new Promise(function (resolve, reject) {
+        setTimeout(function () {
+          if (result instanceof Error) {
+            reject(result);
+          } else {
+            resolve(result);
+          }
+        }, ms);
+      })];
+    });
+  });
+}
+
+function 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 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 = generateCallId(__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;
+  };
+}
+
+/**
+ * /\$\{\s*([\w$.]+)\s*\}/g
+ * ![](docs/resources/interpolation_regexp.png)
+ *
+ * RegExp used for matching interpolation expressions.
+ * Allows a non-interrupted sequence of alphanumeric chars ([A-Za-z0-9_]),
+ * dollar signs ($) and dots (.) wrapped in curly braces ({})
+ * with or without any number of whitespace chars (' ') between braces and the
+ * value identifier.
+ *
+ * Some resources on RegExp safety concerning RegExp Denial of Service (ReDOS)
+ * through Catastrophic backtracking, for future study and reference:
+ *
+ * - [Catastrophic backtracking](https://www.regular-expressions.info/catastrophic.html)
+ * - [Regular expression visualizer](https://github.com/CJex/regulex)
+ * - [Validator.js](https://github.com/validatorjs/validator.js)
+ * - [Stack Overflow interesting question](https://stackoverflow.com/questions/63127145/safe-regex-patterns-from-redos-attack)
+ * - [Catastrophic backtracking - JavaScript Info](https://javascript.info/regexp-catastrophic-backtracking#preventing-backtracking)
+ * - [Google re2 library](https://github.com/google/re2)
+ * - [Google re2 for Node.js - re2](https://github.com/uhop/node-re2/)
+ *
+ * @const {RegExp} INTERPOLATION_REGEXP
+ */
+var INTERPOLATION_REGEXP = /\$\{\s*([\w$.=\s]+)\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
+ *                          interpolation. It is possible to access nested properties
+ *                          through dot `.` notation. Keywords between braces are
+ *                          only interpreted as paths to the value. No logic
+ *                          supported: loops, conditionals, etc.
+ * @param {Object | Array} data Data context to be used for interpolation
+ */
+function interpolate(template, data, _a) {
+  var _b = _a === void 0 ? {} : _a,
+    _c = _b.maxLength,
+    maxLength = _c === void 0 ? 10000 : _c;
+  if (template.length > maxLength) {
+    throw new Error("Template exceeds maxLength ".concat(maxLength));
+  }
+  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 = lodashEs.get(data, path);
+    switch (_typeof(value)) {
+      case 'number':
+        {
+          return value + '';
+        }
+      case 'string':
+        {
+          return value;
+        }
+      default:
+        {
+          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 '';
+          }
+        }
+    }
+  });
+}
+
+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 pickPaths(sourceObj, paths) {
+  return paths.reduce(function (acc, path) {
+    var _a = Array.isArray(path) ? path : [path, path],
+      targetPath = _a[0],
+      resolver = _a[1],
+      defaultValue = _a[2];
+    var value = typeof resolver === 'string' ? lodashEs.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' ? lodashEs.set(acc, targetPath, valueAfterDefault) : acc;
+  }, {});
+}
+
+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 = {};
+  }
+  if (ctx === void 0) {
+    ctx = {
+      root: node,
+      depth: 0
+    };
+  }
+  return __awaiter(this, void 0, void 0, function () {
+    var opts, promises, _cloneFn, clonedNode, resolved;
+    return __generator(this, function (_a) {
+      opts = _assign(_assign({}, DEFAULT_OPTIONS), options);
+      promises = [];
+      _cloneFn = opts.clone || _echo;
+      clonedNode = _cloneFn(node);
+      resolved = traverse(clonedNode).forEach(function (value) {
+        var _this = this;
+        var depth = ctx.depth + this.path.length;
+        if (depth > opts.maxDepth) {
+          throw new Error("Max depth exceeded: { depth: ".concat(depth, ", maxDepth: ").concat(opts.maxDepth, " }"));
+        }
+        if (value instanceof Promise) {
+          var updatePromise = value.then(function (resolvedValue) {
+            return __awaiter(_this, void 0, void 0, function () {
+              var _a, _b;
+              return __generator(this, function (_c) {
+                switch (_c.label) {
+                  case 0:
+                    // Arrow function;
+                    // this refers to outside this ctx
+                    _a = this.update;
+                    if (!(opts.mode === 'eager')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, resolveNestedPromises(resolvedValue, opts, _assign(_assign({}, ctx), {
+                      // pass the base depth of the current value
+                      depth: depth
+                    }))];
+                  case 1:
+                    _b = _c.sent();
+                    return [3 /*break*/, 3];
+                  case 2:
+                    _b = resolvedValue;
+                    _c.label = 3;
+                  case 3:
+                    // Arrow function;
+                    // this refers to outside this ctx
+                    _a.apply(this, [_b]);
+                    return [2 /*return*/];
+                }
+              });
+            });
+          });
+          promises = __spreadArray(__spreadArray([], promises, true), [updatePromise], false);
+        }
+      });
+      return [2 /*return*/, Promise.all(promises).then(function () {
+        return resolved;
+      })];
+    });
+  });
+}
+
+var TimeoutError = /** @class */function (_super) {
+  __extends(TimeoutError, _super);
+  function TimeoutError(message) {
+    var _this = _super.call(this, message) || this;
+    _this.name = 'TimeoutError';
+    _this.code = 'ETIMEDOUT';
+    _this.timestamp = new Date();
+    // Maintain proper stack trace (only available in V8 engines, e.g., Chrome and Node.js)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(_this, TimeoutError);
+    }
+    return _this;
+  }
+  return TimeoutError;
+}(Error);
+function withTimeout(fn, timeout) {
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () {
+        reject(new TimeoutError("Function timed out (max: ".concat(timeout, "ms)")));
+      }, timeout);
+      fn.apply(void 0, args).then(resolve)["catch"](reject)["finally"](function () {
+        return clearTimeout(timer);
+      });
+    });
+  };
+}
+
+var SKIPPED = Symbol();
+function batchFn(itemFn, _a) {
+  var _b = _a === void 0 ? {} : _a,
+    _c = _b.batchSize,
+    batchSize = _c === void 0 ? 10 : _c,
+    skip = _b.skip,
+    _d = _b.retry,
+    retry = _d === void 0 ? false : _d,
+    timeout = _b.timeout,
+    rollback = _b.rollback;
+  //
+  // Optionally wrap itemFn into timeout
+  //
+  itemFn = timeout ? withTimeout(itemFn, timeout) : itemFn;
+  return function batchExec(items) {
+    var _this = this;
+    var batches = arrayChunk(items, batchSize);
+    var promise = new PromiseLikeEventEmitter();
+    // const events = new EventEmitter<EventTypes>()
+    var progressCount = 0;
+    var resultsPromise = promiseReduce(batches, function (acc, batchItems, index) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var batch, batchResults;
+        var _this = this;
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              batch = {
+                index: index,
+                items: batchItems
+              };
+              promise.emit('batchStart', {
+                batch: batch
+              });
+              return [4 /*yield*/, Promise.all(batchItems.map(function (item) {
+                return __awaiter(_this, void 0, void 0, function () {
+                  var itemSkip, itemResult, _a, err_1, rollbackErr_1;
+                  return __generator(this, function (_b) {
+                    switch (_b.label) {
+                      case 0:
+                        _b.trys.push([0, 5,, 10]);
+                        promise.emit('itemStart', {
+                          batch: batch,
+                          item: item
+                        });
+                        return [4 /*yield*/, typeof skip === 'function' && skip(item)];
+                      case 1:
+                        itemSkip = _b.sent();
+                        if (itemSkip) {
+                          promise.emit('itemSkip', {
+                            batch: batch,
+                            item: item
+                          });
+                        }
+                        if (!itemSkip) return [3 /*break*/, 2];
+                        _a = SKIPPED;
+                        return [3 /*break*/, 4];
+                      case 2:
+                        return [4 /*yield*/, retry === true ? exponentialBackoff.backOff(function () {
+                          return itemFn(item);
+                        }) : _typeof(retry) === 'object' && retry !== null ? exponentialBackoff.backOff(function () {
+                          return itemFn(item);
+                        }, retry) : itemFn(item)];
+                      case 3:
+                        _a = _b.sent();
+                        _b.label = 4;
+                      case 4:
+                        itemResult = _a;
+                        progressCount += 1;
+                        promise.emit('progress', {
+                          type: itemSkip ? 'skip' : 'data',
+                          batch: batch,
+                          progress: progressCount / items.length,
+                          item: item,
+                          result: itemResult
+                        });
+                        return [2 /*return*/, itemResult];
+                      case 5:
+                        err_1 = _b.sent();
+                        progressCount += 1;
+                        promise.emit('progress', {
+                          type: 'error',
+                          batch: batch,
+                          progress: progressCount / items.length,
+                          item: item,
+                          result: err_1
+                        });
+                        if (!(typeof rollback === 'function')) return [3 /*break*/, 9];
+                        _b.label = 6;
+                      case 6:
+                        _b.trys.push([6, 8,, 9]);
+                        return [4 /*yield*/, rollback(item, err_1)];
+                      case 7:
+                        _b.sent();
+                        return [3 /*break*/, 9];
+                      case 8:
+                        rollbackErr_1 = _b.sent();
+                        console.error('Failure rolling back', rollbackErr_1);
+                        return [3 /*break*/, 9];
+                      case 9:
+                        return [2 /*return*/, err_1];
+                      case 10:
+                        return [2 /*return*/];
+                    }
+                  });
+                });
+              }))];
+            case 1:
+              batchResults = _a.sent();
+              promise.emit('batchProgress', {
+                batch: batch,
+                progress: batch.index + 1 / batches.length,
+                results: batchResults
+              });
+              return [2 /*return*/, __spreadArray(__spreadArray([], acc, true), batchResults, true)];
+          }
+        });
+      });
+    }, []);
+    resultsPromise.then(function (results) {
+      promise.resolve(results);
+      promise.emit('results', {
+        results: results
+      });
+    }, function (err) {
+      promise.reject(err);
+      promise.emit('error', err);
+    });
+    return promise;
+  };
+}
+function parseBatchedResults(inputs, results) {
+  return results.reduce(function (acc, result, index) {
+    if (result === SKIPPED) {
+      return _assign(_assign({}, acc), {
+        skipped: __spreadArray(__spreadArray([], acc.skipped, true), [inputs[index]], false)
+      });
+    } else if (result instanceof Error) {
+      return _assign(_assign({}, acc), {
+        errors: __spreadArray(__spreadArray([], acc.errors, true), [result], false)
+      });
+    } else {
+      return _assign(_assign({}, acc), {
+        results: __spreadArray(__spreadArray([], acc.results, true), [result], false)
+      });
+    }
+  }, {
+    results: [],
+    errors: [],
+    skipped: []
+  });
+}
+
+function makeDeferred() {
+  var resolve = function resolve() {};
+  var reject = function reject() {};
+  var settled = false;
+  var promise = new Promise(function (_resolve, _reject) {
+    resolve = function resolve(value) {
+      if (!settled) {
+        settled = true;
+        _resolve(value);
+      }
+    };
+    reject = function reject(reason) {
+      if (!settled) {
+        settled = true;
+        _reject(reason);
+      }
+    };
+  });
+  return {
+    promise: promise,
+    resolve: resolve,
+    reject: reject
+  };
+}
+
+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.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':
+      {
+        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);
+}
+
+//
+// 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.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 defaultParseResponse(response) {
+  return response.json();
+}
+function paginatedHttpFetch(_a) {
+  var pageUrl = _a.pageUrl,
+    _b = _a.parseResponse,
+    parseResponse = _b === void 0 ? defaultParseResponse : _b;
+  return function (params) {
+    return __awaiter(this, void 0, void 0, function () {
+      var response, data;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, fetch(pageUrl(params))];
+          case 1:
+            response = _a.sent();
+            return [4 /*yield*/, parseResponse(response)];
+          case 2:
+            data = _a.sent();
+            return [2 /*return*/, data];
+        }
+      });
+    });
+  };
+}
+function inMemoryDataStore() {
+  var data = [];
+  return {
+    getSize: function getSize() {
+      return data.length;
+    },
+    storePage: function storePage(pageData) {
+      data = __spreadArray(__spreadArray([], data, true), pageData, true);
+    },
+    getResult: function getResult() {
+      return data;
+    }
+  };
+}
+function fetchAllPages(_a) {
+  var fetchPage = _a.fetchPage,
+    _b = _a.pageSize,
+    pageSize = _b === void 0 ? 50 : _b,
+    _c = _a.dataStore,
+    dataStore = _c === void 0 ? inMemoryDataStore : _c;
+  return __awaiter(this, void 0, void 0, function () {
+    var store, currentPageData, currentOffset, result;
+    return __generator(this, function (_d) {
+      switch (_d.label) {
+        case 0:
+          store = dataStore();
+          currentPageData = null;
+          _d.label = 1;
+        case 1:
+          return [4 /*yield*/, store.getSize()];
+        case 2:
+          currentOffset = _d.sent();
+          return [4 /*yield*/, fetchPage({
+            offset: currentOffset,
+            pageSize: pageSize
+          })];
+        case 3:
+          currentPageData = _d.sent();
+          return [4 /*yield*/, store.storePage(currentPageData, {
+            offset: currentOffset,
+            pageSize: pageSize
+          })];
+        case 4:
+          _d.sent();
+          _d.label = 5;
+        case 5:
+          if (currentPageData.length === pageSize) return [3 /*break*/, 1];
+          _d.label = 6;
+        case 6:
+          return [4 /*yield*/, store.getResult()];
+        case 7:
+          result = _d.sent();
+          return [2 /*return*/, result];
+      }
+    });
+  });
+}
+
+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
+  .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
+//
+function hookFn(fn, _a) {
+  var input = _a.input,
+    validate = _a.validate,
+    before = _a.before,
+    output = _a.output,
+    after = _a.after;
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      var _input, _a, validationResult, error, rawResult, result, _b;
+      return __generator(this, function (_c) {
+        switch (_c.label) {
+          case 0:
+            if (!(typeof input === 'function')) return [3 /*break*/, 2];
+            return [4 /*yield*/, input.apply(void 0, args)];
+          case 1:
+            _a = _c.sent();
+            return [3 /*break*/, 3];
+          case 2:
+            _a = args;
+            _c.label = 3;
+          case 3:
+            _input = _a;
+            if (!Array.isArray(_input)) {
+              throw new TypeError('Input hook must resolve an array of args');
+            }
+            if (!(typeof validate === 'function')) return [3 /*break*/, 5];
+            return [4 /*yield*/, validate.apply(void 0, _input)];
+          case 4:
+            validationResult = _c.sent();
+            if (validationResult !== true) {
+              error = typeof validationResult === 'string' ? new Error(validationResult) : validationResult instanceof Error ? validationResult : new Error('Invalid input');
+              throw error;
+            }
+            _c.label = 5;
+          case 5:
+            if (!(typeof before === 'function')) return [3 /*break*/, 7];
+            return [4 /*yield*/, before.apply(void 0, _input)];
+          case 6:
+            _c.sent();
+            _c.label = 7;
+          case 7:
+            return [4 /*yield*/, fn.apply(void 0, _input)];
+          case 8:
+            rawResult = _c.sent();
+            if (!(typeof output === 'function')) return [3 /*break*/, 10];
+            return [4 /*yield*/, output(rawResult)];
+          case 9:
+            _b = _c.sent();
+            return [3 /*break*/, 11];
+          case 10:
+            _b = rawResult;
+            _c.label = 11;
+          case 11:
+            result = _b;
+            if (!(typeof after === 'function')) return [3 /*break*/, 13];
+            return [4 /*yield*/, after.apply(void 0, __spreadArray([result], _input, false))];
+          case 12:
+            _c.sent();
+            _c.label = 13;
+          case 13:
+            return [2 /*return*/, result];
+        }
+      });
+    });
+  };
+}
+
+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;
+  }
+}
+
+exports.DEFAULT_TYPES = DEFAULT_TYPES;
+exports.PromiseLikeEventEmitter = PromiseLikeEventEmitter;
+exports.SKIPPED = SKIPPED;
+exports.TimeoutError = TimeoutError;
+exports.arrayChunk = arrayChunk;
+exports.batchFn = batchFn;
+exports.dataJoin = dataJoin;
+exports.debugFn = debugFn;
+exports.deepFreeze = deepFreeze;
+exports.deprecateFn = deprecateFn;
+exports.deprecateInput = deprecateInput;
+exports.deprecateProperty = deprecateProperty;
+exports.fetchAllPages = fetchAllPages;
+exports.hasNestedPromises = hasNestedPromises;
+exports.hookFn = hookFn;
+exports.inMemoryDataStore = inMemoryDataStore;
+exports.interpolate = interpolate;
+exports.isPromise = isPromise;
+exports.isValidUrl = isValidUrl;
+exports.makeDeferred = makeDeferred;
+exports.makeTypeOf = makeTypeOf;
+exports.maybeAsyncFn = maybeAsyncFn;
+exports.maybeFn = maybeFn;
+exports.maybeReturnPromise = maybeReturnPromise;
+exports.normalizeString = normalizeString;
+exports.paginatedHttpFetch = paginatedHttpFetch;
+exports.parseBatchedResults = parseBatchedResults;
+exports.pickPaths = pickPaths;
+exports.promiseReduce = promiseReduce;
+exports.resolveNestedPromises = resolveNestedPromises;
+exports.sequentialCallIdGenerator = sequentialCallIdGenerator;
+exports.slugify = slugify;
+exports.strExpr = strExpr;
+exports.switchExec = switchExec;
+exports.switchValue = switchValue;
+exports.syntheticJson = syntheticJson;
+exports.typeMap = typeMap;
+exports.typeOf = typeOf;
+exports.untilConditionIsSatisfiedReducer = untilConditionIsSatisfiedReducer;
+exports.url = url;
+exports.wait = wait;
+exports.withTimeout = withTimeout;