@dbmx/toasts 0.0.122 → 0.0.123

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

@@ -0,0 +1,234 @@
+'use strict';
+
+var core = require('./core.cjs');
+var isNil$1 = require('./node_modules/ramda/es/isNil.cjs');
+
+core.__require();
+var isNil = isNil$1.isNil_1;
+
+/**
+ * Fills a slice of an array with a specified value
+ *
+ * @function fillSlice
+ * @param {number} - Starting index of the slice
+ * @param {number} - Size of the slice
+ * @param {Array} - Input array
+ * @param {*} - Value to fill the slice with
+ * @return {Array} - Filled slice
+ *
+ * @example
+ * const filledSlice = fillSlice(0, 3, ['a', 'b', 'c'], 'x');
+ */
+const fillSlice = (start, size = -1, input = [], value = null) => {
+  const d1 = input.slice(start, start + size);
+  if (size - d1.length < 0) return d1;
+  const d2 = new Array(size - d1.length).fill(value);
+  return d1.concat(d2);
+};
+
+// export const fillSlice = (start, size, input = [], value = null) => {
+//   const d1 = input.slice(start, size)
+//   if (size - d1.length < 0) return d1
+//   const d2 = times(() => value, size - d1.length)
+//   return d1.concat(d2)
+// }
+
+const getListedComponentValue = (component, value) => {
+  if (value === null) {
+    if (component.default) {
+      const dvalue = component.values.find(v => v?.id === component.default);
+      if (dvalue === -1) throw new Error(`Cannot get default value for component ${component.id}!`);
+      return dvalue;
+    }
+    return null;
+  } else {
+    const cvalue = component.values[value];
+    if (cvalue === undefined) throw new Error(`Cannot get value idx ${value} for component ${component.id}!`);
+    return cvalue;
+  }
+};
+const getComponentValue = (component, value) => {
+  if (!component.values) {
+    // not listed
+    if (value === null) return null;else return {
+      value
+    };
+  } else {
+    return getListedComponentValue(component, value);
+  }
+};
+const getObsValues = (components, values) => {
+  const res = {};
+  for (const [idx, value] of values.entries()) {
+    const component = components[idx];
+    if (!component) throw new Error(`Cannot get dataset component idx ${idx}!`);
+    const v = getComponentValue(component, value);
+    if (!isNil(v)) res[component.id] = getComponentValue(component, value);
+  }
+  return res;
+};
+
+/**
+ * Gets the dimensions of a dataset
+ *
+ * @function getdSetDimensions
+ * @param {object} - Structure object
+ * @return {object} - Dataset dimensions
+ *
+ */
+const getdSetDimensions = structure => {
+  const dimensions = structure?.dimensions?.dataSet ?? [];
+  const res = {};
+  for (const dimension of dimensions) {
+    const v = getListedComponentValue(dimension, 0);
+    if (!isNil(v)) res[dimension.id] = v;
+  }
+  return res;
+};
+
+/**
+ * Gets the attributes of a dataset
+ *
+ * @function getdSetAttributes
+ * @param {object} - Dataset object
+ * @param {object} - Structure object
+ * @return {object} - Dataset attributes
+ *
+ */
+const getdSetAttributes = (dataset, structure) => {
+  const attributes = structure?.attributes?.dataSet ?? [];
+  const values = fillSlice(0, attributes.length, dataset?.attributes ?? []);
+  return getObsValues(attributes, values);
+};
+const unpackDimensions = (key = '') => key.split(':');
+
+/**
+ * Gets the dimensions of an observation
+ *
+ * @function getObsDimensions
+ * @param {object} - Structure object
+ * @param {string} - Observation key
+ * @return {object} - Observation dimensions
+ *
+ */
+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 v = getComponentValue(dimension, idxValue);
+    if (!isNil(v)) res[dimension.id] = v;
+  }
+  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);
+};
+
+/**
+ * Gets the attributes of an observation.
+ *
+ * @function getObsAttributes
+ * @param {object} structure - Structure object
+ * @param {Array} values - Observation value
+ * @return {object} - Observation attributes
+ *
+ */
+const getObsAttributes = (structure, values) => {
+  const attributes = structure?.attributes?.observation || [];
+  return getObsValues(attributes, values);
+};
+const getKeyAttributes = (dataset, structure, key) => {
+  return {
+    ...getdSetAttributes(dataset, 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 || [];
+  return getObsValues(measures, values);
+};
+const getFullDimKey = (datasetStructure, dimKey) => `${'0:'.repeat(datasetStructure.dimensions?.dataSet?.length ?? 0)}${dimKey}`;
+const getDimensions = (structure, key) => {
+  return {
+    ...getdSetDimensions(structure),
+    ...getObsDimensions(structure, key)
+  };
+};
+
+/**
+ * Checks if an observation key matches a dimension group key.
+ *
+ * @function dimGroupKeyMatches
+ * @param {string} - Observation key
+ * @param {string} - DimensionGroup key
+ * @return {boolean} - True if the keys match, otherwise false
+ *
+ */
+const dimGroupKeyMatches = (obsKey, grpKey) => {
+  const obsValues = obsKey.split(':');
+  const grpValues = grpKey.split(':');
+  if (obsValues.length !== grpValues.length) throw new Error(`Inconsistent  dimensionGroupAttributes key ${grpKey}`);
+  for (const [idx, obsValue] of obsValues.entries()) {
+    const grpValue = grpValues[idx];
+    if (grpValue !== '' && grpValue !== '~' && obsValue !== grpValue) return false;
+  }
+  return true;
+};
+const getMatchedDimensionGroupAttributes = (structure, dataset, key) => {
+  let res = {};
+  const fullDimKey = getFullDimKey(structure, key);
+  const attributes = structure?.attributes?.dimensionGroup || [];
+  for (const grpKey in dataset.dimensionGroupAttributes || {}) {
+    if (dimGroupKeyMatches(fullDimKey, grpKey)) {
+      const values = fillSlice(0, attributes.length, dataset.dimensionGroupAttributes[grpKey]);
+      const dimAttrs = getObsValues(attributes, values);
+      for (const id in dimAttrs) {
+        if (dimAttrs[id] !== null) res[id] = dimAttrs[id];
+      }
+    }
+  }
+  return res;
+};
+
+/**
+ * Generates observations
+ *
+ * @function getObservations
+ * @param {object} dataStructure - Data structure object
+ * @param {object} - Options object
+ * @param {number} - Dataset index
+ * @yields {object} - Observations
+ *
+ */
+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(dataSet, structure, observations[key]),
+      ...getMatchedDimensionGroupAttributes(structure, dataSet, key)
+    };
+    yield obs;
+  }
+}
+var getObservations_1 = getObservations;
+
+exports.getObservations = getObservations_1;

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

