@dbmx/toasts 0.0.46 → 0.0.48

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/dissoc.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var _curry2$1 = require('./internal/_curry2.cjs');
+var dissocPath$1 = require('./dissocPath.cjs');
+
+var _curry2 = _curry2$1._curry2_1;
+var dissocPath = dissocPath$1.dissocPath_1;
+
+/**
+ * Returns a new object that does not contain a `prop` property.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Object
+ * @sig String -> {k: v} -> {k: v}
+ * @param {String} prop The name of the property to dissociate
+ * @param {Object} obj The object to clone
+ * @return {Object} A new object equivalent to the original but without the specified property
+ * @see R.assoc, R.omit
+ * @example
+ *
+ *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
+ */
+
+var dissoc = /*#__PURE__*/
+_curry2(function dissoc(prop, obj) {
+  return dissocPath([prop], obj);
+});
+var dissoc$1 = dissoc;
+var dissoc_1 = dissoc$1;
+
+exports.dissoc_1 = dissoc_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/dissocPath.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+var _curry2$1 = require('./internal/_curry2.cjs');
+var _dissoc$1 = require('./internal/_dissoc.cjs');
+var _isInteger$1 = require('./internal/_isInteger.cjs');
+var _isArray$1 = require('./internal/_isArray.cjs');
+var assoc$1 = require('./assoc.cjs');
+
+var _curry2 = _curry2$1._curry2_1;
+var _dissoc = _dissoc$1._dissoc_1;
+var _isInteger = _isInteger$1._isInteger_1;
+var _isArray = _isArray$1._isArray_1;
+var assoc = assoc$1.assoc_1;
+
+/**
+ * Makes a shallow clone of an object. Note that this copies and flattens
+ * prototype properties onto the new object as well. All non-primitive
+ * properties are copied by reference.
+ *
+ * @private
+ * @param {String|Integer} prop The prop operating
+ * @param {Object|Array} obj The object to clone
+ * @return {Object|Array} A new object equivalent to the original.
+ */
+
+function _shallowCloneObject(prop, obj) {
+  if (_isInteger(prop) && _isArray(obj)) {
+    return [].concat(obj);
+  }
+  var result = {};
+  for (var p in obj) {
+    result[p] = obj[p];
+  }
+  return result;
+}
+/**
+ * Makes a shallow clone of an object, omitting the property at the given path.
+ * Note that this copies and flattens prototype properties onto the new object
+ * as well. All non-primitive properties are copied by reference.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.11.0
+ * @category Object
+ * @typedefn Idx = String | Int | Symbol
+ * @sig [Idx] -> {k: v} -> {k: v}
+ * @param {Array} path The path to the value to omit
+ * @param {Object} obj The object to clone
+ * @return {Object} A new object without the property at path
+ * @see R.assocPath
+ * @example
+ *
+ *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
+ */
+
+var dissocPath = /*#__PURE__*/
+_curry2(function dissocPath(path, obj) {
+  if (obj == null) {
+    return obj;
+  }
+  switch (path.length) {
+    case 0:
+      return obj;
+    case 1:
+      return _dissoc(path[0], obj);
+    default:
+      var head = path[0];
+      var tail = Array.prototype.slice.call(path, 1);
+      if (obj[head] == null) {
+        return _shallowCloneObject(head, obj);
+      } else {
+        return assoc(head, dissocPath(tail, obj[head]), obj);
+      }
+  }
+});
+var dissocPath$1 = dissocPath;
+var dissocPath_1 = dissocPath$1;
+
+exports.dissocPath_1 = dissocPath_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/equals.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var _curry2$1 = require('./internal/_curry2.cjs');
+var _equals$1 = require('./internal/_equals.cjs');
+
+var _curry2 = _curry2$1._curry2_1;
+var _equals = _equals$1._equals_1;
+
+/**
+ * Returns `true` if its arguments are equivalent, `false` otherwise. Handles
+ * cyclical data structures.
+ *
+ * Dispatches symmetrically to the `equals` methods of both arguments, if
+ * present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category Relation
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @example
+ *
+ *      R.equals(1, 1); //=> true
+ *      R.equals(1, '1'); //=> false
+ *      R.equals([1, 2, 3], [1, 2, 3]); //=> true
+ *
+ *      const a = {}; a.v = a;
+ *      const b = {}; b.v = b;
+ *      R.equals(a, b); //=> true
+ */
+
+var equals = /*#__PURE__*/
+_curry2(function equals(a, b) {
+  return _equals(a, b, [], []);
+});
+var equals$1 = equals;
+var equals_1 = equals$1;
+
+exports.equals_1 = equals_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/filter.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var _arrayReduce$1 = require('./internal/_arrayReduce.cjs');
+var _curry2$1 = require('./internal/_curry2.cjs');
+var _dispatchable$1 = require('./internal/_dispatchable.cjs');
+var _filter$1 = require('./internal/_filter.cjs');
+var _isObject$1 = require('./internal/_isObject.cjs');
+var _xfilter$1 = require('./internal/_xfilter.cjs');
+var keys$1 = require('./keys.cjs');
+
+var _arrayReduce = _arrayReduce$1._arrayReduce_1;
+var _curry2 = _curry2$1._curry2_1;
+var _dispatchable = _dispatchable$1._dispatchable_1;
+var _filter = _filter$1._filter_1;
+var _isObject = _isObject$1._isObject_1;
+var _xfilter = _xfilter$1._xfilter_1;
+var keys = keys$1.keys_1;
+
+/**
+ * Takes a predicate and a `Filterable`, and returns a new filterable of the
+ * same type containing the members of the given filterable which satisfy the
+ * given predicate. Filterable objects include plain objects or any object
+ * that has a filter method such as `Array`.
+ *
+ * Dispatches to the `filter` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @category Object
+ * @sig Filterable f => (a -> Boolean) -> f a -> f a
+ * @param {Function} pred
+ * @param {Array} filterable
+ * @return {Array} Filterable
+ * @see R.reject, R.transduce, R.addIndex
+ * @example
+ *
+ *      const isEven = n => n % 2 === 0;
+ *
+ *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
+ *
+ *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
+ */
+
+var filter = /*#__PURE__*/
+_curry2( /*#__PURE__*/
+_dispatchable(['fantasy-land/filter', 'filter'], _xfilter, function (pred, filterable) {
+  return _isObject(filterable) ? _arrayReduce(function (acc, key) {
+    if (pred(filterable[key])) {
+      acc[key] = filterable[key];
+    }
+    return acc;
+  }, {}, keys(filterable)) :
+  // else
+  _filter(pred, filterable);
+}));
+var filter$1 = filter;
+var filter_1 = filter$1;
+
+exports.filter_1 = filter_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/forEach.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var _checkForMethod$1 = require('./internal/_checkForMethod.cjs');
+var _curry2$1 = require('./internal/_curry2.cjs');
+
+var _checkForMethod = _checkForMethod$1._checkForMethod_1;
+var _curry2 = _curry2$1._curry2_1;
+
+/**
+ * Iterate over an input `list`, calling a provided function `fn` for each
+ * element in the list.
+ *
+ * `fn` receives one argument: *(value)*.
+ *
+ * Note: `R.forEach` does not skip deleted or unassigned indices (sparse
+ * arrays), unlike the native `Array.prototype.forEach` method. For more
+ * details on this behavior, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description
+ *
+ * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns
+ * the original array. In some libraries this function is named `each`.
+ *
+ * Dispatches to the `forEach` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig (a -> *) -> [a] -> [a]
+ * @param {Function} fn The function to invoke. Receives one argument, `value`.
+ * @param {Array} list The list to iterate over.
+ * @return {Array} The original list.
+ * @see R.addIndex
+ * @example
+ *
+ *      const printXPlusFive = x => console.log(x + 5);
+ *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
+ *      // logs 6
+ *      // logs 7
+ *      // logs 8
+ * @symb R.forEach(f, [a, b, c]) = [a, b, c]
+ */
+
+var forEach = /*#__PURE__*/
+_curry2( /*#__PURE__*/
+_checkForMethod('forEach', function forEach(fn, list) {
+  var len = list.length;
+  var idx = 0;
+  while (idx < len) {
+    fn(list[idx]);
+    idx += 1;
+  }
+  return list;
+}));
+var forEach$1 = forEach;
+var forEach_1 = forEach$1;
+
+exports.forEach_1 = forEach_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/node_modules/ramda/es/identity.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var _curry1$1 = require('./internal/_curry1.cjs');
+var _identity$1 = require('./internal/_identity.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var _identity = _identity$1._identity_1;
+
+/**
+ * A function that does nothing but return the parameter supplied to it. Good
+ * as a default or placeholder function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig a -> a
+ * @param {*} x The value to return.
+ * @return {*} The input value, `x`.
+ * @example
+ *
+ *      R.identity(1); //=> 1
+ *
+ *      const obj = {};
+ *      R.identity(obj) === obj; //=> true
+ * @symb R.identity(a) = a
+ */
+
+var identity = /*#__PURE__*/
+_curry1(_identity);
+var identity$1 = identity;
+var identity_1 = identity$1;
+
+exports.identity_1 = identity_1;

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

@@ -0,0 +1,56 @@
+'use strict';
+
+function _arity(n, fn) {
+  /* eslint-disable no-unused-vars */
+  switch (n) {
+    case 0:
+      return function () {
+        return fn.apply(this, arguments);
+      };
+    case 1:
+      return function (a0) {
+        return fn.apply(this, arguments);
+      };
+    case 2:
+      return function (a0, a1) {
+        return fn.apply(this, arguments);
+      };
+    case 3:
+      return function (a0, a1, a2) {
+        return fn.apply(this, arguments);
+      };
+    case 4:
+      return function (a0, a1, a2, a3) {
+        return fn.apply(this, arguments);
+      };
+    case 5:
+      return function (a0, a1, a2, a3, a4) {
+        return fn.apply(this, arguments);
+      };
+    case 6:
+      return function (a0, a1, a2, a3, a4, a5) {
+        return fn.apply(this, arguments);
+      };
+    case 7:
+      return function (a0, a1, a2, a3, a4, a5, a6) {
+        return fn.apply(this, arguments);
+      };
+    case 8:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7) {
+        return fn.apply(this, arguments);
+      };
+    case 9:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+        return fn.apply(this, arguments);
+      };
+    case 10:
+      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        return fn.apply(this, arguments);
+      };
+    default:
+      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+  }
+}
+var _arity_1 = _arity;
+
+exports._arity_1 = _arity_1;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+function _arrayFromIterator(iter) {
+  var list = [];
+  var next;
+  while (!(next = iter.next()).done) {
+    list.push(next.value);
+  }
+  return list;
+}
+var _arrayFromIterator_1 = _arrayFromIterator;
+
+exports._arrayFromIterator_1 = _arrayFromIterator_1;

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

