@dbmx/toasts 0.0.67 → 0.0.70

package/cjs/components/SdmxDatagrid/utils/index.cjs

@@ -1,8 +1,10 @@
 'use strict';
 
 var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.cjs');
-var sdmx = require('@dbmx/sdmx');
 var urljoin = require('url-join');
+var core = require('../../../node_modules/@dbmx/sdmx/esm/core.cjs');
+var datastructures = require('../../../node_modules/@dbmx/sdmx/esm/datastructures.cjs');
+var query = require('../../../node_modules/@dbmx/sdmx/esm/query.cjs');
 
 function sortByKey(array, key) {
   return array.sort(function (a, b) {
@@ -65,9 +67,9 @@ var getStructure = /*#__PURE__*/function () {
   };
 }();
 var getDataStructure = function getDataStructure(dataflow, structure) {
-  if (!(dataflow !== null && dataflow !== void 0 && dataflow.structure)) throw new Error("Cannot get dataStructure from dataflow ".concat(sdmx.ID(dataflow)));
-  var dsRef = sdmx.urn2FullRef(dataflow.structure);
-  return sdmx.resolveResourceFromStructure(structure, dataflow, dsRef, {
+  if (!(dataflow !== null && dataflow !== void 0 && dataflow.structure)) throw new Error("Cannot get dataStructure from dataflow ".concat(core.ID(dataflow)));
+  var dsRef = core.urn2FullRef(dataflow.structure);
+  return core.resolveResourceFromStructure(structure, dataflow, dsRef, {
     noError: true
   });
 };
@@ -92,7 +94,7 @@ var getColumns = function getColumns() {
   };
 };
 var getSelectedComponents = function getSelectedComponents(resource) {
-  var components = sdmx.getComponents(resource);
+  var components = datastructures.getComponents(resource);
   return components.reduce(function (acc, component) {
     return _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, acc), {}, _rollupPluginBabelHelpers.defineProperty({}, component.id, component));
   }, {});
@@ -111,9 +113,9 @@ var getData = /*#__PURE__*/function () {
             min: 1,
             max: 100
           };
-          dataUrl = sdmx.dataQueryUrl(_rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({
+          dataUrl = query.dataQueryUrl(_rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({
             context: 'dataflow'
-          }, sdmx.getRef(dataflow)), {}, {
+          }, core.getRef(dataflow)), {}, {
             endpoint: endpoint
           }));
           min = range.min, max = range.max;

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

@@ -0,0 +1,143 @@
+'use strict';
+
+var _arrayFromIterator$1 = require('./_arrayFromIterator.cjs');
+var _includesWith$1 = require('./_includesWith.cjs');
+var _functionName$1 = require('./_functionName.cjs');
+var _has$1 = require('./_has.cjs');
+var _objectIs$1 = require('./_objectIs.cjs');
+var keys$1 = require('../keys.cjs');
+var type$1 = require('../type.cjs');
+
+var _arrayFromIterator = _arrayFromIterator$1._arrayFromIterator_1;
+var _includesWith = _includesWith$1._includesWith_1;
+var _functionName = _functionName$1._functionName_1;
+var _has = _has$1._has_1;
+var _objectIs = _objectIs$1._objectIs_1;
+var keys = keys$1.keys_1;
+var type = type$1.type_1;
+
+/**
+ * private _uniqContentEquals function.
+ * That function is checking equality of 2 iterator contents with 2 assumptions
+ * - iterators lengths are the same
+ * - iterators values are unique
+ *
+ * false-positive result will be returned for comparison of, e.g.
+ * - [1,2,3] and [1,2,3,4]
+ * - [1,1,1] and [1,2,3]
+ * */
+
+function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
+  var a = _arrayFromIterator(aIterator);
+  var b = _arrayFromIterator(bIterator);
+  function eq(_a, _b) {
+    return _equals(_a, _b, stackA.slice(), stackB.slice());
+  } // if *a* array contains any element that is not included in *b*
+
+  return !_includesWith(function (b, aItem) {
+    return !_includesWith(eq, aItem, b);
+  }, b, a);
+}
+function _equals(a, b, stackA, stackB) {
+  if (_objectIs(a, b)) {
+    return true;
+  }
+  var typeA = type(a);
+  if (typeA !== type(b)) {
+    return false;
+  }
+  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {
+    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);
+  }
+  if (typeof a.equals === 'function' || typeof b.equals === 'function') {
+    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);
+  }
+  switch (typeA) {
+    case 'Arguments':
+    case 'Array':
+    case 'Object':
+      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {
+        return a === b;
+      }
+      break;
+    case 'Boolean':
+    case 'Number':
+    case 'String':
+      if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {
+        return false;
+      }
+      break;
+    case 'Date':
+      if (!_objectIs(a.valueOf(), b.valueOf())) {
+        return false;
+      }
+      break;
+    case 'Error':
+      return a.name === b.name && a.message === b.message;
+    case 'RegExp':
+      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {
+        return false;
+      }
+      break;
+  }
+  var idx = stackA.length - 1;
+  while (idx >= 0) {
+    if (stackA[idx] === a) {
+      return stackB[idx] === b;
+    }
+    idx -= 1;
+  }
+  switch (typeA) {
+    case 'Map':
+      if (a.size !== b.size) {
+        return false;
+      }
+      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));
+    case 'Set':
+      if (a.size !== b.size) {
+        return false;
+      }
+      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));
+    case 'Arguments':
+    case 'Array':
+    case 'Object':
+    case 'Boolean':
+    case 'Number':
+    case 'String':
+    case 'Date':
+    case 'Error':
+    case 'RegExp':
+    case 'Int8Array':
+    case 'Uint8Array':
+    case 'Uint8ClampedArray':
+    case 'Int16Array':
+    case 'Uint16Array':
+    case 'Int32Array':
+    case 'Uint32Array':
+    case 'Float32Array':
+    case 'Float64Array':
+    case 'ArrayBuffer':
+      break;
+    default:
+      // Values of other types are only equal if identical.
+      return false;
+  }
+  var keysA = keys(a);
+  if (keysA.length !== keys(b).length) {
+    return false;
+  }
+  var extendedStackA = stackA.concat([a]);
+  var extendedStackB = stackB.concat([b]);
+  idx = keysA.length - 1;
+  while (idx >= 0) {
+    var key = keysA[idx];
+    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {
+      return false;
+    }
+    idx -= 1;
+  }
+  return true;
+}
+var _equals_1 = _equals;
+
+exports._equals_1 = _equals_1;

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

