@dbmx/toasts 0.0.88 → 0.0.92

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/_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/_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/_objectIs.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+function _objectIs(a, b) {
+  // SameValue algorithm
+  if (a === b) {
+    // Steps 1-5, 7-10
+    // Steps 6.b-6.e: +0 != -0
+    return a !== 0 || 1 / a === 1 / b;
+  } else {
+    // Step 6.a: NaN == NaN
+    return a !== a && b !== b;
+  }
+}
+var _objectIs$1 = typeof Object.is === 'function' ? Object.is : _objectIs;
+var _objectIs_1 = _objectIs$1;
+
+exports._objectIs_1 = _objectIs_1;

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

@@ -0,0 +1,10 @@
+'use strict';
+
+function _quote(s) {
+  var escaped = s.replace(/\\/g, '\\\\').replace(/[\b]/g, '\\b') // \b matches word boundary; [\b] matches backspace
+  .replace(/\f/g, '\\f').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t').replace(/\v/g, '\\v').replace(/\0/g, '\\0');
+  return '"' + escaped.replace(/"/g, '\\"') + '"';
+}
+var _quote_1 = _quote;
+
+exports._quote_1 = _quote_1;

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

@@ -0,0 +1,17 @@
+'use strict';
+
+/**
+ * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.
+ */
+var pad = function pad(n) {
+  return (n < 10 ? '0' : '') + n;
+};
+var _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {
+  return d.toISOString();
+} : function _toISOString(d) {
+  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';
+};
+var _toISOString$1 = _toISOString;
+var _toISOString_1 = _toISOString$1;
+
+exports._toISOString_1 = _toISOString_1;

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

@@ -0,0 +1,62 @@
+'use strict';
+
+var _includes$1 = require('./_includes.cjs');
+var _map$1 = require('./_map.cjs');
+var _quote$1 = require('./_quote.cjs');
+var _toISOString$1 = require('./_toISOString.cjs');
+var keys$1 = require('../keys.cjs');
+var reject$1 = require('../reject.cjs');
+
+var _includes = _includes$1._includes_1;
+var _map = _map$1._map_1;
+var _quote = _quote$1._quote_1;
+var _toISOString = _toISOString$1._toISOString_1;
+var keys = keys$1.keys_1;
+var reject = reject$1.reject_1;
+function _toString(x, seen) {
+  var recur = function recur(y) {
+    var xs = seen.concat([x]);
+    return _includes(y, xs) ? '<Circular>' : _toString(y, xs);
+  }; //  mapPairs :: (Object, [String]) -> [String]
+
+  var mapPairs = function (obj, keys) {
+    return _map(function (k) {
+      return _quote(k) + ': ' + recur(obj[k]);
+    }, keys.slice().sort());
+  };
+  switch (Object.prototype.toString.call(x)) {
+    case '[object Arguments]':
+      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';
+    case '[object Array]':
+      return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {
+        return /^\d+$/.test(k);
+      }, keys(x)))).join(', ') + ']';
+    case '[object Boolean]':
+      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();
+    case '[object Date]':
+      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';
+    case '[object Map]':
+      return 'new Map(' + recur(Array.from(x)) + ')';
+    case '[object Null]':
+      return 'null';
+    case '[object Number]':
+      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);
+    case '[object Set]':
+      return 'new Set(' + recur(Array.from(x).sort()) + ')';
+    case '[object String]':
+      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);
+    case '[object Undefined]':
+      return 'undefined';
+    default:
+      if (typeof x.toString === 'function') {
+        var repr = x.toString();
+        if (repr !== '[object Object]') {
+          return repr;
+        }
+      }
+      return '{' + mapPairs(x, keys(x)).join(', ') + '}';
+  }
+}
+var _toString_1 = _toString;
+
+exports._toString_1 = _toString_1;

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

@@ -0,0 +1,26 @@
+'use strict';
+
+var _xfBase$1 = require('./_xfBase.cjs');
+
+var _xfBase = _xfBase$1._xfBase_1;
+var XFilter = /*#__PURE__*/
+function () {
+  function XFilter(f, xf) {
+    this.xf = xf;
+    this.f = f;
+  }
+  XFilter.prototype['@@transducer/init'] = _xfBase.init;
+  XFilter.prototype['@@transducer/result'] = _xfBase.result;
+  XFilter.prototype['@@transducer/step'] = function (result, input) {
+    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;
+  };
+  return XFilter;
+}();
+function _xfilter(f) {
+  return function (xf) {
+    return new XFilter(f, xf);
+  };
+}
+var _xfilter_1 = _xfilter;
+
+exports._xfilter_1 = _xfilter_1;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+var _complement$1 = require('./internal/_complement.cjs');
+var _curry2$1 = require('./internal/_curry2.cjs');
+var filter$1 = require('./filter.cjs');
+
+var _complement = _complement$1._complement_1;
+var _curry2 = _curry2$1._curry2_1;
+var filter = filter$1.filter_1;
+
+/**
+ * The complement of [`filter`](#filter).
+ *
+ * Acts as a transducer if a transformer is given in list position. Filterable
+ * objects include plain objects or any object that has a filter method such
+ * as `Array`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Filterable f => (a -> Boolean) -> f a -> f a
+ * @param {Function} pred
+ * @param {Array} filterable
+ * @return {Array}
+ * @see R.filter, R.transduce, R.addIndex
+ * @example
+ *
+ *      const isOdd = (n) => n % 2 !== 0;
+ *
+ *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
+ *
+ *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
+ */
+
+var reject = /*#__PURE__*/
+_curry2(function reject(pred, filterable) {
+  return filter(_complement(pred), filterable);
+});
+var reject$1 = reject;
+var reject_1 = reject$1;
+
+exports.reject_1 = reject_1;

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