@@ -0,0 +1,86 @@
+'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];
+};
+
+/**
+ * Resolves a dependency by finding the appropriate resource based on a version range and returns an external resource from the input
+ *
+ * @function resolveDependency
+ * @tag dependency
+ * @param {array} - Array of all possible resources
+ * @param {object} - Source object representing the dependency source
+ * @param {object} - Reference object representing the target version
+ * @param {object} - Options object (optional)
+ * @param {boolean} - Flag to indicate whether to suppress errors ([noError=false])
+ * @return {object | undefined} - The resolved resource that matches the reference and version range, or undefined if not found (depending on the 'noError' flag)
+ * @throws {Error} - Throws an error if 'noError' flag is not set and resolution fails
+ *
+ * @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;
+  }
+};
+
+/**
+ * Resolves a data target by finding the appropriate resource based on a version range
+ *
+ * @function resolveDataTarget
+ * @tag dependency
+ * @param {Array} - Array of all possible resources
+ * @param {object} - Reference object representing the target version
+ * @return {object | undefined} - The resolved resource that matches the reference and version range, or undefined if not found
+ */
+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,148 @@
+'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();
+
+	/**
+	 * Retrieves fully qualified items for parent and categories relations
+	 *
+	 * @function getFullyQualifiedItems
+	 * @tag items
+	 * @tag structure
+	 * @param {array} - Array of items
+	 * @param {object} - Options object [flatten: bool: get flatten array of items]
+	 * @returns {array} - Array of fully qualified items
+	 * @throws {Error} - Throws an error if an invalid code is encountered
+	 *
+	 * @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);
+	};
+
+	/**
+	 * Retrieves items for a specified resourceType
+	 *
+	 * @function getItems
+	 * @tag items
+	 * @tag structure
+	 * @param {string} - resourceType
+	 * @param {object} - Values object containing items
+	 * @return {array} - Array of items for the specified resourceType
+	 * @throws {Error} - Throws an error if an invalid resourceType is provided.
+	 *
+	 * @example
+	 *
+	 *   const codes = [
+	 *     { id: 'A', names: { fr: 'A' } },
+	 *     { id: 'E', names: { fr: 'E' } },
+	 *     { id: 'F', parent: 'E', names: { fr: 'F' } },
+	 *     { id: 'B', parent: 'A', names: { fr: 'B' } },
+	 *     { id: 'C', parent: 'A', names: { it: 'C' } },
+	 *     { id: 'D', parent: 'B', names: { fr: 'DD' } },
+	 *   ]
+	 *
+	 *   const categories = [
+	 *     {
+	 *       id: 'A',
+	 *       categories: [
+	 *         {
+	 *           id: 'B',
+	 *           categories: [{ id: 'D' }],
+	 *         },
+	 *         { id: 'C' },
+	 *       ],
+	 *     },
+	 *     {
+	 *       id: 'E',
+	 *       categories: [{ id: 'F' }],
+	 *     },
+	 *   ]
+	 *
+	 *   expect(getItems('codelist', { codes }).length).toEqual(6)
+	 *   expect(getItems('categoryscheme', { categories }).length).toEqual(2)
+	 *   expect(() => getItems(RESOURCES.dataflow, {})).toThrow()
+	 *
+	 */
+
+	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;