@@ -0,0 +1,17 @@
+'use strict';
+
+function _filter(fn, list) {
+  var idx = 0;
+  var len = list.length;
+  var result = [];
+  while (idx < len) {
+    if (fn(list[idx])) {
+      result[result.length] = list[idx];
+    }
+    idx += 1;
+  }
+  return result;
+}
+var _filter_1 = _filter;
+
+exports._filter_1 = _filter_1;

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

@@ -0,0 +1,10 @@
+'use strict';
+
+function _functionName(f) {
+  // String(x => x) evaluates to "x => x", so the pattern may not match.
+  var match = String(f).match(/^function (\w*)/);
+  return match == null ? '' : match[1];
+}
+var _functionName_1 = _functionName;
+
+exports._functionName_1 = _functionName_1;

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

@@ -0,0 +1,11 @@
+'use strict';
+
+var _indexOf$1 = require('./_indexOf.cjs');
+
+var _indexOf = _indexOf$1._indexOf_1;
+function _includes(a, list) {
+  return _indexOf(list, a, 0) >= 0;
+}
+var _includes_1 = _includes;
+
+exports._includes_1 = _includes_1;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+function _includesWith(pred, x, list) {
+  var idx = 0;
+  var len = list.length;
+  while (idx < len) {
+    if (pred(x, list[idx])) {
+      return true;
+    }
+    idx += 1;
+  }
+  return false;
+}
+var _includesWith_1 = _includesWith;
+
+exports._includesWith_1 = _includesWith_1;

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;