@dbmx/toasts 0.0.46 → 0.0.48

package/cjs/node_modules/@dbmx/sdmx/cjs/data.cjs

@@ -0,0 +1,140 @@
+'use strict';
+
+var core = require('./core.cjs');
+var slice$1 = require('./node_modules/ramda/es/slice.cjs');
+var times$1 = require('./node_modules/ramda/es/times.cjs');
+var concat$1 = require('./node_modules/ramda/es/concat.cjs');
+var isNil$1 = require('./node_modules/ramda/es/isNil.cjs');
+
+core.__require();
+var slice = slice$1.slice_1;
+var times = times$1.times_1;
+var concat = concat$1.concat_1;
+var isNil = isNil$1.isNil_1;
+const fillSlice = (start, size, input = [], value = null) => {
+  const d1 = slice(start, size, input);
+  if (size - d1.length < 0) return d1;
+  const d2 = times(() => value, size - d1.length);
+  return concat(d1, d2);
+};
+const getDefaultCompValue = comp => comp.default;
+const getdSetDimensions = structure => {
+  const dimensions = structure?.dimensions?.dataSet || [];
+  const res = {};
+  for (const dimension of dimensions) {
+    if (!dimension.values) continue;
+    res[dimension.id] = dimension.values[0];
+  }
+  return res;
+};
+const getdSetAttributes = structure => {
+  const attributes = structure?.attributes?.dataSet || [];
+  const res = {};
+  for (const attribute of attributes) {
+    if (!attribute.values) continue;
+    res[attribute.id] = attribute.values[0];
+  }
+  return res;
+};
+const unpackDimensions = key => key.split(':');
+const getObsDimensions = (structure, key) => {
+  const dimensions = structure?.dimensions?.observation || [];
+  const res = {};
+  for (const [idx, idxValue] of unpackDimensions(key).entries()) {
+    const dimension = dimensions[idx];
+    if (!dimension) throw new Error(`Cannot get dimension idx ${idx}!`);
+    const value = dimension.values[idxValue];
+    if (!value) throw new Error(`Cannot get value ${idxValue} for dimension ${dimension.id}!`);
+    res[dimension.id] = value;
+  }
+  return res;
+};
+const getDataObsAttributes = (structure, values) => {
+  const measures = structure?.measures?.observation || [];
+  const attributes = structure?.attributes?.observation || [];
+  const attributeValues = fillSlice(measures.length, attributes.length, values);
+  return getObsAttributes(structure, attributeValues);
+};
+const getObsAttributes = (structure, values) => {
+  const attributes = structure?.attributes?.observation || [];
+  const res = {};
+  for (const [idx, idxValue] of values.entries()) {
+    const attribute = attributes[idx];
+    if (!attribute) throw new Error(`Cannot get attribute idx ${idx}!`);
+    if (attribute.values) {
+      if (idxValue === null) {
+        const defaultValue = getDefaultCompValue(attribute);
+        if (!isNil(defaultValue)) res[attribute.id] = {
+          value: defaultValue
+        };
+      } else {
+        const value = attribute.values[idxValue];
+        if (value !== null) {
+          if (!value) throw new Error(`Cannot get value ${idxValue} for attribute ${attribute.id}!`);
+          res[attribute.id] = value;
+        }
+      }
+    } else {
+      if (idxValue !== null) res[attribute.id] = {
+        value: idxValue
+      };
+    }
+  }
+  return res;
+};
+const getKeyAttributes = (structure, key) => {
+  return {
+    ...getdSetAttributes(structure),
+    ...getDataObsAttributes(structure, key)
+  };
+};
+const getKeyMeasures = (structure, values) => {
+  const measures = structure?.measures?.observation || [];
+  const measureValues = fillSlice(0, measures.length, values);
+  return getMeasures(structure, measureValues);
+};
+const getMeasures = (structure, values) => {
+  const measures = structure?.measures?.observation || [];
+  const res = {};
+  for (const [idx, idxValue] of values.entries()) {
+    const measure = measures[idx];
+    if (!measure) throw new Error(`Cannot get measure idx ${idx}!`);
+    if (idxValue === null) continue;else if (!measure.values) {
+      res[measure.id] = {
+        value: idxValue
+      };
+    } else {
+      const value = measure.values[idxValue];
+      if (!value) throw new Error(`Cannot get value ${idxValue} for measure ${measure.id}!`);
+      res[measure.id] = value;
+    }
+  }
+  return res;
+};
+const getDimensions = (structure, key) => {
+  return {
+    ...getdSetDimensions(structure),
+    ...getObsDimensions(structure, key)
+  };
+};
+function* getObservations(dataStructure, {
+  dSet = 0
+} = {}) {
+  const dataSet = dataStructure?.data?.dataSets?.[dSet];
+  if (!dataSet) throw new Error(`Wrong input dataStructure: cannot get targeted dataSet!`);
+  const structure = dataStructure.data?.structures?.[dataSet.structure];
+  if (!structure) throw new Error(`Wrong input dataStructure: cannot get targeted structure!`);
+  const observations = dataSet.observations;
+  if (!observations) return;
+  for (const key of Object.keys(observations)) {
+    const obs = {
+      ...getDimensions(structure, key),
+      ...getKeyMeasures(structure, observations[key]),
+      ...getKeyAttributes(structure, observations[key])
+    };
+    yield obs;
+  }
+}
+var getObservations_1 = getObservations;
+
+exports.getObservations = getObservations_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/dependencyResolver.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var dependencyResolver = require('../../../../_virtual/dependencyResolver.cjs');
+var index_esm = require('../../../../_virtual/index.esm.cjs');
+
+var semver = index_esm;
+
+// TODO: remove resourceType from comparaison
+const matchRefVersionLess = (ref, resource) => (ref.resourceType && resource.resourceType && ref.resourceType === resource.resourceType || !ref.resourceType || !resource.resourceType) && ref.id === resource.id && ref.agencyID === resource.agencyID;
+const getOne = (ref, range, resources) => {
+  for (const resource of resources) {
+    if (matchRefVersionLess(ref, resource) && range.test(resource.version)) return resource;
+  }
+};
+const getLatest = (ref, range, resources) => {
+  let res = [];
+  if (resources.length === 1 && range.raw === '~') return resources[0];
+  for (const resource of resources) {
+    if (!matchRefVersionLess(ref, resource)) continue;
+    const semver$1 = semver.SemVer(resource.version);
+    if (semver$1.isNonVersioned()) continue;
+    if (range.test(semver$1)) {
+      if (!res[0]) res = [resource, semver$1];else if (semver$1.compare(res[1]) === 1) res = [resource, semver$1];
+    }
+  }
+  return res[0];
+};
+
+/**
+ * Returns an external resource from the input
+ *
+ * @function resolveDependency
+ * @tag dependency
+ * @param {array} - all possible resources
+ * @param {object} - source of the dependency
+ * @param {object} - target version
+ *
+ * @example
+ *
+ *   const resources = [
+ *      { agencyID: 'A', id: 'ID1', version: '1.0.0' },
+ *      { agencyID: 'A', id: 'ID2', version: '1.0.1' },
+ *      { agencyID: 'A', id: 'ID3', version: '1.1.1' },
+ *   ]
+ *   const ref = resolveDependency(resources, { version: 1.0.0 }, { resourceType, agencyID, id, version: '1.1+.0' }
+ *   expect(ref.id}.toEqual('ID3')
+ */
+
+const resolveDependency = (resources, source, ref, {
+  noError
+} = {}) => {
+  try {
+    const range = semver.Dependency(source, ref.version).range;
+    if (range.type === semver.RANGE_TYPE.LATEST) return getLatest(ref, range, resources);
+    return getOne(ref, range, resources);
+  } catch (err) {
+    if (noError) return;
+    throw err;
+  }
+};
+const resolveDataTarget = (resources, ref) => {
+  try {
+    const range = semver.Range(ref.version);
+    if (range.type === semver.RANGE_TYPE.LATEST) return getLatest(ref, range, resources);
+    return getOne(ref, range, resources);
+  } catch (err) {
+    return;
+  }
+};
+dependencyResolver.__exports.resolveDataTarget = resolveDataTarget;
+dependencyResolver.__exports.resolveDependency = resolveDependency;
+
+module.exports = dependencyResolver.__exports;

