@swagger-api/apidom-json-pointer 0.76.0 → 0.76.1

package/dist/apidom-json-pointer.browser.js

@@ -326,6 +326,16 @@ const safeDecodeURIComponent = encodedURIComponent => {
 const unescape = (0,ramda__WEBPACK_IMPORTED_MODULE_0__.pipe)((0,ramda__WEBPACK_IMPORTED_MODULE_0__.replace)(/~1/g, '/'), (0,ramda__WEBPACK_IMPORTED_MODULE_0__.replace)(/~0/g, '~'), safeDecodeURIComponent);
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (unescape);
 
+/***/ }),
+
+/***/ 60042:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var parent = __webpack_require__(35846);
+
+module.exports = parent;
+
+
 /***/ }),
 
 /***/ 28385:
@@ -400,6 +410,21 @@ var parent = __webpack_require__(16042);
 module.exports = parent;
 
 
+/***/ }),
+
+/***/ 56791:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+__webpack_require__(4339);
+__webpack_require__(4242);
+__webpack_require__(84016);
+__webpack_require__(98939);
+__webpack_require__(5454);
+var path = __webpack_require__(57545);
+
+module.exports = path.AggregateError;
+
+
 /***/ }),
 
 /***/ 92089:
@@ -522,6 +547,27 @@ var WrappedWellKnownSymbolModule = __webpack_require__(89207);
 module.exports = WrappedWellKnownSymbolModule.f('toPrimitive');
 
 
+/***/ }),
+
+/***/ 36762:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(73028);
+
+
+/***/ }),
+
+/***/ 73028:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+// TODO: remove from `core-js@4`
+__webpack_require__(12752);
+
+var parent = __webpack_require__(60042);
+
+module.exports = parent;
+
+
 /***/ }),
 
 /***/ 32747:
@@ -951,6 +997,29 @@ module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
 };
 
 
+/***/ }),
+
+/***/ 97987:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var hasOwn = __webpack_require__(64500);
+var ownKeys = __webpack_require__(93011);
+var getOwnPropertyDescriptorModule = __webpack_require__(5141);
+var definePropertyModule = __webpack_require__(42760);
+
+module.exports = function (target, source, exceptions) {
+  var keys = ownKeys(source);
+  var defineProperty = definePropertyModule.f;
+  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+    }
+  }
+};
+
+
 /***/ }),
 
 /***/ 4635:
@@ -1248,6 +1317,65 @@ module.exports = [
 ];
 
 
+/***/ }),
+
+/***/ 14503:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var uncurryThis = __webpack_require__(84120);
+
+var $Error = Error;
+var replace = uncurryThis(''.replace);
+
+var TEST = (function (arg) { return String($Error(arg).stack); })('zxcasd');
+// eslint-disable-next-line redos/no-vulnerable -- safe
+var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
+var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
+
+module.exports = function (stack, dropEntries) {
+  if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
+    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
+  } return stack;
+};
+
+
+/***/ }),
+
+/***/ 58266:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var createNonEnumerableProperty = __webpack_require__(98711);
+var clearErrorStack = __webpack_require__(14503);
+var ERROR_STACK_INSTALLABLE = __webpack_require__(50274);
+
+// non-standard V8
+var captureStackTrace = Error.captureStackTrace;
+
+module.exports = function (error, C, stack, dropEntries) {
+  if (ERROR_STACK_INSTALLABLE) {
+    if (captureStackTrace) captureStackTrace(error, C);
+    else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries));
+  }
+};
+
+
+/***/ }),
+
+/***/ 50274:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var fails = __webpack_require__(76192);
+var createPropertyDescriptor = __webpack_require__(90774);
+
+module.exports = !fails(function () {
+  var error = Error('a');
+  if (!('stack' in error)) return true;
+  // eslint-disable-next-line es/no-object-defineproperty -- safe
+  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
+  return error.stack !== 7;
+});
+
+
 /***/ }),
 
 /***/ 93085:
@@ -1531,6 +1659,46 @@ module.exports = function (namespace, method) {
 };
 
 
+/***/ }),
+
+/***/ 78703:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var classof = __webpack_require__(4696);
+var getMethod = __webpack_require__(75037);
+var isNullOrUndefined = __webpack_require__(75646);
+var Iterators = __webpack_require__(82621);
+var wellKnownSymbol = __webpack_require__(18182);
+
+var ITERATOR = wellKnownSymbol('iterator');
+
+module.exports = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+    || getMethod(it, '@@iterator')
+    || Iterators[classof(it)];
+};
+
+
+/***/ }),
+
+/***/ 61669:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var call = __webpack_require__(18922);
+var aCallable = __webpack_require__(66235);
+var anObject = __webpack_require__(31138);
+var tryToString = __webpack_require__(79288);
+var getIteratorMethod = __webpack_require__(78703);
+
+var $TypeError = TypeError;
+
+module.exports = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+  throw $TypeError(tryToString(argument) + ' is not iterable');
+};
+
+
 /***/ }),
 
 /***/ 19202:
@@ -1680,6 +1848,31 @@ module.exports = fails(function () {
 } : $Object;
 
 
+/***/ }),
+
+/***/ 62643:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isCallable = __webpack_require__(16447);
+var isObject = __webpack_require__(35744);
+var setPrototypeOf = __webpack_require__(24469);
+
+// makes subclassing work correct for wrapped built-ins
+module.exports = function ($this, dummy, Wrapper) {
+  var NewTarget, NewTargetPrototype;
+  if (
+    // it can work only with native `setPrototypeOf`
+    setPrototypeOf &&
+    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
+    isCallable(NewTarget = dummy.constructor) &&
+    NewTarget !== Wrapper &&
+    isObject(NewTargetPrototype = NewTarget.prototype) &&
+    NewTargetPrototype !== Wrapper.prototype
+  ) setPrototypeOf($this, NewTargetPrototype);
+  return $this;
+};
+
+
 /***/ }),
 
 /***/ 19516:
@@ -1701,6 +1894,23 @@ if (!isCallable(store.inspectSource)) {
 module.exports = store.inspectSource;
 
 
+/***/ }),
+
+/***/ 10273:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isObject = __webpack_require__(35744);
+var createNonEnumerableProperty = __webpack_require__(98711);
+
+// `InstallErrorCause` abstract operation
+// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
+module.exports = function (O, options) {
+  if (isObject(options) && 'cause' in options) {
+    createNonEnumerableProperty(O, 'cause', options.cause);
+  }
+};
+
+
 /***/ }),
 
 /***/ 73326:
@@ -1778,6 +1988,23 @@ module.exports = {
 };
 
 
+/***/ }),
+
+/***/ 96109:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var wellKnownSymbol = __webpack_require__(18182);
+var Iterators = __webpack_require__(82621);
+
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+module.exports = function (it) {
+  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+};
+
+
 /***/ }),
 
 /***/ 34770:
@@ -1956,6 +2183,111 @@ module.exports = USE_SYMBOL_AS_UID ? function (it) {
 };
 
 
+/***/ }),
+
+/***/ 33442:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var bind = __webpack_require__(8043);
+var call = __webpack_require__(18922);
+var anObject = __webpack_require__(31138);
+var tryToString = __webpack_require__(79288);
+var isArrayIteratorMethod = __webpack_require__(96109);
+var lengthOfArrayLike = __webpack_require__(84104);
+var isPrototypeOf = __webpack_require__(8902);
+var getIterator = __webpack_require__(61669);
+var getIteratorMethod = __webpack_require__(78703);
+var iteratorClose = __webpack_require__(66639);
+
+var $TypeError = TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+module.exports = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_RECORD = !!(options && options.IS_RECORD);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = bind(unboundFunction, that);
+  var iterator, iterFn, index, length, result, next, step;
+
+  var stop = function (condition) {
+    if (iterator) iteratorClose(iterator, 'normal', condition);
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      anObject(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_RECORD) {
+    iterator = iterable.iterator;
+  } else if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (!iterFn) throw $TypeError(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && isPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = IS_RECORD ? iterable.next : iterator.next;
+  while (!(step = call(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+
+/***/ }),
+
+/***/ 66639:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var call = __webpack_require__(18922);
+var anObject = __webpack_require__(31138);
+var getMethod = __webpack_require__(75037);
+
+module.exports = function (iterator, kind, value) {
+  var innerResult, innerError;
+  anObject(iterator);
+  try {
+    innerResult = getMethod(iterator, 'return');
+    if (!innerResult) {
+      if (kind === 'throw') throw value;
+      return value;
+    }
+    innerResult = call(innerResult, iterator);
+  } catch (error) {
+    innerError = true;
+    innerResult = error;
+  }
+  if (kind === 'throw') throw value;
+  if (innerError) throw innerResult;
+  anObject(innerResult);
+  return value;
+};
+
+
 /***/ }),
 
 /***/ 25695:
@@ -2183,6 +2515,18 @@ module.exports = Math.trunc || function trunc(x) {
 };
 
 
+/***/ }),
+
+/***/ 36016:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var toString = __webpack_require__(44845);
+
+module.exports = function (argument, $default) {
+  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
+};
+
+
 /***/ }),
 
 /***/ 52853:
@@ -2611,6 +2955,27 @@ module.exports = function (input, pref) {
 };
 
 
+/***/ }),
+
+/***/ 93011:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getBuiltIn = __webpack_require__(10150);
+var uncurryThis = __webpack_require__(84120);
+var getOwnPropertyNamesModule = __webpack_require__(92092);
+var getOwnPropertySymbolsModule = __webpack_require__(84750);
+var anObject = __webpack_require__(31138);
+
+var concat = uncurryThis([].concat);
+
+// all object keys, includes non-enumerable and symbols
+module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = getOwnPropertyNamesModule.f(anObject(it));
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+
 /***/ }),
 
 /***/ 57545:
@@ -2619,6 +2984,22 @@ module.exports = function (input, pref) {
 module.exports = {};
 
 
+/***/ }),
+
+/***/ 67656:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var defineProperty = (__webpack_require__(42760).f);
+
+module.exports = function (Target, Source, key) {
+  key in Target || defineProperty(Target, key, {
+    configurable: true,
+    get: function () { return Source[key]; },
+    set: function (it) { Source[key] = it; }
+  });
+};
+
+
 /***/ }),
 
 /***/ 13209:
@@ -3169,6 +3550,176 @@ module.exports = function (name) {
 };
 
 
