@dbmx/toasts 0.0.47 → 0.0.49

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/bind.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var _arity = require('./internal/_arity.cjs');
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * Creates a function that is bound to a context.
+ * Note: `R.bind` does not provide the additional argument-binding capabilities of
+ * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Function
+ * @category Object
+ * @sig (* -> *) -> {*} -> (* -> *)
+ * @param {Function} fn The function to bind to context
+ * @param {Object} thisObj The context to bind `fn` to
+ * @return {Function} A function that will execute in the context of `thisObj`.
+ * @see R.partial
+ * @example
+ *
+ *      const log = R.bind(console.log, console);
+ *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
+ *      // logs {a: 2}
+ * @symb R.bind(f, o)(a, b) = f.call(o, a, b)
+ */
+
+var bind =
+/*#__PURE__*/
+_curry2(function bind(fn, thisObj) {
+  return _arity(fn.length, function () {
+    return fn.apply(thisObj, arguments);
+  });
+});
+
+var bind$1 = bind;
+
+module.exports = bind$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/compose.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var pipe = require('./pipe.cjs');
+var reverse = require('./reverse.cjs');
+
+/**
+ * Performs right-to-left function composition. The last argument may have
+ * any arity; the remaining arguments must be unary.
+ *
+ * **Note:** The result of compose is not automatically curried.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
+ * @param {...Function} ...functions The functions to compose
+ * @return {Function}
+ * @see R.pipe
+ * @example
+ *
+ *      const classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
+ *      const yellGreeting = R.compose(R.toUpper, classyGreeting);
+ *      yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
+ *
+ *      R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7
+ *
+ * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))
+ * @symb R.compose(f, g, h)(a)(b) = f(g(h(a)))(b)
+ */
+
+function compose() {
+  if (arguments.length === 0) {
+    throw new Error('compose requires at least one argument');
+  }
+
+  return pipe.apply(this, reverse(arguments));
+}
+
+module.exports = compose;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/curryN.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var _arity = require('./internal/_arity.cjs');
+var _curry1 = require('./internal/_curry1.cjs');
+var _curry2 = require('./internal/_curry2.cjs');
+var _curryN = require('./internal/_curryN.cjs');
+
+/**
+ * Returns a curried equivalent of the provided function, with the specified
+ * arity. The curried function has two unusual capabilities. First, its
+ * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
+ * following are equivalent:
+ *
+ *   - `g(1)(2)(3)`
+ *   - `g(1)(2, 3)`
+ *   - `g(1, 2)(3)`
+ *   - `g(1, 2, 3)`
+ *
+ * Secondly, the special placeholder value [`R.__`](#__) may be used to specify
+ * "gaps", allowing partial application of any combination of arguments,
+ * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),
+ * the following are equivalent:
+ *
+ *   - `g(1, 2, 3)`
+ *   - `g(_, 2, 3)(1)`
+ *   - `g(_, _, 3)(1)(2)`
+ *   - `g(_, _, 3)(1, 2)`
+ *   - `g(_, 2)(1)(3)`
+ *   - `g(_, 2)(1, 3)`
+ *   - `g(_, 2)(_, 3)(1)`
+ *
+ * @func
+ * @memberOf R
+ * @since v0.5.0
+ * @category Function
+ * @sig Number -> (* -> a) -> (* -> a)
+ * @param {Number} length The arity for the returned function.
+ * @param {Function} fn The function to curry.
+ * @return {Function} A new, curried function.
+ * @see R.curry
+ * @example
+ *
+ *      const sumArgs = (...args) => R.sum(args);
+ *
+ *      const curriedAddFourNumbers = R.curryN(4, sumArgs);
+ *      const f = curriedAddFourNumbers(1, 2);
+ *      const g = f(3);
+ *      g(4); //=> 10
+ */
+
+var curryN =
+/*#__PURE__*/
+_curry2(function curryN(length, fn) {
+  if (length === 1) {
+    return _curry1(fn);
+  }
+
+  return _arity(length, _curryN(length, [], fn));
+});
+
+var curryN$1 = curryN;
+
+module.exports = curryN$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/ramda/es/defaultTo.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * Returns the second argument if it is not `null`, `undefined` or `NaN`;
+ * otherwise the first argument is returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Logic
+ * @sig a -> b -> a | b
+ * @param {a} default The default value.
+ * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.
+ * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value
+ * @example
+ *
+ *      const defaultTo42 = R.defaultTo(42);
+ *
+ *      defaultTo42(null);  //=> 42
+ *      defaultTo42(undefined);  //=> 42
+ *      defaultTo42(false);  //=> false
+ *      defaultTo42('Ramda');  //=> 'Ramda'
+ *      // parseInt('string') results in NaN
+ *      defaultTo42(parseInt('string')); //=> 42
+ */
+
+var defaultTo =
+/*#__PURE__*/
+_curry2(function defaultTo(d, v) {
+  return v == null || v !== v ? d : v;
+});
+
+var defaultTo$1 = defaultTo;
+
+module.exports = defaultTo$1;

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

@@ -0,0 +1,59 @@
+'use strict';
+
+var _checkForMethod = require('./internal/_checkForMethod.cjs');
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * 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;
+
+module.exports = forEach$1;

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var _curry1 = require('./internal/_curry1.cjs');
+var _identity = require('./internal/_identity.cjs');
+
+/**
+ * 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;
+
+module.exports = identity$1;

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

@@ -0,0 +1,66 @@
+'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');
+  }
+}
+
+module.exports = _arity;

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

@@ -0,0 +1,15 @@
+'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;
+}
+
+module.exports = _arrayReduce;

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

@@ -0,0 +1,29 @@
+'use strict';
+
+var _isArray = require('./_isArray.cjs');
+
+/**
+ * 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));
+  };
+}
+
+module.exports = _checkForMethod;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+var _isArrayLike = require('./_isArrayLike.cjs');
+
+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');
+  };
+}
+
+module.exports = _createReduce;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * 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);
+    }
+  };
+}
+
+module.exports = _curry1;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+var _curry1 = require('./_curry1.cjs');
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * 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);
+    }
+  };
+}
+
+module.exports = _curry2;

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

@@ -0,0 +1,54 @@
+'use strict';
+
+var _curry1 = require('./_curry1.cjs');
+var _curry2 = require('./_curry2.cjs');
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * 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);
+    }
+  };
+}
+
+module.exports = _curry3;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+var _arity = require('./_arity.cjs');
+var _isPlaceholder = require('./_isPlaceholder.cjs');
+
+/**
+ * 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));
+  };
+}
+
+module.exports = _curryN;

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

@@ -0,0 +1,51 @@
+'use strict';
+
+var _isArray = require('./_isArray.cjs');
+var _isTransformer = require('./_isTransformer.cjs');
+
+/**
+ * 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);
+  };
+}
+
+module.exports = _dispatchable;

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

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

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

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var _has = require('./_has.cjs');
+
+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;
+
+module.exports = _isArguments$1;