@dbmx/toasts 0.0.122 → 0.0.123

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

@@ -0,0 +1,35 @@
+'use strict';
+
+var _curry3 = require('./internal/_curry3.cjs');
+var defaultTo = require('./defaultTo.cjs');
+var path = require('./path.cjs');
+
+/**
+ * If the given, non-null object has a value at the given path, returns the
+ * value at that path. Otherwise returns the provided default value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category Object
+ * @typedefn Idx = String | Int | Symbol
+ * @sig a -> [Idx] -> {a} -> a
+ * @param {*} d The default value.
+ * @param {Array} p The path to use.
+ * @param {Object} obj The object to retrieve the nested property from.
+ * @return {*} The data at `path` of the supplied object or the default value.
+ * @example
+ *
+ *      R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
+ *      R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
+ */
+
+var pathOr =
+/*#__PURE__*/
+_curry3(function pathOr(d, p, obj) {
+  return defaultTo(d, path(p, obj));
+});
+
+var pathOr$1 = pathOr;
+
+module.exports = pathOr$1;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+var _curry2 = require('./internal/_curry2.cjs');
+var _isInteger = require('./internal/_isInteger.cjs');
+var nth = require('./nth.cjs');
+
+/**
+ * Retrieves the values at given paths of an object.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.27.1
+ * @category Object
+ * @typedefn Idx = [String | Int | Symbol]
+ * @sig [Idx] -> {a} -> [a | Undefined]
+ * @param {Array} pathsArray The array of paths to be fetched.
+ * @param {Object} obj The object to retrieve the nested properties from.
+ * @return {Array} A list consisting of values at paths specified by "pathsArray".
+ * @see R.path
+ * @example
+ *
+ *      R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]
+ *      R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]
+ */
+
+var paths =
+/*#__PURE__*/
+_curry2(function paths(pathsArray, obj) {
+  return pathsArray.map(function (paths) {
+    var val = obj;
+    var idx = 0;
+    var p;
+
+    while (idx < paths.length) {
+      if (val == null) {
+        return;
+      }
+
+      p = paths[idx];
+      val = _isInteger(p) ? nth(p, val) : val[p];
+      idx += 1;
+    }
+
+    return val;
+  });
+});
+
+var paths$1 = paths;
+
+module.exports = paths$1;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+var _curry2 = require('./internal/_curry2.cjs');
+
+/**
+ * Returns a partial copy of an object containing only the keys specified. If
+ * the key does not exist, the property is ignored.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig [k] -> {k: v} -> {k: v}
+ * @param {Array} names an array of String property names to copy onto a new object
+ * @param {Object} obj The object to copy from
+ * @return {Object} A new object with only properties from `names` on it.
+ * @see R.omit, R.props
+ * @example
+ *
+ *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
+ *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
+ */
+
+var pick =
+/*#__PURE__*/
+_curry2(function pick(names, obj) {
+  var result = {};
+  var idx = 0;
+
+  while (idx < names.length) {
+    if (names[idx] in obj) {
+      result[names[idx]] = obj[names[idx]];
+    }
+
+    idx += 1;
+  }
+
+  return result;
+});
+
+var pick$1 = pick;
+
+module.exports = pick$1;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var _arity = require('./internal/_arity.cjs');
+var _pipe = require('./internal/_pipe.cjs');
+var reduce = require('./reduce.cjs');
+var tail = require('./tail.cjs');
+
+/**
+ * Performs left-to-right function composition. The first argument may have
+ * any arity; the remaining arguments must be unary.
+ *
+ * In some libraries this function is named `sequence`.
+ *
+ * **Note:** The result of pipe is not automatically curried.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
+ * @param {...Function} functions
+ * @return {Function}
+ * @see R.compose
+ * @example
+ *
+ *      const f = R.pipe(Math.pow, R.negate, R.inc);
+ *
+ *      f(3, 4); // -(3^4) + 1
+ * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))
+ * @symb R.pipe(f, g, h)(a)(b) = h(g(f(a)))(b)
+ */
+
+function pipe() {
+  if (arguments.length === 0) {
+    throw new Error('pipe requires at least one argument');
+  }
+
+  return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));
+}
+
+module.exports = pipe;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var _curry2 = require('./internal/_curry2.cjs');
+var _isInteger = require('./internal/_isInteger.cjs');
+var nth = require('./nth.cjs');
+
+/**
+ * Returns a function that when supplied an object returns the indicated
+ * property of that object, if it exists.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @typedefn Idx = String | Int | Symbol
+ * @sig Idx -> {s: a} -> a | Undefined
+ * @param {String|Number} p The property name or array index
+ * @param {Object} obj The object to query
+ * @return {*} The value at `obj.p`.
+ * @see R.path, R.props, R.pluck, R.project, R.nth
+ * @example
+ *
+ *      R.prop('x', {x: 100}); //=> 100
+ *      R.prop('x', {}); //=> undefined
+ *      R.prop(0, [100]); //=> 100
+ *      R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4
+ */
+
+var prop =
+/*#__PURE__*/
+_curry2(function prop(p, obj) {
+  if (obj == null) {
+    return;
+  }
+
+  return _isInteger(p) ? nth(p, obj) : obj[p];
+});
+
+var prop$1 = prop;
+
+module.exports = prop$1;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+var _curry3 = require('./internal/_curry3.cjs');
+var defaultTo = require('./defaultTo.cjs');
+var prop = require('./prop.cjs');
+
+/**
+ * Return the specified property of the given non-null object if the property
+ * is present and it's value is not `null`, `undefined` or `NaN`.
+ *
+ * Otherwise the first argument is returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Object
+ * @sig a -> String -> Object -> a
+ * @param {*} val The default value.
+ * @param {String} p The name of the property to return.
+ * @param {Object} obj The object to query.
+ * @return {*} The value of given property of the supplied object or the default value.
+ * @example
+ *
+ *      const alice = {
+ *        name: 'ALICE',
+ *        age: 101
+ *      };
+ *      const favorite = R.prop('favoriteLibrary');
+ *      const favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');
+ *
+ *      favorite(alice);  //=> undefined
+ *      favoriteWithDefault(alice);  //=> 'Ramda'
+ */
+
+var propOr =
+/*#__PURE__*/
+_curry3(function propOr(val, p, obj) {
+  return defaultTo(val, prop(p, obj));
+});
+
+var propOr$1 = propOr;
+
+module.exports = propOr$1;

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

