@dbmx/toasts 0.0.47 → 0.0.49

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

@@ -0,0 +1,46 @@
+'use strict';
+
+var _curry3$1 = require('./internal/_curry3.cjs');
+var defaultTo$1 = require('./defaultTo.cjs');
+var prop$1 = require('./prop.cjs');
+
+var _curry3 = _curry3$1._curry3_1;
+var defaultTo = defaultTo$1.defaultTo_1;
+var prop = prop$1.prop_1;
+
+/**
+ * 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;
+var propOr_1 = propOr$1;
+
+exports.propOr_1 = propOr_1;

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

@@ -0,0 +1,71 @@
+'use strict';
+
+var _curry3$1 = require('./internal/_curry3.cjs');
+var _xReduce$1 = require('./internal/_xReduce.cjs');
+var _xwrap$1 = require('./internal/_xwrap.cjs');
+
+var _curry3 = _curry3$1._curry3_1;
+var _xReduce = _xReduce$1._xReduce_1;
+var _xwrap = _xwrap$1._xwrap_1;
+
+/**
+ * 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;
+var reduce_1 = reduce$1;
+
+exports.reduce_1 = reduce_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/remove.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var _curry3$1 = require('./internal/_curry3.cjs');
+
+var _curry3 = _curry3$1._curry3_1;
+
+/**
+ * Removes the sub-list of `list` starting at index `start` and containing
+ * `count` elements. _Note that this is not destructive_: it returns a copy of
+ * the list with the changes.
+ * <small>No lists have been harmed in the application of this function.</small>
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.2
+ * @category List
+ * @sig Number -> Number -> [a] -> [a]
+ * @param {Number} start The position to start removing elements
+ * @param {Number} count The number of elements to remove
+ * @param {Array} list The list to remove from
+ * @return {Array} A new Array with `count` elements from `start` removed.
+ * @see R.without
+ * @example
+ *
+ *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
+ */
+
+var remove = /*#__PURE__*/
+_curry3(function remove(start, count, list) {
+  var result = Array.prototype.slice.call(list, 0);
+  result.splice(start, count);
+  return result;
+});
+var remove$1 = remove;
+var remove_1 = remove$1;
+
+exports.remove_1 = remove_1;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+var _curry1$1 = require('./internal/_curry1.cjs');
+var _isString$1 = require('./internal/_isString.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var _isString = _isString$1._isString_1;
+
+/**
+ * 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;
+var reverse_1 = reverse$1;
+
+exports.reverse_1 = reverse_1;

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var _checkForMethod$1 = require('./internal/_checkForMethod.cjs');
+var _curry3$1 = require('./internal/_curry3.cjs');
+
+var _checkForMethod = _checkForMethod$1._checkForMethod_1;
+var _curry3 = _curry3$1._curry3_1;
+
+/**
+ * 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;
+var slice_1 = slice$1;
+
+exports.slice_1 = slice_1;

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

@@ -0,0 +1,46 @@
+'use strict';
+
+var _checkForMethod$1 = require('./internal/_checkForMethod.cjs');
+var _curry1$1 = require('./internal/_curry1.cjs');
+var slice$1 = require('./slice.cjs');
+
+var _checkForMethod = _checkForMethod$1._checkForMethod_1;
+var _curry1 = _curry1$1._curry1_1;
+var slice = slice$1.slice_1;
+
+/**
+ * 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;
+var tail_1 = tail$1;
+
+exports.tail_1 = tail_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;

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

@@ -0,0 +1,42 @@
+'use strict';
+
+var _curry1$1 = require('./internal/_curry1.cjs');
+var keys$1 = require('./keys.cjs');
+
+var _curry1 = _curry1$1._curry1_1;
+var keys = keys$1.keys_1;
+
+/**
+ * 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;
+var values_1 = values$1;
+
+exports.values_1 = values_1;

package/cjs/node_modules/@dbmx/sdmx/cjs/types/artefacts.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var artefacts = require('../../../../../_virtual/artefacts.cjs');
+var dataflow = require('./dataflow.cjs');
+var datastructure = require('./datastructure.cjs');
+var codelist = require('./codelist.cjs');
+var categorisation = require('./categorisation.cjs');
+var categoryscheme = require('./categoryscheme.cjs');
+var conceptscheme = require('./conceptscheme.cjs');
+var contentconstraint = require('./contentconstraint.cjs');
+var dataproviderscheme = require('./dataproviderscheme.cjs');
+var hierarchicalcodelist = require('./hierarchicalcodelist.cjs');
+var dataconstraint = require('./dataconstraint.cjs');
+var provisionagreement = require('./provisionagreement.cjs');
+var metadatastructure = require('./metadatastructure.cjs');
+
+var hasRequiredArtefacts;
+
+function requireArtefacts () {
+	if (hasRequiredArtefacts) return artefacts.__exports;
+	hasRequiredArtefacts = 1;
+
+	var dataflow$1 = dataflow.__require();
+	var datastructure$1 = datastructure.__require();
+	var codelist$1 = codelist.__require();
+	var categorisation$1 = categorisation.__require();
+	var categoryscheme$1 = categoryscheme.categoryscheme;
+	var conceptscheme$1 = conceptscheme.__require();
+	var contentconstraint$1 = contentconstraint.__require();
+	var dataproviderscheme$1 = dataproviderscheme.dataproviderscheme;
+	var hierarchicalcodelist$1 = hierarchicalcodelist.__require();
+	var dataconstraint$1 = dataconstraint.__require();
+	var provisionagreement$1 = provisionagreement.__require();
+	var metadatastructure$1 = metadatastructure.__require();
+	const Artefacts = [dataflow$1, datastructure$1, codelist$1, categorisation$1, categoryscheme$1, conceptscheme$1, contentconstraint$1, dataconstraint$1, dataproviderscheme$1, hierarchicalcodelist$1, provisionagreement$1, metadatastructure$1];
+	artefacts.__exports.Artefacts = Artefacts;
+	return artefacts.__exports;
+}
+
+exports.__require = requireArtefacts;

package/cjs/node_modules/@dbmx/sdmx/cjs/types/categorisation.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+require('./sdmx.cjs');
+var core = require('../core.cjs');
+var identity = require('../node_modules/ramda/es/identity.cjs');
+var sdmx = require('../../../../../_virtual/sdmx.cjs');
+
+var categorisation;
+var hasRequiredCategorisation;
+
+function requireCategorisation () {
+	if (hasRequiredCategorisation) return categorisation;
+	hasRequiredCategorisation = 1;
+
+	var sdmx$1 = sdmx.__exports;
+	var core$1 = core.__require();
+	var identity$1 = identity.identity_1;
+	function getChildRefs(input) {
+	  return [core$1.urn2FullRef(input.source), core$1.urn2FullRef(input.target)].filter(identity$1);
+	}
+	var Categorisation = sdmx$1.Artefact({
+	  name: 'categorisation',
+	  structureName: 'categorisations',
+	  packageName: 'categoryscheme',
+	  className: 'Categorisation',
+	  getChildRefs
+	});
+	categorisation = Categorisation;
+	return categorisation;
+}
+
+exports.__require = requireCategorisation;

package/cjs/node_modules/@dbmx/sdmx/cjs/types/categoryscheme.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+require('./sdmx.cjs');
+var sdmx$1 = require('../../../../../_virtual/sdmx.cjs');
+
+var sdmx = sdmx$1.__exports;
+var CategoryScheme = sdmx.ItemScheme({
+  name: 'categoryscheme',
+  structureName: 'categorySchemes',
+  packageName: 'categoryscheme',
+  className: 'CategoryScheme',
+  itemsName: 'categories'
+});
+var categoryscheme = CategoryScheme;
+
+exports.categoryscheme = categoryscheme;

package/cjs/node_modules/@dbmx/sdmx/cjs/types/codelist.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+require('./sdmx.cjs');
+var core = require('../core.cjs');
+var sdmx = require('../../../../../_virtual/sdmx.cjs');
+
+var codelist;
+var hasRequiredCodelist;
+
+function requireCodelist () {
+	if (hasRequiredCodelist) return codelist;
+	hasRequiredCodelist = 1;
+
+	var sdmx$1 = sdmx.__exports;
+	var core$1 = core.__require();
+	function getChildRefs(input) {
+	  return (input.codelistExtensions || []).map(ext => core$1.urn2FullRef(ext.codelist));
+	}
+	var Codelist = sdmx$1.ItemScheme({
+	  name: 'codelist',
+	  structureName: 'codelists',
+	  packageName: 'codelist',
+	  className: 'Codelist',
+	  itemsName: 'codes',
+	  getChildRefs
+	});
+	codelist = Codelist;
+	return codelist;
+}
+
+exports.__require = requireCodelist;

package/cjs/node_modules/@dbmx/sdmx/cjs/types/conceptscheme.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+require('./sdmx.cjs');
+var core = require('../core.cjs');
+var propOr = require('../node_modules/ramda/es/propOr.cjs');
+var sdmx = require('../../../../../_virtual/sdmx.cjs');
+
+var conceptscheme;
+var hasRequiredConceptscheme;
+
+function requireConceptscheme () {
+	if (hasRequiredConceptscheme) return conceptscheme;
+	hasRequiredConceptscheme = 1;
+
+	var sdmx$1 = sdmx.__exports;
+	var core$1 = core.__require();
+	var propOr$1 = propOr.propOr_1;
+	const getCoreRepresentations = input => {
+	  const refs = [];
+	  for (const concept of propOr$1([], 'concepts', input)) {
+	    const enumeration = concept.coreRepresentation?.enumeration;
+	    if (enumeration) refs.push(core$1.urn2FullRef(enumeration));
+	  }
+	  return refs;
+	};
+	function getChildRefs(input) {
+	  return getCoreRepresentations(input);
+	}
+	var ConcepScheme = sdmx$1.ItemScheme({
+	  name: 'conceptscheme',
+	  structureName: 'conceptSchemes',
+	  packageName: 'conceptscheme',
+	  className: 'ConceptScheme',
+	  itemsName: 'concepts',
+	  getChildRefs
+	});
+	conceptscheme = ConcepScheme;
+	return conceptscheme;
+}
+
+exports.__require = requireConceptscheme;