@@ -0,0 +1,49 @@
+'use strict';
+
+var _curry2$1 = require('./internal/_curry2.cjs');
+
+var _curry2 = _curry2$1._curry2_1;
+
+/**
+ * Calls an input function `n` times, returning an array containing the results
+ * of those function calls.
+ *
+ * `fn` is passed one argument: The current value of `n`, which begins at `0`
+ * and is gradually incremented to `n - 1`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.3
+ * @category List
+ * @sig (Number -> a) -> Number -> [a]
+ * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.
+ * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.
+ * @return {Array} An array containing the return values of all calls to `fn`.
+ * @see R.repeat
+ * @example
+ *
+ *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
+ * @symb R.times(f, 0) = []
+ * @symb R.times(f, 1) = [f(0)]
+ * @symb R.times(f, 2) = [f(0), f(1)]
+ */
+
+var times = /*#__PURE__*/
+_curry2(function times(fn, n) {
+  var len = Number(n);
+  var idx = 0;
+  var list;
+  if (len < 0 || isNaN(len)) {
+    throw new RangeError('n must be a non-negative number');
+  }
+  list = [];
+  while (idx < len) {
+    list.push(fn(idx));
+    idx += 1;
+  }
+  return list;
+});
+var times$1 = times;
+var times_1 = times$1;
+
+exports.times_1 = times_1;

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

@@ -0,0 +1,53 @@
+'use strict';
+
+var _curry1$1 = require('./internal/_curry1.cjs');
+var _toString$1 = require('./internal/_toString.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var _toString = _toString$1._toString_1;
+
+/**
+ * Returns the string representation of the given value. `eval`'ing the output
+ * should result in a value equivalent to the input value. Many of the built-in
+ * `toString` methods do not satisfy this requirement.
+ *
+ * If the given value is an `[object Object]` with a `toString` method other
+ * than `Object.prototype.toString`, this method is invoked with no arguments
+ * to produce the return value. This means user-defined constructor functions
+ * can provide a suitable `toString` method. For example:
+ *
+ *     function Point(x, y) {
+ *       this.x = x;
+ *       this.y = y;
+ *     }
+ *
+ *     Point.prototype.toString = function() {
+ *       return 'new Point(' + this.x + ', ' + this.y + ')';
+ *     };
+ *
+ *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category String
+ * @sig * -> String
+ * @param {*} val
+ * @return {String}
+ * @example
+ *
+ *      R.toString(42); //=> '42'
+ *      R.toString('abc'); //=> '"abc"'
+ *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'
+ *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
+ *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")'
+ */
+
+var toString = /*#__PURE__*/
+_curry1(function toString(val) {
+  return _toString(val, []);
+});
+var toString$1 = toString;
+var toString_1 = toString$1;
+
+exports.toString_1 = toString_1;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var _curry1$1 = require('./internal/_curry1.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+
+/**
+ * Gives a single-word string description of the (native) type of a value,
+ * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not
+ * attempt to distinguish user Object types any further, reporting them all as
+ * 'Object'.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Type
+ * @sig * -> String
+ * @param {*} val The value to test
+ * @return {String}
+ * @example
+ *
+ *      R.type({}); //=> "Object"
+ *      R.type(1); //=> "Number"
+ *      R.type(false); //=> "Boolean"
+ *      R.type('s'); //=> "String"
+ *      R.type(null); //=> "Null"
+ *      R.type([]); //=> "Array"
+ *      R.type(/[A-z]/); //=> "RegExp"
+ *      R.type(() => {}); //=> "Function"
+ *      R.type(async () => {}); //=> "AsyncFunction"
+ *      R.type(undefined); //=> "Undefined"
+ */
+
+var type = /*#__PURE__*/
+_curry1(function type(val) {
+  return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);
+});
+var type$1 = type;
+var type_1 = type$1;
+
+exports.type_1 = type_1;