@@ -0,0 +1,68 @@
+'use strict';
+
+var _curry3 = require('./internal/_curry3.cjs');
+var _xReduce = require('./internal/_xReduce.cjs');
+var _xwrap = require('./internal/_xwrap.cjs');
+
+/**
+ * Returns a single item by iterating through the list, successively calling
+ * the iterator function and passing it an accumulator value and the current
+ * value from the array, and then passing the result to the next call.
+ *
+ * The iterator function receives two values: *(acc, value)*. It may use
+ * [`R.reduced`](#reduced) to shortcut the iteration.
+ *
+ * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function
+ * is *(value, acc)*.
+ *
+ * Note: `R.reduce` does not skip deleted or unassigned indices (sparse
+ * arrays), unlike the native `Array.prototype.reduce` method. For more details
+ * on this behavior, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
+ *
+ * Be cautious of mutating and returning the accumulator. If you reuse it across
+ * invocations, it will continue to accumulate onto the same value. The general
+ * recommendation is to always return a new value. If you can't do so for
+ * performance reasons, then be sure to reinitialize the accumulator on each
+ * invocation.
+ *
+ * Dispatches to the `reduce` method of the third argument, if present. When
+ * doing so, it is up to the user to handle the [`R.reduced`](#reduced)
+ * shortcuting, as this is not implemented by `reduce`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig ((a, b) -> a) -> a -> [b] -> a
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the
+ *        current element from the array.
+ * @param {*} acc The accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @see R.reduced, R.addIndex, R.reduceRight
+ * @example
+ *
+ *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
+ *      //          -               -10
+ *      //         / \              / \
+ *      //        -   4           -6   4
+ *      //       / \              / \
+ *      //      -   3   ==>     -3   3
+ *      //     / \              / \
+ *      //    -   2           -1   2
+ *      //   / \              / \
+ *      //  0   1            0   1
+ *
+ * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)
+ */
+
+var reduce =
+/*#__PURE__*/
+_curry3(function (xf, acc, list) {
+  return _xReduce(typeof xf === 'function' ? _xwrap(xf) : xf, acc, list);
+});
+
+var reduce$1 = reduce;
+
+module.exports = reduce$1;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+var _curry1 = require('./internal/_curry1.cjs');
+var _isString = require('./internal/_isString.cjs');
+
+/**
+ * Returns a new list or string with the elements or characters in reverse
+ * order.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a]
+ * @sig String -> String
+ * @param {Array|String} list
+ * @return {Array|String}
+ * @example
+ *
+ *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]
+ *      R.reverse([1, 2]);     //=> [2, 1]
+ *      R.reverse([1]);        //=> [1]
+ *      R.reverse([]);         //=> []
+ *
+ *      R.reverse('abc');      //=> 'cba'
+ *      R.reverse('ab');       //=> 'ba'
+ *      R.reverse('a');        //=> 'a'
+ *      R.reverse('');         //=> ''
+ */
+
+var reverse =
+/*#__PURE__*/
+_curry1(function reverse(list) {
+  return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();
+});
+
+var reverse$1 = reverse;
+
+module.exports = reverse$1;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var _checkForMethod = require('./internal/_checkForMethod.cjs');
+var _curry3 = require('./internal/_curry3.cjs');
+
+/**
+ * Returns the elements of the given list or string (or object with a `slice`
+ * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).
+ *
+ * Dispatches to the `slice` method of the third argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.4
+ * @category List
+ * @sig Number -> Number -> [a] -> [a]
+ * @sig Number -> Number -> String -> String
+ * @param {Number} fromIndex The start index (inclusive).
+ * @param {Number} toIndex The end index (exclusive).
+ * @param {*} list
+ * @return {*}
+ * @example
+ *
+ *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']
+ *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']
+ *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']
+ *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']
+ *      R.slice(0, 3, 'ramda');                     //=> 'ram'
+ */
+
+var slice =
+/*#__PURE__*/
+_curry3(
+/*#__PURE__*/
+_checkForMethod('slice', function slice(fromIndex, toIndex, list) {
+  return Array.prototype.slice.call(list, fromIndex, toIndex);
+}));
+
+var slice$1 = slice;
+
+module.exports = slice$1;

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