@@ -0,0 +1,14 @@
+'use strict';
+
+function _arrayReduce(reducer, acc, list) {
+  var index = 0;
+  var length = list.length;
+  while (index < length) {
+    acc = reducer(acc, list[index]);
+    index += 1;
+  }
+  return acc;
+}
+var _arrayReduce_1 = _arrayReduce;
+
+exports._arrayReduce_1 = _arrayReduce_1;

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

@@ -0,0 +1,37 @@
+'use strict';
+
+var _isArray$1 = require('./_isArray.cjs');
+var _isInteger$1 = require('./_isInteger.cjs');
+
+var _isArray = _isArray$1._isArray_1;
+var _isInteger = _isInteger$1._isInteger_1;
+
+/**
+ * Makes a shallow clone of an object, setting or overriding the specified
+ * property with the given value. Note that this copies and flattens prototype
+ * properties onto the new object as well. All non-primitive properties are
+ * copied by reference.
+ *
+ * @private
+ * @param {String|Number} prop The property name to set
+ * @param {*} val The new value
+ * @param {Object|Array} obj The object to clone
+ * @return {Object|Array} A new object equivalent to the original except for the changed property.
+ */
+
+function _assoc(prop, val, obj) {
+  if (_isInteger(prop) && _isArray(obj)) {
+    var arr = [].concat(obj);
+    arr[prop] = val;
+    return arr;
+  }
+  var result = {};
+  for (var p in obj) {
+    result[p] = obj[p];
+  }
+  result[prop] = val;
+  return result;
+}
+var _assoc_1 = _assoc;
+
+exports._assoc_1 = _assoc_1;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+var _isArray$1 = require('./_isArray.cjs');
+
+var _isArray = _isArray$1._isArray_1;
+
+/**
+ * This checks whether a function has a [methodname] function. If it isn't an
+ * array it will execute that function otherwise it will default to the ramda
+ * implementation.
+ *
+ * @private
+ * @param {Function} fn ramda implementation
+ * @param {String} methodname property to check for a custom implementation
+ * @return {Object} Whatever the return value of the method is.
+ */
+
+function _checkForMethod(methodname, fn) {
+  return function () {
+    var length = arguments.length;
+    if (length === 0) {
+      return fn();
+    }
+    var obj = arguments[length - 1];
+    return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
+  };
+}
+var _checkForMethod_1 = _checkForMethod;
+
+exports._checkForMethod_1 = _checkForMethod_1;

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

