@dbmx/toasts 0.0.122 → 0.0.123

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_curry1.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var _isPlaceholder$1 = require('./_isPlaceholder.cjs');
+
+var _isPlaceholder = _isPlaceholder$1._isPlaceholder_1;
+
+/**
+ * Optimized internal one-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry1(fn) {
+  return function f1(a) {
+    if (arguments.length === 0 || _isPlaceholder(a)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}
+var _curry1_1 = _curry1;
+
+exports._curry1_1 = _curry1_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_curry2.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var _curry1$1 = require('./_curry1.cjs');
+var _isPlaceholder$1 = require('./_isPlaceholder.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var _isPlaceholder = _isPlaceholder$1._isPlaceholder_1;
+
+/**
+ * Optimized internal two-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry2(fn) {
+  return function f2(a, b) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+      case 1:
+        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {
+          return fn(a, _b);
+        });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {
+          return fn(_a, b);
+        }) : _isPlaceholder(b) ? _curry1(function (_b) {
+          return fn(a, _b);
+        }) : fn(a, b);
+    }
+  };
+}
+var _curry2_1 = _curry2;
+
+exports._curry2_1 = _curry2_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_curry3.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var _curry1$1 = require('./_curry1.cjs');
+var _curry2$1 = require('./_curry2.cjs');
+var _isPlaceholder$1 = require('./_isPlaceholder.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var _curry2 = _curry2$1._curry2_1;
+var _isPlaceholder = _isPlaceholder$1._isPlaceholder_1;
+
+/**
+ * Optimized internal three-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry3(fn) {
+  return function f3(a, b, c) {
+    switch (arguments.length) {
+      case 0:
+        return f3;
+      case 1:
+        return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {
+          return fn(a, _b, _c);
+        });
+      case 2:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {
+          return fn(_a, b, _c);
+        }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {
+          return fn(a, _b, _c);
+        }) : _curry1(function (_c) {
+          return fn(a, b, _c);
+        });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {
+          return fn(_a, _b, c);
+        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {
+          return fn(_a, b, _c);
+        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {
+          return fn(a, _b, _c);
+        }) : _isPlaceholder(a) ? _curry1(function (_a) {
+          return fn(_a, b, c);
+        }) : _isPlaceholder(b) ? _curry1(function (_b) {
+          return fn(a, _b, c);
+        }) : _isPlaceholder(c) ? _curry1(function (_c) {
+          return fn(a, b, _c);
+        }) : fn(a, b, c);
+    }
+  };
+}
+var _curry3_1 = _curry3;
+
+exports._curry3_1 = _curry3_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_curryN.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var _arity$1 = require('./_arity.cjs');
+var _isPlaceholder$1 = require('./_isPlaceholder.cjs');
+
+var _arity = _arity$1._arity_1;
+var _isPlaceholder = _isPlaceholder$1._isPlaceholder_1;
+
+/**
+ * Internal curryN function.
+ *
+ * @private
+ * @category Function
+ * @param {Number} length The arity of the curried function.
+ * @param {Array} received An array of arguments received thus far.
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curryN(length, received, fn) {
+  return function () {
+    var combined = [];
+    var argsIdx = 0;
+    var left = length;
+    var combinedIdx = 0;
+    var hasPlaceholder = false;
+    while (combinedIdx < received.length || argsIdx < arguments.length) {
+      var result;
+      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
+        result = received[combinedIdx];
+      } else {
+        result = arguments[argsIdx];
+        argsIdx += 1;
+      }
+      combined[combinedIdx] = result;
+      if (!_isPlaceholder(result)) {
+        left -= 1;
+      } else {
+        hasPlaceholder = true;
+      }
+      combinedIdx += 1;
+    }
+    return !hasPlaceholder && left <= 0 ? fn.apply(this, combined) : _arity(Math.max(0, left), _curryN(length, combined, fn));
+  };
+}
+var _curryN_1 = _curryN;
+
+exports._curryN_1 = _curryN_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_dispatchable.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var _isArray$1 = require('./_isArray.cjs');
+var _isTransformer$1 = require('./_isTransformer.cjs');
+
+var _isArray = _isArray$1._isArray_1;
+var _isTransformer = _isTransformer$1._isTransformer_1;
+
+/**
+ * Returns a function that dispatches with different strategies based on the
+ * object in list position (last argument). If it is an array, executes [fn].
+ * Otherwise, if it has a function with one of the given method names, it will
+ * execute that function (functor case). Otherwise, if it is a transformer,
+ * uses transducer created by [transducerCreator] to return a new transformer
+ * (transducer case).
+ * Otherwise, it will default to executing [fn].
+ *
+ * @private
+ * @param {Array} methodNames properties to check for a custom implementation
+ * @param {Function} transducerCreator transducer factory if object is transformer
+ * @param {Function} fn default ramda implementation
+ * @return {Function} A function that dispatches on object in list position
+ */
+
+function _dispatchable(methodNames, transducerCreator, fn) {
+  return function () {
+    if (arguments.length === 0) {
+      return fn();
+    }
+    var obj = arguments[arguments.length - 1];
+    if (!_isArray(obj)) {
+      var idx = 0;
+      while (idx < methodNames.length) {
+        if (typeof obj[methodNames[idx]] === 'function') {
+          return obj[methodNames[idx]].apply(obj, Array.prototype.slice.call(arguments, 0, -1));
+        }
+        idx += 1;
+      }
+      if (_isTransformer(obj)) {
+        var transducer = transducerCreator.apply(null, Array.prototype.slice.call(arguments, 0, -1));
+        return transducer(obj);
+      }
+    }
+    return fn.apply(this, arguments);
+  };
+}
+var _dispatchable_1 = _dispatchable;
+
+exports._dispatchable_1 = _dispatchable_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_dissoc.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var _isInteger$1 = require('./_isInteger.cjs');
+var _isArray$1 = require('./_isArray.cjs');
+var remove$1 = require('../remove.cjs');
+
+var _isInteger = _isInteger$1._isInteger_1;
+var _isArray = _isArray$1._isArray_1;
+var remove = remove$1.remove_1;
+
+/**
+ * Returns a new object that does not contain a `prop` property.
+ *
+ * @private
+ * @param {String|Number} prop The name of the property to dissociate
+ * @param {Object|Array} obj The object to clone
+ * @return {Object} A new object equivalent to the original but without the specified property
+ */
+
+function _dissoc(prop, obj) {
+  if (obj == null) {
+    return obj;
+  }
+  if (_isInteger(prop) && _isArray(obj)) {
+    return remove(prop, 1, obj);
+  }
+  var result = {};
+  for (var p in obj) {
+    result[p] = obj[p];
+  }
+  delete result[prop];
+  return result;
+}
+var _dissoc_1 = _dissoc;
+
+exports._dissoc_1 = _dissoc_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_equals.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+var _arrayFromIterator$1 = require('./_arrayFromIterator.cjs');
+var _includesWith$1 = require('./_includesWith.cjs');
+var _functionName$1 = require('./_functionName.cjs');
+var _has$1 = require('./_has.cjs');
+var _objectIs$1 = require('./_objectIs.cjs');
+var keys$1 = require('../keys.cjs');
+var type$1 = require('../type.cjs');
+
+var _arrayFromIterator = _arrayFromIterator$1._arrayFromIterator_1;
+var _includesWith = _includesWith$1._includesWith_1;
+var _functionName = _functionName$1._functionName_1;
+var _has = _has$1._has_1;
+var _objectIs = _objectIs$1._objectIs_1;
+var keys = keys$1.keys_1;
+var type = type$1.type_1;
+
+/**
+ * private _uniqContentEquals function.
+ * That function is checking equality of 2 iterator contents with 2 assumptions
+ * - iterators lengths are the same
+ * - iterators values are unique
+ *
+ * false-positive result will be returned for comparison of, e.g.
+ * - [1,2,3] and [1,2,3,4]
+ * - [1,1,1] and [1,2,3]
+ * */
+
+function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
+  var a = _arrayFromIterator(aIterator);
+  var b = _arrayFromIterator(bIterator);
+  function eq(_a, _b) {
+    return _equals(_a, _b, stackA.slice(), stackB.slice());
+  } // if *a* array contains any element that is not included in *b*
+
+  return !_includesWith(function (b, aItem) {
+    return !_includesWith(eq, aItem, b);
+  }, b, a);
+}
+function _equals(a, b, stackA, stackB) {
+  if (_objectIs(a, b)) {
+    return true;
+  }
+  var typeA = type(a);
+  if (typeA !== type(b)) {
+    return false;
+  }
+  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {
+    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);
+  }
+  if (typeof a.equals === 'function' || typeof b.equals === 'function') {
+    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);
+  }
+  switch (typeA) {
+    case 'Arguments':
+    case 'Array':
+    case 'Object':
+      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {
+        return a === b;
+      }
+      break;
+    case 'Boolean':
+    case 'Number':
+    case 'String':
+      if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {
+        return false;
+      }
+      break;
+    case 'Date':
+      if (!_objectIs(a.valueOf(), b.valueOf())) {
+        return false;
+      }
+      break;
+    case 'Error':
+      return a.name === b.name && a.message === b.message;
+    case 'RegExp':
+      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {
+        return false;
+      }
+      break;
+  }
+  var idx = stackA.length - 1;
+  while (idx >= 0) {
+    if (stackA[idx] === a) {
+      return stackB[idx] === b;
+    }
+    idx -= 1;
+  }
+  switch (typeA) {
+    case 'Map':
+      if (a.size !== b.size) {
+        return false;
+      }
+      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));
+    case 'Set':
+      if (a.size !== b.size) {
+        return false;
+      }
+      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));
+    case 'Arguments':
+    case 'Array':
+    case 'Object':
+    case 'Boolean':
+    case 'Number':
+    case 'String':
+    case 'Date':
+    case 'Error':
+    case 'RegExp':
+    case 'Int8Array':
+    case 'Uint8Array':
+    case 'Uint8ClampedArray':
+    case 'Int16Array':
+    case 'Uint16Array':
+    case 'Int32Array':
+    case 'Uint32Array':
+    case 'Float32Array':
+    case 'Float64Array':
+    case 'ArrayBuffer':
+      break;
+    default:
+      // Values of other types are only equal if identical.
+      return false;
+  }
+  var keysA = keys(a);
+  if (keysA.length !== keys(b).length) {
+    return false;
+  }
+  var extendedStackA = stackA.concat([a]);
+  var extendedStackB = stackB.concat([b]);
+  idx = keysA.length - 1;
+  while (idx >= 0) {
+    var key = keysA[idx];
+    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {
+      return false;
+    }
+    idx -= 1;
+  }
+  return true;
+}
+var _equals_1 = _equals;
+
+exports._equals_1 = _equals_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_filter.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function _filter(fn, list) {
+  var idx = 0;
+  var len = list.length;
+  var result = [];
+  while (idx < len) {
+    if (fn(list[idx])) {
+      result[result.length] = list[idx];
+    }
+    idx += 1;
+  }
+  return result;
+}
+var _filter_1 = _filter;
+
+exports._filter_1 = _filter_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_functionName.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+function _functionName(f) {
+  // String(x => x) evaluates to "x => x", so the pattern may not match.
+  var match = String(f).match(/^function (\w*)/);
+  return match == null ? '' : match[1];
+}
+var _functionName_1 = _functionName;
+
+exports._functionName_1 = _functionName_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_has.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+function _has(prop, obj) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+var _has_1 = _has;
+
+exports._has_1 = _has_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_identity.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+function _identity(x) {
+  return x;
+}
+var _identity_1 = _identity;
+
+exports._identity_1 = _identity_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_includes.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var _indexOf$1 = require('./_indexOf.cjs');
+
+var _indexOf = _indexOf$1._indexOf_1;
+function _includes(a, list) {
+  return _indexOf(list, a, 0) >= 0;
+}
+var _includes_1 = _includes;
+
+exports._includes_1 = _includes_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_includesWith.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function _includesWith(pred, x, list) {
+  var idx = 0;
+  var len = list.length;
+  while (idx < len) {
+    if (pred(x, list[idx])) {
+      return true;
+    }
+    idx += 1;
+  }
+  return false;
+}
+var _includesWith_1 = _includesWith;
+
+exports._includesWith_1 = _includesWith_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_indexOf.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+var equals$1 = require('../equals.cjs');
+
+var equals = equals$1.equals_1;
+function _indexOf(list, a, idx) {
+  var inf, item; // Array.prototype.indexOf doesn't exist below IE9
+
+  if (typeof list.indexOf === 'function') {
+    switch (typeof a) {
+      case 'number':
+        if (a === 0) {
+          // manually crawl the list to distinguish between +0 and -0
+          inf = 1 / a;
+          while (idx < list.length) {
+            item = list[idx];
+            if (item === 0 && 1 / item === inf) {
+              return idx;
+            }
+            idx += 1;
+          }
+          return -1;
+        } else if (a !== a) {
+          // NaN
+          while (idx < list.length) {
+            item = list[idx];
+            if (typeof item === 'number' && item !== item) {
+              return idx;
+            }
+            idx += 1;
+          }
+          return -1;
+        } // non-zero numbers can utilise Set
+
+        return list.indexOf(a, idx);
+      // all these types can utilise Set
+
+      case 'string':
+      case 'boolean':
+      case 'function':
+      case 'undefined':
+        return list.indexOf(a, idx);
+      case 'object':
+        if (a === null) {
+          // null can utilise Set
+          return list.indexOf(a, idx);
+        }
+    }
+  } // anything else not covered above, defer to R.equals
+
+  while (idx < list.length) {
+    if (equals(list[idx], a)) {
+      return idx;
+    }
+    idx += 1;
+  }
+  return -1;
+}
+var _indexOf_1 = _indexOf;
+
+exports._indexOf_1 = _indexOf_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isArguments.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var _has$1 = require('./_has.cjs');
+
+var _has = _has$1._has_1;
+var toString = Object.prototype.toString;
+var _isArguments = /*#__PURE__*/
+function () {
+  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {
+    return toString.call(x) === '[object Arguments]';
+  } : function _isArguments(x) {
+    return _has('callee', x);
+  };
+}();
+var _isArguments$1 = _isArguments;
+var _isArguments_1 = _isArguments$1;
+
+exports._isArguments_1 = _isArguments_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isArray.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * Tests whether or not an object is an array.
+ *
+ * @private
+ * @param {*} val The object to test.
+ * @return {Boolean} `true` if `val` is an array, `false` otherwise.
+ * @example
+ *
+ *      _isArray([]); //=> true
+ *      _isArray(null); //=> false
+ *      _isArray({}); //=> false
+ */
+var _isArray = Array.isArray || function _isArray(val) {
+  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';
+};
+var _isArray_1 = _isArray;
+
+exports._isArray_1 = _isArray_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isArrayLike.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var _curry1$1 = require('./_curry1.cjs');
+var _isArray$1 = require('./_isArray.cjs');
+var _isString$1 = require('./_isString.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var _isArray = _isArray$1._isArray_1;
+var _isString = _isString$1._isString_1;
+
+/**
+ * Tests whether or not an object is similar to an array.
+ *
+ * @private
+ * @category Type
+ * @category List
+ * @sig * -> Boolean
+ * @param {*} x The object to test.
+ * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.
+ * @example
+ *
+ *      _isArrayLike([]); //=> true
+ *      _isArrayLike(true); //=> false
+ *      _isArrayLike({}); //=> false
+ *      _isArrayLike({length: 10}); //=> false
+ *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
+ *      _isArrayLike({nodeType: 1, length: 1}) // => false
+ */
+
+var _isArrayLike = /*#__PURE__*/
+_curry1(function isArrayLike(x) {
+  if (_isArray(x)) {
+    return true;
+  }
+  if (!x) {
+    return false;
+  }
+  if (typeof x !== 'object') {
+    return false;
+  }
+  if (_isString(x)) {
+    return false;
+  }
+  if (x.length === 0) {
+    return true;
+  }
+  if (x.length > 0) {
+    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
+  }
+  return false;
+});
+var _isArrayLike$1 = _isArrayLike;
+var _isArrayLike_1 = _isArrayLike$1;
+
+exports._isArrayLike_1 = _isArrayLike_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isFunction.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function _isFunction(x) {
+  var type = Object.prototype.toString.call(x);
+  return type === '[object Function]' || type === '[object AsyncFunction]' || type === '[object GeneratorFunction]' || type === '[object AsyncGeneratorFunction]';
+}
+var _isFunction_1 = _isFunction;
+
+exports._isFunction_1 = _isFunction_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isInteger.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Determine if the passed argument is an integer.
+ *
+ * @private
+ * @param {*} n
+ * @category Type
+ * @return {Boolean}
+ */
+var _isInteger = Number.isInteger || function _isInteger(n) {
+  return n << 0 === n;
+};
+var _isInteger_1 = _isInteger;
+
+exports._isInteger_1 = _isInteger_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isObject.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+function _isObject(x) {
+  return Object.prototype.toString.call(x) === '[object Object]';
+}
+var _isObject_1 = _isObject;
+
+exports._isObject_1 = _isObject_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/internal/_isPlaceholder.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+function _isPlaceholder(a) {
+  return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;
+}
+var _isPlaceholder_1 = _isPlaceholder;
+
+exports._isPlaceholder_1 = _isPlaceholder_1;