@@ -0,0 +1,45 @@
+'use strict';
+
+var _checkForMethod = require('./internal/_checkForMethod.cjs');
+var _curry1 = require('./internal/_curry1.cjs');
+var slice = require('./slice.cjs');
+
+/**
+ * Returns all but the first element of the given list or string (or object
+ * with a `tail` method).
+ *
+ * Dispatches to the `slice` method of the first argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a]
+ * @sig String -> String
+ * @param {*} list
+ * @return {*}
+ * @see R.head, R.init, R.last
+ * @example
+ *
+ *      R.tail([1, 2, 3]);  //=> [2, 3]
+ *      R.tail([1, 2]);     //=> [2]
+ *      R.tail([1]);        //=> []
+ *      R.tail([]);         //=> []
+ *
+ *      R.tail('abc');  //=> 'bc'
+ *      R.tail('ab');   //=> 'b'
+ *      R.tail('a');    //=> ''
+ *      R.tail('');     //=> ''
+ */
+
+var tail =
+/*#__PURE__*/
+_curry1(
+/*#__PURE__*/
+_checkForMethod('tail',
+/*#__PURE__*/
+slice(1, Infinity)));
+
+var tail$1 = tail;
+
+module.exports = tail$1;

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var _curry1 = require('./internal/_curry1.cjs');
+var keys = require('./keys.cjs');
+
+/**
+ * Returns a list of all the enumerable own properties of the supplied object.
+ * Note that the order of the output array is not guaranteed across different
+ * JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig {k: v} -> [v]
+ * @param {Object} obj The object to extract values from
+ * @return {Array} An array of the values of the object's own properties.
+ * @see R.valuesIn, R.keys, R.toPairs
+ * @example
+ *
+ *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]
+ */
+
+var values =
+/*#__PURE__*/
+_curry1(function values(obj) {
+  var props = keys(obj);
+  var len = props.length;
+  var vals = [];
+  var idx = 0;
+
+  while (idx < len) {
+    vals[idx] = obj[props[idx]];
+    idx += 1;
+  }
+
+  return vals;
+});
+
+var values$1 = values;
+
+module.exports = values$1;

