@dbmx/toasts 0.0.122 → 0.0.123

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

@@ -0,0 +1,69 @@
+'use strict';
+
+var _curry2$1 = require('./internal/_curry2.cjs');
+var _isArray$1 = require('./internal/_isArray.cjs');
+var _isFunction$1 = require('./internal/_isFunction.cjs');
+var _isString$1 = require('./internal/_isString.cjs');
+var toString$1 = require('./toString.cjs');
+
+var _curry2 = _curry2$1._curry2_1;
+var _isArray = _isArray$1._isArray_1;
+var _isFunction = _isFunction$1._isFunction_1;
+var _isString = _isString$1._isString_1;
+var toString = toString$1.toString_1;
+
+/**
+ * Returns the result of concatenating the given lists or strings.
+ *
+ * Note: `R.concat` expects both arguments to be of the same type,
+ * unlike the native `Array.prototype.concat` method. It will throw
+ * an error if you `concat` an Array with a non-Array value.
+ *
+ * Dispatches to the `concat` method of the first argument, if present.
+ * Can also concatenate two members of a [fantasy-land
+ * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a] -> [a]
+ * @sig String -> String -> String
+ * @param {Array|String} firstList The first list
+ * @param {Array|String} secondList The second list
+ * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of
+ * `secondList`.
+ *
+ * @example
+ *
+ *      R.concat('ABC', 'DEF'); // 'ABCDEF'
+ *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
+ *      R.concat([], []); //=> []
+ */
+
+var concat = /*#__PURE__*/
+_curry2(function concat(a, b) {
+  if (_isArray(a)) {
+    if (_isArray(b)) {
+      return a.concat(b);
+    }
+    throw new TypeError(toString(b) + ' is not an array');
+  }
+  if (_isString(a)) {
+    if (_isString(b)) {
+      return a + b;
+    }
+    throw new TypeError(toString(b) + ' is not a string');
+  }
+  if (a != null && _isFunction(a['fantasy-land/concat'])) {
+    return a['fantasy-land/concat'](b);
+  }
+  if (a != null && _isFunction(a.concat)) {
+    return a.concat(b);
+  }
+  throw new TypeError(toString(a) + ' does not have a method named "concat" or "fantasy-land/concat"');
+});
+var concat$1 = concat;
+var concat_1 = concat$1;
+
+exports.concat_1 = concat_1;

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

@@ -0,0 +1,66 @@
+'use strict';
+
+var _arity$1 = require('./internal/_arity.cjs');
+var _curry1$1 = require('./internal/_curry1.cjs');
+var _curry2$1 = require('./internal/_curry2.cjs');
+var _curryN$1 = require('./internal/_curryN.cjs');
+
+var _arity = _arity$1._arity_1;
+var _curry1 = _curry1$1._curry1_1;
+var _curry2 = _curry2$1._curry2_1;
+var _curryN = _curryN$1._curryN_1;
+
+/**
+ * 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;
+var curryN_1 = curryN$1;
+
+exports.curryN_1 = curryN_1;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+var _curry2$1 = require('./internal/_curry2.cjs');
+
+var _curry2 = _curry2$1._curry2_1;
+
+/**
+ * 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;
+var defaultTo_1 = defaultTo$1;
+
+exports.defaultTo_1 = defaultTo_1;

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;