+/***/ }),
+
+/***/ 20426:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+var getBuiltIn = __webpack_require__(10150);
+var hasOwn = __webpack_require__(64500);
+var createNonEnumerableProperty = __webpack_require__(98711);
+var isPrototypeOf = __webpack_require__(8902);
+var setPrototypeOf = __webpack_require__(24469);
+var copyConstructorProperties = __webpack_require__(97987);
+var proxyAccessor = __webpack_require__(67656);
+var inheritIfRequired = __webpack_require__(62643);
+var normalizeStringArgument = __webpack_require__(36016);
+var installErrorCause = __webpack_require__(10273);
+var installErrorStack = __webpack_require__(58266);
+var DESCRIPTORS = __webpack_require__(50069);
+var IS_PURE = __webpack_require__(85546);
+
+module.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {
+  var STACK_TRACE_LIMIT = 'stackTraceLimit';
+  var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;
+  var path = FULL_NAME.split('.');
+  var ERROR_NAME = path[path.length - 1];
+  var OriginalError = getBuiltIn.apply(null, path);
+
+  if (!OriginalError) return;
+
+  var OriginalErrorPrototype = OriginalError.prototype;
+
+  // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006
+  if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;
+
+  if (!FORCED) return OriginalError;
+
+  var BaseError = getBuiltIn('Error');
+
+  var WrappedError = wrapper(function (a, b) {
+    var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);
+    var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();
+    if (message !== undefined) createNonEnumerableProperty(result, 'message', message);
+    installErrorStack(result, WrappedError, result.stack, 2);
+    if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);
+    if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);
+    return result;
+  });
+
+  WrappedError.prototype = OriginalErrorPrototype;
+
+  if (ERROR_NAME !== 'Error') {
+    if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError);
+    else copyConstructorProperties(WrappedError, BaseError, { name: true });
+  } else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) {
+    proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT);
+    proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace');
+  }
+
+  copyConstructorProperties(WrappedError, OriginalError);
+
+  if (!IS_PURE) try {
+    // Safari 13- bug: WebAssembly errors does not have a proper `.name`
+    if (OriginalErrorPrototype.name !== ERROR_NAME) {
+      createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME);
+    }
+    OriginalErrorPrototype.constructor = WrappedError;
+  } catch (error) { /* empty */ }
+
+  return WrappedError;
+};
+
+
+/***/ }),
+
+/***/ 84016:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+var $ = __webpack_require__(93085);
+var getBuiltIn = __webpack_require__(10150);
+var apply = __webpack_require__(86298);
+var fails = __webpack_require__(76192);
+var wrapErrorConstructorWithCause = __webpack_require__(20426);
+
+var AGGREGATE_ERROR = 'AggregateError';
+var $AggregateError = getBuiltIn(AGGREGATE_ERROR);
+
+var FORCED = !fails(function () {
+  return $AggregateError([1]).errors[0] !== 1;
+}) && fails(function () {
+  return $AggregateError([1], AGGREGATE_ERROR, { cause: 7 }).cause !== 7;
+});
+
+// https://tc39.es/ecma262/#sec-aggregate-error
+$({ global: true, constructor: true, arity: 2, forced: FORCED }, {
+  AggregateError: wrapErrorConstructorWithCause(AGGREGATE_ERROR, function (init) {
+    // eslint-disable-next-line no-unused-vars -- required for functions `.length`
+    return function AggregateError(errors, message) { return apply(init, this, arguments); };
+  }, FORCED, true)
+});
+
+
+/***/ }),
+
+/***/ 93820:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+var $ = __webpack_require__(93085);
+var isPrototypeOf = __webpack_require__(8902);
+var getPrototypeOf = __webpack_require__(89341);
+var setPrototypeOf = __webpack_require__(24469);
+var copyConstructorProperties = __webpack_require__(97987);
+var create = __webpack_require__(52853);
+var createNonEnumerableProperty = __webpack_require__(98711);
+var createPropertyDescriptor = __webpack_require__(90774);
+var installErrorCause = __webpack_require__(10273);
+var installErrorStack = __webpack_require__(58266);
+var iterate = __webpack_require__(33442);
+var normalizeStringArgument = __webpack_require__(36016);
+var wellKnownSymbol = __webpack_require__(18182);
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var $Error = Error;
+var push = [].push;
+
+var $AggregateError = function AggregateError(errors, message /* , options */) {
+  var isInstance = isPrototypeOf(AggregateErrorPrototype, this);
+  var that;
+  if (setPrototypeOf) {
+    that = setPrototypeOf($Error(), isInstance ? getPrototypeOf(this) : AggregateErrorPrototype);
+  } else {
+    that = isInstance ? this : create(AggregateErrorPrototype);
+    createNonEnumerableProperty(that, TO_STRING_TAG, 'Error');
+  }
+  if (message !== undefined) createNonEnumerableProperty(that, 'message', normalizeStringArgument(message));
+  installErrorStack(that, $AggregateError, that.stack, 1);
+  if (arguments.length > 2) installErrorCause(that, arguments[2]);
+  var errorsArray = [];
+  iterate(errors, push, { that: errorsArray });
+  createNonEnumerableProperty(that, 'errors', errorsArray);
+  return that;
+};
+
+if (setPrototypeOf) setPrototypeOf($AggregateError, $Error);
+else copyConstructorProperties($AggregateError, $Error, { name: true });
+
+var AggregateErrorPrototype = $AggregateError.prototype = create($Error.prototype, {
+  constructor: createPropertyDescriptor(1, $AggregateError),
+  message: createPropertyDescriptor(1, ''),
+  name: createPropertyDescriptor(1, 'AggregateError')
+});
+
+// `AggregateError` constructor
+// https://tc39.es/ecma262/#sec-aggregate-error-constructor
+$({ global: true, constructor: true, arity: 2 }, {
+  AggregateError: $AggregateError
+});
+
+
+/***/ }),
+
+/***/ 4242:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+// TODO: Remove this module from `core-js@4` since it's replaced to module below
+__webpack_require__(93820);
+
+
 /***/ }),
 
 /***/ 59106:
@@ -3344,6 +3895,69 @@ if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {
 // empty
 
 
+/***/ }),
+
+/***/ 4339:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+/* eslint-disable no-unused-vars -- required for functions `.length` */
+var $ = __webpack_require__(93085);
+var global = __webpack_require__(98576);
+var apply = __webpack_require__(86298);
+var wrapErrorConstructorWithCause = __webpack_require__(20426);
+
+var WEB_ASSEMBLY = 'WebAssembly';
+var WebAssembly = global[WEB_ASSEMBLY];
+
+var FORCED = Error('e', { cause: 7 }).cause !== 7;
+
+var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {
+  var O = {};
+  O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);
+  $({ global: true, constructor: true, arity: 1, forced: FORCED }, O);
+};
+
+var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {
+  if (WebAssembly && WebAssembly[ERROR_NAME]) {
+    var O = {};
+    O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);
+    $({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O);
+  }
+};
+
+// https://tc39.es/ecma262/#sec-nativeerror
+exportGlobalErrorCauseWrapper('Error', function (init) {
+  return function Error(message) { return apply(init, this, arguments); };
+});
+exportGlobalErrorCauseWrapper('EvalError', function (init) {
+  return function EvalError(message) { return apply(init, this, arguments); };
+});
+exportGlobalErrorCauseWrapper('RangeError', function (init) {
+  return function RangeError(message) { return apply(init, this, arguments); };
+});
+exportGlobalErrorCauseWrapper('ReferenceError', function (init) {
+  return function ReferenceError(message) { return apply(init, this, arguments); };
+});
+exportGlobalErrorCauseWrapper('SyntaxError', function (init) {
+  return function SyntaxError(message) { return apply(init, this, arguments); };
+});
+exportGlobalErrorCauseWrapper('TypeError', function (init) {
+  return function TypeError(message) { return apply(init, this, arguments); };
+});
+exportGlobalErrorCauseWrapper('URIError', function (init) {
+  return function URIError(message) { return apply(init, this, arguments); };
+});
+exportWebAssemblyErrorCauseWrapper('CompileError', function (init) {
+  return function CompileError(message) { return apply(init, this, arguments); };
+});
+exportWebAssemblyErrorCauseWrapper('LinkError', function (init) {
+  return function LinkError(message) { return apply(init, this, arguments); };
+});
+exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {
+  return function RuntimeError(message) { return apply(init, this, arguments); };
+});
+
+
 /***/ }),
 
 /***/ 59704:
@@ -4064,6 +4678,15 @@ var defineWellKnownSymbol = __webpack_require__(48332);
 defineWellKnownSymbol('unscopables');
 
 
+/***/ }),
+
+/***/ 12752:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+// TODO: Remove from `core-js@4`
+__webpack_require__(4242);
+
+
 /***/ }),
 
 /***/ 17148:
@@ -4268,6 +4891,20 @@ for (var COLLECTION_NAME in DOMIterables) {
 }
 
 
+/***/ }),
+
+/***/ 35846:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+// TODO: remove from `core-js@4`
+__webpack_require__(12752);
+
+var parent = __webpack_require__(56791);
+__webpack_require__(80162);
+
+module.exports = parent;
+
+
 /***/ }),
 
 /***/ 26174:
@@ -10953,8 +11590,12 @@ var trimCharsStart = (0,ramda__WEBPACK_IMPORTED_MODULE_0__.curry)(function (char
 /***/ 68322:
 /***/ ((module) => {
 
+"use strict";
+
 var ShortUniqueId = (() => {
   var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -10970,22 +11611,34 @@ var ShortUniqueId = (() => {
       }
     return a;
   };
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
     DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
     default: () => ShortUniqueId
   });
 
   // package.json
-  var version = "4.4.4";
+  var version = "5.0.2";
 
   // src/index.ts
   var DEFAULT_UUID_LENGTH = 6;
@@ -10993,54 +11646,70 @@ var ShortUniqueId = (() => {
     dictionary: "alphanum",
     shuffle: true,
     debug: false,
-    length: DEFAULT_UUID_LENGTH
+    length: DEFAULT_UUID_LENGTH,
+    counter: 0
   };
-  var _ShortUniqueId = class extends Function {
+  var _ShortUniqueId = class _ShortUniqueId {
     constructor(argOptions = {}) {
-      super();
-      this.dictIndex = 0;
-      this.dictRange = [];
-      this.lowerBound = 0;
-      this.upperBound = 0;
-      this.dictLength = 0;
-      this._digit_first_ascii = 48;
-      this._digit_last_ascii = 58;
-      this._alpha_lower_first_ascii = 97;
-      this._alpha_lower_last_ascii = 123;
-      this._hex_last_ascii = 103;
-      this._alpha_upper_first_ascii = 65;
-      this._alpha_upper_last_ascii = 91;
-      this._number_dict_ranges = {
+      __publicField(this, "counter");
+      __publicField(this, "debug");
+      __publicField(this, "dict");
+      __publicField(this, "version");
+      __publicField(this, "dictIndex", 0);
+      __publicField(this, "dictRange", []);
+      __publicField(this, "lowerBound", 0);
+      __publicField(this, "upperBound", 0);
+      __publicField(this, "dictLength", 0);
+      __publicField(this, "uuidLength");
+      __publicField(this, "_digit_first_ascii", 48);
+      __publicField(this, "_digit_last_ascii", 58);
+      __publicField(this, "_alpha_lower_first_ascii", 97);
+      __publicField(this, "_alpha_lower_last_ascii", 123);
+      __publicField(this, "_hex_last_ascii", 103);
+      __publicField(this, "_alpha_upper_first_ascii", 65);
+      __publicField(this, "_alpha_upper_last_ascii", 91);
+      __publicField(this, "_number_dict_ranges", {
         digits: [this._digit_first_ascii, this._digit_last_ascii]
-      };
-      this._alpha_dict_ranges = {
+      });
+      __publicField(this, "_alpha_dict_ranges", {
         lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
         upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-      };
-      this._alpha_lower_dict_ranges = {
+      });
+      __publicField(this, "_alpha_lower_dict_ranges", {
         lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
-      };
-      this._alpha_upper_dict_ranges = {
+      });
+      __publicField(this, "_alpha_upper_dict_ranges", {
         upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-      };
-      this._alphanum_dict_ranges = {
+      });
+      __publicField(this, "_alphanum_dict_ranges", {
         digits: [this._digit_first_ascii, this._digit_last_ascii],
         lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
         upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-      };
-      this._alphanum_lower_dict_ranges = {
+      });
+      __publicField(this, "_alphanum_lower_dict_ranges", {
         digits: [this._digit_first_ascii, this._digit_last_ascii],
         lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
-      };
-      this._alphanum_upper_dict_ranges = {
+      });
+      __publicField(this, "_alphanum_upper_dict_ranges", {
         digits: [this._digit_first_ascii, this._digit_last_ascii],
         upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-      };
-      this._hex_dict_ranges = {
+      });
+      __publicField(this, "_hex_dict_ranges", {
         decDigits: [this._digit_first_ascii, this._digit_last_ascii],
         alphaDigits: [this._alpha_lower_first_ascii, this._hex_last_ascii]
-      };
-      this.log = (...args) => {
+      });
+      __publicField(this, "_dict_ranges", {
+        _number_dict_ranges: this._number_dict_ranges,
+        _alpha_dict_ranges: this._alpha_dict_ranges,
+        _alpha_lower_dict_ranges: this._alpha_lower_dict_ranges,
+        _alpha_upper_dict_ranges: this._alpha_upper_dict_ranges,
+        _alphanum_dict_ranges: this._alphanum_dict_ranges,
+        _alphanum_lower_dict_ranges: this._alphanum_lower_dict_ranges,
+        _alphanum_upper_dict_ranges: this._alphanum_upper_dict_ranges,
+        _hex_dict_ranges: this._hex_dict_ranges
+      });
+      /* tslint:disable consistent-return */
+      __publicField(this, "log", (...args) => {
         const finalArgs = [...args];
         finalArgs[0] = `[short-unique-id] ${args[0]}`;
         if (this.debug === true) {
@@ -11048,8 +11717,10 @@ var ShortUniqueId = (() => {
             return console.log(...finalArgs);
           }
         }
-      };
-      this.setDictionary = (dictionary, shuffle) => {
+      });
+      /* tslint:enable consistent-return */
+      /** Change the dictionary after initialization. */
+      __publicField(this, "setDictionary", (dictionary, shuffle) => {
         let finalDict;
         if (dictionary && Array.isArray(dictionary) && dictionary.length > 1) {
           finalDict = dictionary;
@@ -11058,7 +11729,7 @@ var ShortUniqueId = (() => {
           let i;
           this.dictIndex = i = 0;
           const rangesName = `_${dictionary}_dict_ranges`;
-          const ranges = this[rangesName];
+          const ranges = this._dict_ranges[rangesName];
           Object.keys(ranges).forEach((rangeType) => {
             const rangeTypeKey = rangeType;
             this.dictRange = ranges[rangeTypeKey];
@@ -11075,12 +11746,16 @@ var ShortUniqueId = (() => {
         }
         this.dict = finalDict;
         this.dictLength = this.dict.length;
-        this.counter = 0;
-      };
-      this.seq = () => {
+        this.setCounter(0);
+      });
+      __publicField(this, "seq", () => {
         return this.sequentialUUID();
-      };
-      this.sequentialUUID = () => {
+      });
+      /**
+       * Generates UUID based on internal counter that's incremented after each ID generation.
+       * @alias `const uid = new ShortUniqueId(); uid.seq();`
+       */
+      __publicField(this, "sequentialUUID", () => {
         let counterDiv;
         let counterRem;
         let id = "";
@@ -11092,8 +11767,15 @@ var ShortUniqueId = (() => {
         } while (counterDiv !== 0);
         this.counter += 1;
         return id;
-      };
-      this.randomUUID = (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+      });
+      __publicField(this, "rnd", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+        return this.randomUUID(uuidLength);
+      });
+      /**
+       * Generates UUID by creating each part randomly.
+       * @alias `const uid = new ShortUniqueId(); uid.rnd(uuidLength: number);`
+       */
+      __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
         let id;
         let randomPartIdx;
         let j;
@@ -11103,44 +11785,234 @@ var ShortUniqueId = (() => {
         const isPositive = uuidLength >= 0;
         id = "";
         for (j = 0; j < uuidLength; j += 1) {
-          randomPartIdx = parseInt((Math.random() * this.dictLength).toFixed(0), 10) % this.dictLength;
+          randomPartIdx = parseInt(
+            (Math.random() * this.dictLength).toFixed(0),
+            10
+          ) % this.dictLength;
           id += this.dict[randomPartIdx];
         }
         return id;
-      };
-      this.availableUUIDs = (uuidLength = this.uuidLength) => {
-        return parseFloat(Math.pow([...new Set(this.dict)].length, uuidLength).toFixed(0));
-      };
-      this.approxMaxBeforeCollision = (rounds = this.availableUUIDs(this.uuidLength)) => {
-        return parseFloat(Math.sqrt(Math.PI / 2 * rounds).toFixed(20));
-      };
-      this.collisionProbability = (rounds = this.availableUUIDs(this.uuidLength), uuidLength = this.uuidLength) => {
-        return parseFloat((this.approxMaxBeforeCollision(rounds) / this.availableUUIDs(uuidLength)).toFixed(20));
-      };
-      this.uniqueness = (rounds = this.availableUUIDs(this.uuidLength)) => {
-        const score = parseFloat((1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20));
+      });
+      __publicField(this, "fmt", (format, date) => {
+        return this.formattedUUID(format, date);
+      });
+      /**
+       * Generates custom UUID with the provided format string.
+       * @alias `const uid = new ShortUniqueId(); uid.fmt(format: string);`
+       */
+      __publicField(this, "formattedUUID", (format, date) => {
+        const fnMap = {
+          "$r": this.randomUUID,
+          "$s": this.sequentialUUID,
+          "$t": this.stamp
+        };
+        const result = format.replace(
+          /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
+          (m) => {
+            const fn = m.slice(0, 2);
+            const len = parseInt(m.slice(2), 10);
+            if (fn === "$s") {
+              return fnMap[fn]().padStart(len, "0");
+            }
+            if (fn === "$t" && date) {
+              return fnMap[fn](len, date);
+            }
+            return fnMap[fn](len);
+          }
+        );
+        return result;
+      });
+      /**
+       * Calculates total number of possible UUIDs.
+       *
+       * Given that:
+       *
+       * - `H` is the total number of possible UUIDs
+       * - `n` is the number of unique characters in the dictionary
+       * - `l` is the UUID length
+       *
+       * Then `H` is defined as `n` to the power of `l`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="https://render.githubusercontent.com/render/math?math=%5CHuge%20H=n%5El"/>
+       * </div>
+       *
+       * This function returns `H`.
+       */
+      __publicField(this, "availableUUIDs", (uuidLength = this.uuidLength) => {
+        return parseFloat(
+          Math.pow([...new Set(this.dict)].length, uuidLength).toFixed(0)
+        );
+      });
+      /**
+       * Calculates approximate number of hashes before first collision.
+       *
+       * Given that:
+       *
+       * - `H` is the total number of possible UUIDs, or in terms of this library,
+       * the result of running `availableUUIDs()`
+       * - the expected number of values we have to choose before finding the
+       * first collision can be expressed as the quantity `Q(H)`
+       *
+       * Then `Q(H)` can be approximated as the square root of the product of half
+       * of pi times `H`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="https://render.githubusercontent.com/render/math?math=%5CHuge%20Q(H)%5Capprox%5Csqrt%7B%5Cfrac%7B%5Cpi%7D%7B2%7DH%7D"/>
+       * </div>
+       *
+       * This function returns `Q(H)`.
+       * 
+       * (see [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution))
+       */
+      __publicField(this, "approxMaxBeforeCollision", (rounds = this.availableUUIDs(this.uuidLength)) => {
+        return parseFloat(
+          Math.sqrt(Math.PI / 2 * rounds).toFixed(20)
+        );
+      });
+      /**
+       * Calculates probability of generating duplicate UUIDs (a collision) in a
+       * given number of UUID generation rounds.
+       *
+       * Given that:
+       *
+       * - `r` is the maximum number of times that `randomUUID()` will be called,
+       * or better said the number of _rounds_
+       * - `H` is the total number of possible UUIDs, or in terms of this library,
+       * the result of running `availableUUIDs()`
+       *
+       * Then the probability of collision `p(r; H)` can be approximated as the result
+       * of dividing the square root of the product of half of pi times `r` by `H`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="https://render.githubusercontent.com/render/math?math=%5CHuge%20p(r%3B%20H)%5Capprox%5Cfrac%7B%5Csqrt%7B%5Cfrac%7B%5Cpi%7D%7B2%7Dr%7D%7D%7BH%7D"/>
+       * </div>
+       *
+       * This function returns `p(r; H)`.
+       * 
+       * (see [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution))
+       *
+       * (Useful if you are wondering _"If I use this lib and expect to perform at most
+       * `r` rounds of UUID generations, what is the probability that I will hit a duplicate UUID?"_.)
+       */
+      __publicField(this, "collisionProbability", (rounds = this.availableUUIDs(this.uuidLength), uuidLength = this.uuidLength) => {
+        return parseFloat(
+          (this.approxMaxBeforeCollision(rounds) / this.availableUUIDs(uuidLength)).toFixed(20)
+        );
+      });
+      /**
+       * Calculate a "uniqueness" score (from 0 to 1) of UUIDs based on size of
+       * dictionary and chosen UUID length.
+       *
+       * Given that:
+       *
+       * - `H` is the total number of possible UUIDs, or in terms of this library,
+       * the result of running `availableUUIDs()`
+       * - `Q(H)` is the approximate number of hashes before first collision,
+       * or in terms of this library, the result of running `approxMaxBeforeCollision()`
+       *
+       * Then `uniqueness` can be expressed as the additive inverse of the probability of
+       * generating a "word" I had previously generated (a duplicate) at any given iteration
+       * up to the the total number of possible UUIDs expressed as the quotiend of `Q(H)` and `H`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="https://render.githubusercontent.com/render/math?math=%5CHuge%201-%5Cfrac%7BQ(H)%7D%7BH%7D"/>
+       * </div>
+       *
+       * (Useful if you need a value to rate the "quality" of the combination of given dictionary
+       * and UUID length. The closer to 1, higher the uniqueness and thus better the quality.)
+       */
+      __publicField(this, "uniqueness", (rounds = this.availableUUIDs(this.uuidLength)) => {
+        const score = parseFloat(
+          (1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20)
+        );
         return score > 1 ? 1 : score < 0 ? 0 : score;
-      };
-      this.getVersion = () => {
+      });
+      /**
+       * Return the version of this module.
+       */
+      __publicField(this, "getVersion", () => {
         return this.version;
-      };
-      this.stamp = (finalLength) => {
+      });
+      /**
+       * Generates a UUID with a timestamp that can be extracted using `uid.parseStamp(stampString);`.
+       * 
+       * ```js
+       *  const uidWithTimestamp = uid.stamp(32);
+       *  console.log(uidWithTimestamp);
+       *  // GDa608f973aRCHLXQYPTbKDbjDeVsSb3
+       * 
+       *  console.log(uid.parseStamp(uidWithTimestamp));
+       *  // 2021-05-03T06:24:58.000Z
+       *  ```
+       */
+      __publicField(this, "stamp", (finalLength, date) => {
+        const hexStamp = Math.floor(+(date || /* @__PURE__ */ new Date()) / 1e3).toString(16);
+        if (typeof finalLength === "number" && finalLength === 0) {
+          return hexStamp;
+        }
         if (typeof finalLength !== "number" || finalLength < 10) {
-          throw new Error("Param finalLength must be number greater than 10");
+          throw new Error(
+            [
+              "Param finalLength must be a number greater than or equal to 10,",
+              "or 0 if you want the raw hexadecimal timestamp"
+            ].join("\n")
+          );
         }
-        const hexStamp = Math.floor(+new Date() / 1e3).toString(16);
         const idLength = finalLength - 9;
         const rndIdx = Math.round(Math.random() * (idLength > 15 ? 15 : idLength));
         const id = this.randomUUID(idLength);
-        return `${id.substr(0, rndIdx)}${hexStamp}${id.substr(rndIdx)}${rndIdx.toString(16)}`;
-      };
-      this.parseStamp = (stamp) => {
+        return `${id.substring(0, rndIdx)}${hexStamp}${id.substring(rndIdx)}${rndIdx.toString(16)}`;
+      });
+      /**
+       * Extracts the date embeded in a UUID generated using the `uid.stamp(finalLength);` method.
+       * 
+       * ```js
+       *  const uidWithTimestamp = uid.stamp(32);
+       *  console.log(uidWithTimestamp);
+       *  // GDa608f973aRCHLXQYPTbKDbjDeVsSb3
+       * 
+       *  console.log(uid.parseStamp(uidWithTimestamp));
+       *  // 2021-05-03T06:24:58.000Z
+       *  ```
+       */
+      __publicField(this, "parseStamp", (suid, format) => {
+        if (format && !/t0|t[1-9]\d{1,}/.test(format)) {
+          throw new Error("Cannot extract date from a formated UUID with no timestamp in the format");
+        }
+        const stamp = format ? format.replace(
+          /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
+          (m) => {
+            const fnMap = {
+              "$r": (len2) => [...Array(len2)].map(() => "r").join(""),
+              "$s": (len2) => [...Array(len2)].map(() => "s").join(""),
+              "$t": (len2) => [...Array(len2)].map(() => "t").join("")
+            };
+            const fn = m.slice(0, 2);
+            const len = parseInt(m.slice(2), 10);
+            return fnMap[fn](len);
+          }
+        ).replace(
+          /^(.*?)(t{8,})(.*)$/g,
+          (_m, p1, p2) => {
+            return suid.substring(p1.length, p1.length + p2.length);
+          }
+        ) : suid;
+        if (stamp.length === 8) {
+          return new Date(parseInt(stamp, 16) * 1e3);
+        }
         if (stamp.length < 10) {
           throw new Error("Stamp length invalid");
         }
-        const rndIdx = parseInt(stamp.substr(stamp.length - 1, 1), 16);
-        return new Date(parseInt(stamp.substr(rndIdx, 8), 16) * 1e3);
-      };
+        const rndIdx = parseInt(stamp.substring(stamp.length - 1), 16);
+        return new Date(parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
+      });
+      /**
+       * Set the counter to a specific value.
+       */
+      __publicField(this, "setCounter", (counter) => {
+        this.counter = counter;
+      });
       const options = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), argOptions);
       this.counter = 0;
       this.debug = false;
@@ -11149,21 +12021,40 @@ var ShortUniqueId = (() => {
       const {
         dictionary,
         shuffle,
-        length
+        length,
+        counter
       } = options;
       this.uuidLength = length;
       this.setDictionary(dictionary, shuffle);
+      this.setCounter(counter);
       this.debug = options.debug;
       this.log(this.dict);
-      this.log(`Generator instantiated with Dictionary Size ${this.dictLength}`);
-      return new Proxy(this, {
-        apply: (target, that, args) => this.randomUUID(...args)
-      });
+      this.log(
+        `Generator instantiated with Dictionary Size ${this.dictLength} and counter set to ${this.counter}`
+      );
+      this.log = this.log.bind(this);
+      this.setDictionary = this.setDictionary.bind(this);
+      this.setCounter = this.setCounter.bind(this);
+      this.seq = this.seq.bind(this);
+      this.sequentialUUID = this.sequentialUUID.bind(this);
+      this.rnd = this.rnd.bind(this);
+      this.randomUUID = this.randomUUID.bind(this);
+      this.fmt = this.fmt.bind(this);
+      this.formattedUUID = this.formattedUUID.bind(this);
+      this.availableUUIDs = this.availableUUIDs.bind(this);
+      this.approxMaxBeforeCollision = this.approxMaxBeforeCollision.bind(this);
+      this.collisionProbability = this.collisionProbability.bind(this);
+      this.uniqueness = this.uniqueness.bind(this);
+      this.getVersion = this.getVersion.bind(this);
+      this.stamp = this.stamp.bind(this);
+      this.parseStamp = this.parseStamp.bind(this);
+      return this;
     }
   };
+  /** @hidden */
+  __publicField(_ShortUniqueId, "default", _ShortUniqueId);
   var ShortUniqueId = _ShortUniqueId;
-  ShortUniqueId.default = _ShortUniqueId;
-  return src_exports;
+  return __toCommonJS(src_exports);
 })();
 //# sourceMappingURL=short-unique-id.js.map
  true&&(module.exports=ShortUniqueId.default),'undefined'!=typeof window&&(ShortUniqueId=ShortUniqueId.default);
@@ -11177,6 +12068,13 @@ var ShortUniqueId = (() => {
 
 /***/ }),
 
+/***/ 21427:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(36762);
+
+/***/ }),
+
 /***/ 28936:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
@@ -12621,7 +13519,6 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var short_unique_id__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(68322);
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(67952);
-// @ts-ignore
 
 
 
@@ -12642,7 +13539,7 @@ const plugin = ({
     visitor: {
       enter(element) {
         // eslint-disable-next-line no-param-reassign
-        element.id = new minim__WEBPACK_IMPORTED_MODULE_1__.StringElement(uuid());
+        element.id = new minim__WEBPACK_IMPORTED_MODULE_1__.StringElement(uuid.randomUUID());
       }
     },
     post() {
@@ -12664,7 +13561,6 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var short_unique_id__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(68322);
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(67952);
-// @ts-ignore
 
 
 
@@ -12688,7 +13584,7 @@ const plugin = ({
       enter(element) {
         if (!predicates.isPrimitiveElement(element)) {
           // eslint-disable-next-line no-param-reassign
-          element.id = new minim__WEBPACK_IMPORTED_MODULE_1__.StringElement(uuid());
+          element.id = new minim__WEBPACK_IMPORTED_MODULE_1__.StringElement(uuid.randomUUID());
         }
       }
     },
@@ -13833,12 +14729,20 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(39723);
+/* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39723);
 /* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13776);
+/* harmony import */ var _babel_runtime_corejs3_core_js_aggregate_error__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(21427);
+var _globalThis$Aggregate;
+
 
+// @ts-ignore
 
+const AggregateError = (_globalThis$Aggregate = globalThis.AggregateError) !== null && _globalThis$Aggregate !== void 0 ? _globalThis$Aggregate : _babel_runtime_corejs3_core_js_aggregate_error__WEBPACK_IMPORTED_MODULE_1__;
+/**
+ * ApiDOMAggregateError is using polyfill of AggregateError from core-js-pure
+ * in environments which don't support global AggregateError symbol.
+ */
 class ApiDOMAggregateError extends AggregateError {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(errors, message, options) {
     super(errors, message, options);
     this.name = this.constructor.name;
@@ -13855,7 +14759,7 @@ class ApiDOMAggregateError extends AggregateError {
      * This needs to stay here until our minimum supported version of Node.js is >= 16.9.0.
      * Node.js is >= 16.9.0 supports error causes natively.
      */
-    if ((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_1__["default"])(options) && (0,ramda__WEBPACK_IMPORTED_MODULE_0__.hasIn)('cause', options) && !(0,ramda__WEBPACK_IMPORTED_MODULE_0__.hasIn)('cause', this)) {
+    if ((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_2__["default"])(options) && (0,ramda__WEBPACK_IMPORTED_MODULE_0__.hasIn)('cause', options) && !(0,ramda__WEBPACK_IMPORTED_MODULE_0__.hasIn)('cause', this)) {
       const {
         cause
       } = options;