package/cjs/node_modules/@dbmx/sdmx/cjs/items.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+var items = require('../../../../_virtual/items.cjs');
+var core = require('./core.cjs');
+
+var hasRequiredItems;
+
+function requireItems () {
+	if (hasRequiredItems) return items.__exports;
+	hasRequiredItems = 1;
+
+	var core$1 = core.__require();
+
+	/**
+	 * Returns  fully qualified items for parent and categories relations
+	 *
+	 * @function getFullyQualifiedItems
+	 * @tag items
+	 * @tag structure
+	 * @param {array} - items
+	 * @param {object} - options [flatten: bool: get flatten array of items ]
+	 *
+	 * @example
+	 *
+	 *   const source = {}
+	 *   const codes = [
+	 *    { id: 'A' },
+	 *    { id: 'E' },
+	 *    { id: 'F', parent: 'E' },
+	 *    { id: 'B', parent: 'A' },
+	 *    { id: 'C', parent: 'A' },
+	 *    { id: 'D', parent: 'B' },
+	 *   ]
+	 *
+	 *   const res = new Set(getFullyQualifiedItems(codes).map(code => code.fullId))
+	 *   expect(res).toEqual(new Set(['A', 'E', 'E.F', 'A.B', 'A.C', 'A.B.D']))
+	 */
+
+	const getFullyQualifiedItems = (items = [], options = {}) => {
+	  const roots = {};
+	  const nodes = {};
+	  const parentIds = {};
+	  const childrendIds = {};
+	  const getLabel = options.getLabel ?? ((parentName, itemName) => `${parentName} > ${itemName}`);
+	  const fullId = item => {
+	    const parentId = parentIds[item.id];
+	    if (!parentId) return item.id;
+	    const parent = nodes[parentId];
+	    if (!parent) throw new Error(`Invalid code: ${parentId} code does not exist`);
+	    return `${parent.fullId}.${item.id}`;
+	  };
+	  const fullName = (locale, item) => {
+	    const parentId = parentIds[item.id];
+	    const name = core$1.getName(locale, item) ?? item.id;
+	    if (!parentId) return name;
+	    const parent = nodes[parentId];
+	    if (!parent) throw new Error(`Invalid code: ${parentId} code does not exist`);
+	    return getLabel(parent.fullName(locale), name);
+	  };
+	  const scan = (items, parent) => {
+	    for (const item of items) {
+	      if (!nodes[item.id]) {
+	        nodes[item.id] = {
+	          ...item,
+	          fullName(locale) {
+	            return fullName(locale, item);
+	          },
+	          get fullId() {
+	            return fullId(item);
+	          },
+	          get children() {
+	            return childrendIds[item.id]?.map(id => nodes[id]) ?? [];
+	          }
+	        };
+	        if (item.parent) {
+	          parentIds[item.id] = item.parent;
+	          if (!childrendIds[item.parent]) childrendIds[item.parent] = [item.id];else childrendIds[item.parent].push(item.id);
+	        } else if (parent) {
+	          parentIds[item.id] = parent.id;
+	          if (!childrendIds[parent.id]) childrendIds[parent.id] = [item.id];else childrendIds[parent.id].push(item.id);
+	        }
+	        if (!parent && !item.parent) roots[item.id] = nodes[item.id];
+	        if (item.categories) scan(item.categories, item);
+	      }
+	    }
+	  };
+	  scan(items);
+	  return options.flatten ? Object.values(nodes) : Object.values(roots);
+	};
+	const getItems = (resourceType, values) => {
+	  const resource = core$1.getArtefactByType(resourceType);
+	  if (!resource?.isItemScheme) throw new Error(`Invalid resourceType: "${resourceType}"`);
+	  return values?.[resource.itemsName] || [];
+	};
+	items.__exports.getFullyQualifiedItems = getFullyQualifiedItems;
+	items.__exports.getItems = getItems;
+	return items.__exports;
+}
+
+exports.__require = requireItems;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+var _curry3$1 = require('./internal/_curry3.cjs');
+var assocPath$1 = require('./assocPath.cjs');
+
+var _curry3 = _curry3$1._curry3_1;
+var assocPath = assocPath$1.assocPath_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.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Object
+ * @typedefn Idx = String | Int
+ * @sig Idx -> a -> {k: v} -> {k: v}
+ * @param {String|Number} prop The property name to set
+ * @param {*} val The new value
+ * @param {Object} obj The object to clone
+ * @return {Object} A new object equivalent to the original except for the changed property.
+ * @see R.dissoc, R.pick
+ * @example
+ *
+ *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
+ */
+
+var assoc = /*#__PURE__*/
+_curry3(function assoc(prop, val, obj) {
+  return assocPath([prop], val, obj);
+});
+var assoc$1 = assoc;
+var assoc_1 = assoc$1;
+
+exports.assoc_1 = assoc_1;

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