@@ -0,0 +1,10 @@
+'use strict';
+
+function _complement(f) {
+  return function () {
+    return !f.apply(this, arguments);
+  };
+}
+var _complement_1 = _complement;
+
+exports._complement_1 = _complement_1;

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var _isArrayLike$1 = require('./_isArrayLike.cjs');
+
+var _isArrayLike = _isArrayLike$1._isArrayLike_1;
+var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
+function _createReduce(arrayReduce, methodReduce, iterableReduce) {
+  return function _reduce(xf, acc, list) {
+    if (_isArrayLike(list)) {
+      return arrayReduce(xf, acc, list);
+    }
+    if (list == null) {
+      return acc;
+    }
+    if (typeof list['fantasy-land/reduce'] === 'function') {
+      return methodReduce(xf, acc, list, 'fantasy-land/reduce');
+    }
+    if (list[symIterator] != null) {
+      return iterableReduce(xf, acc, list[symIterator]());
+    }
+    if (typeof list.next === 'function') {
+      return iterableReduce(xf, acc, list);
+    }
+    if (typeof list.reduce === 'function') {
+      return methodReduce(xf, acc, list, 'reduce');
+    }
+    throw new TypeError('reduce: list must be array or iterable');
+  };
+}
+var _createReduce_1 = _createReduce;
+
+exports._createReduce_1 = _createReduce_1;

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;