package/cjs/node_modules/@dbmx/sdmx/esm/node_modules/url-join/lib/url-join.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+var _commonjsHelpers = require('../../../_virtual/_commonjsHelpers.cjs');
+var urlJoin = require('../../../_virtual/url-join.cjs');
+
+(function (module) {
+	(function (name, context, definition) {
+	  if (module.exports) module.exports = definition();
+	  else context[name] = definition();
+	})('urljoin', _commonjsHelpers.commonjsGlobal, function () {
+
+	  function normalize (strArray) {
+	    var resultArray = [];
+	    if (strArray.length === 0) { return ''; }
+
+	    if (typeof strArray[0] !== 'string') {
+	      throw new TypeError('Url must be a string. Received ' + strArray[0]);
+	    }
+
+	    // If the first part is a plain protocol, we combine it with the next part.
+	    if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
+	      var first = strArray.shift();
+	      strArray[0] = first + strArray[0];
+	    }
+
+	    // There must be two or three slashes in the file protocol, two slashes in anything else.
+	    if (strArray[0].match(/^file:\/\/\//)) {
+	      strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1:///');
+	    } else {
+	      strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1://');
+	    }
+
+	    for (var i = 0; i < strArray.length; i++) {
+	      var component = strArray[i];
+
+	      if (typeof component !== 'string') {
+	        throw new TypeError('Url must be a string. Received ' + component);
+	      }
+
+	      if (component === '') { continue; }
+
+	      if (i > 0) {
+	        // Removing the starting slashes for each component but the first.
+	        component = component.replace(/^[\/]+/, '');
+	      }
+	      if (i < strArray.length - 1) {
+	        // Removing the ending slashes for each component but the last.
+	        component = component.replace(/[\/]+$/, '');
+	      } else {
+	        // For the last component we will combine multiple slashes to a single one.
+	        component = component.replace(/[\/]+$/, '/');
+	      }
+
+	      resultArray.push(component);
+
+	    }
+
+	    var str = resultArray.join('/');
+	    // Each input component is now separated by a single slash except the possible first plain protocol part.
+
+	    // remove trailing slash before parameters or hash
+	    str = str.replace(/\/(\?|&|#[^!])/g, '$1');
+
+	    // replace ? in parameters with &
+	    var parts = str.split('?');
+	    str = parts.shift() + (parts.length > 0 ? '?': '') + parts.join('&');
+
+	    return str;
+	  }
+
+	  return function () {
+	    var input;
+
+	    if (typeof arguments[0] === 'object') {
+	      input = arguments[0];
+	    } else {
+	      input = [].slice.call(arguments);
+	    }
+
+	    return normalize(input);
+	  };
+
+	}); 
+} (urlJoin.__module));
+
+var urlJoinExports = urlJoin.__module.exports;
+var urljoin = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(urlJoinExports);
+
+module.exports = urljoin;