@@ -0,0 +1,55 @@
+'use strict';
+
+var _curry3$1 = require('./internal/_curry3.cjs');
+var _has$1 = require('./internal/_has.cjs');
+var _isInteger$1 = require('./internal/_isInteger.cjs');
+var _assoc$1 = require('./internal/_assoc.cjs');
+var isNil$1 = require('./isNil.cjs');
+
+var _curry3 = _curry3$1._curry3_1;
+var _has = _has$1._has_1;
+var _isInteger = _isInteger$1._isInteger_1;
+var _assoc = _assoc$1._assoc_1;
+var isNil = isNil$1.isNil_1;
+
+/**
+ * Makes a shallow clone of an object, setting or overriding the nodes required
+ * to create the given path, and placing the specific value at the tail end of
+ * that 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.8.0
+ * @category Object
+ * @typedefn Idx = String | Int | Symbol
+ * @sig [Idx] -> a -> {a} -> {a}
+ * @param {Array} path the path to set
+ * @param {*} val The new value
+ * @param {Object} obj The object to clone
+ * @return {Object} A new object equivalent to the original except along the specified path.
+ * @see R.dissocPath
+ * @example
+ *
+ *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
+ *
+ *      // Any missing or non-object keys in path will be overridden
+ *      R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}
+ */
+
+var assocPath = /*#__PURE__*/
+_curry3(function assocPath(path, val, obj) {
+  if (path.length === 0) {
+    return val;
+  }
+  var idx = path[0];
+  if (path.length > 1) {
+    var nextObj = !isNil(obj) && _has(idx, obj) && typeof obj[idx] === 'object' ? obj[idx] : _isInteger(path[1]) ? [] : {};
+    val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);
+  }
+  return _assoc(idx, val, obj);
+});
+var assocPath$1 = assocPath;
+var assocPath_1 = assocPath$1;
+
+exports.assocPath_1 = assocPath_1;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var _arity$1 = require('./internal/_arity.cjs');
+var _curry2$1 = require('./internal/_curry2.cjs');
+
+var _arity = _arity$1._arity_1;
+var _curry2 = _curry2$1._curry2_1;
+
+/**
+ * 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;
+var bind_1 = bind$1;
+
+exports.bind_1 = bind_1;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+var pipe$1 = require('./pipe.cjs');
+var reverse$1 = require('./reverse.cjs');
+
+var pipe = pipe$1.pipe_1;
+var reverse = reverse$1.reverse_1;
+
+/**
+ * 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));
+}
+var compose_1 = compose;
+
+exports.compose_1 = compose_1;

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;