@dbmx/toasts 0.0.122 → 0.0.123

package/esm/node_modules/@dbmx/sdmx/cjs/core.js

@@ -0,0 +1,1001 @@
+import { __exports as core } from '../../../../_virtual/core.js';
+import require$$0 from '../../../../_virtual/index.esm.js';
+import './dependencyResolver.js';
+import { __require as requireItems } from './items.js';
+import { u as urlRegexp } from './utils/url-regexp.js';
+import './types/sdmx.js';
+import { __require as requireArtefacts } from './types/artefacts.js';
+import { p as prop_1 } from './node_modules/ramda/es/prop.js';
+import { d as dissoc_1 } from './node_modules/ramda/es/dissoc.js';
+import { p as pick_1 } from './node_modules/ramda/es/pick.js';
+import { r as reduce_1 } from './node_modules/ramda/es/reduce.js';
+import { v as values_1 } from './node_modules/ramda/es/values.js';
+import { __exports as sdmx } from '../../../../_virtual/sdmx.js';
+import { __exports as dependencyResolver } from '../../../../_virtual/dependencyResolver.js';
+
+var hasRequiredCore;
+
+function requireCore () {
+	if (hasRequiredCore) return core;
+	hasRequiredCore = 1;
+
+	var semver = require$$0;
+	var dependencyResolver$1 = dependencyResolver;
+	var items = requireItems();
+	var urlRegexp$1 = urlRegexp;
+	var sdmx$1 = sdmx;
+	var artefacts = requireArtefacts();
+	var prop = prop_1;
+	var dissoc = dissoc_1;
+	var pick = pick_1;
+	var reduce = reduce_1;
+	var values = values_1;
+
+	/**
+	 * @typedef Ref
+	 * @property {string} - Agency ID of the artefact
+	 * @property {string} - ID of the artefact
+	 * @property {string} - SemVer version of the artefact
+	 * @property {string} - Resource Type
+	 */
+
+	/**
+	 * Array of SDMX Artefact to get artefact description
+	 * @property {string} - Name used in the REST API
+	 * @property {string} - Package's name used to build the URN
+	 * @property {string} - Class's name used to build the URN
+	 * @property {string} - Name used in structure messages
+	 *
+	 * @constant
+	 * @function SDMXTypes
+	 * @tag core
+	 * @tag types
+	 *
+	 */
+	const SDMXTypes = [sdmx$1.Item({
+	  name: 'agency',
+	  packageName: 'base',
+	  className: 'Agency',
+	  schemeName: 'agencyscheme'
+	}), sdmx$1.Artefact({
+	  structureName: 'agencySchemes',
+	  name: 'agencyscheme',
+	  packageName: 'base',
+	  className: 'AgencyScheme'
+	}), sdmx$1.SDMX({
+	  name: 'dataConsumer',
+	  packageName: 'base',
+	  className: 'DataConsumer'
+	}), sdmx$1.SDMX({
+	  name: 'dataConsumerScheme',
+	  packageName: 'base',
+	  className: 'DataConsumerScheme'
+	}), sdmx$1.Item({
+	  name: 'dataProvider',
+	  packageName: 'base',
+	  className: 'DataProvider',
+	  schemeName: 'dataproviderscheme'
+	}), sdmx$1.SDMX({
+	  name: 'metadataProvider',
+	  packageName: 'base',
+	  className: 'MetadataProvider'
+	}), sdmx$1.SDMX({
+	  name: 'metadataProviderScheme',
+	  packageName: 'base',
+	  className: 'MetadataProviderScheme'
+	}), sdmx$1.SDMX({
+	  name: 'organisationUnit',
+	  packageName: 'base',
+	  className: 'OrganisationUnit'
+	}), sdmx$1.SDMX({
+	  name: 'organisationUnitScheme',
+	  packageName: 'base',
+	  className: 'OrganisationUnitScheme'
+	}), sdmx$1.SDMX({
+	  name: 'attributeDescriptor',
+	  packageName: 'datastructure',
+	  className: 'AttributeDescriptor'
+	}), sdmx$1.Component({
+	  name: 'dataAttribute',
+	  packageName: 'datastructure',
+	  className: 'DataAttribute'
+	}), sdmx$1.Component({
+	  name: 'dimension',
+	  packageName: 'datastructure',
+	  className: 'Dimension'
+	}), sdmx$1.SDMX({
+	  name: 'dimensionDescriptor',
+	  packageName: 'datastructure',
+	  className: 'DimensionDescriptor'
+	}), sdmx$1.Component({
+	  name: 'primaryMeasure',
+	  packageName: 'datastructure',
+	  className: 'PrimaryMeasure',
+	  version: 2
+	}), sdmx$1.SDMX({
+	  name: 'groupDimensionDescriptor',
+	  packageName: 'datastructure',
+	  className: 'GroupDimensionDescriptor'
+	}), sdmx$1.Component({
+	  name: 'measure',
+	  packageName: 'datastructure',
+	  className: 'Measure'
+	}), sdmx$1.SDMX({
+	  name: 'measureDescriptor',
+	  packageName: 'datastructure',
+	  className: 'MeasureDescriptor'
+	}), sdmx$1.Component({
+	  name: 'timeDimension',
+	  packageName: 'datastructure',
+	  className: 'TimeDimension'
+	}), sdmx$1.Component({
+	  name: 'metadataAttribute',
+	  packageName: 'metadatastructure',
+	  className: 'MetadataAttribute'
+	}), sdmx$1.SDMX({
+	  name: 'metadataAttributeDescriptor',
+	  packageName: 'metadatastructure',
+	  className: 'MetadataAttributeDescriptor'
+	}), sdmx$1.SDMX({
+	  name: 'metadataSet',
+	  packageName: 'metadatastructure',
+	  className: 'MetadataSet'
+	}), sdmx$1.SDMX({
+	  name: 'Process',
+	  packageName: 'process',
+	  className: 'Process'
+	}), sdmx$1.SDMX({
+	  name: 'processStep',
+	  packageName: 'process',
+	  className: 'ProcessStep'
+	}), sdmx$1.SDMX({
+	  name: 'transition',
+	  packageName: 'process',
+	  className: 'Transition'
+	}), sdmx$1.Artefact({
+	  structureName: 'metadataConstraints',
+	  name: 'metadataConstraint',
+	  packageName: 'registry',
+	  className: 'MetadataConstraint'
+	}), sdmx$1.SDMX({
+	  name: 'metadataProvisionAgreement',
+	  packageName: 'registry',
+	  className: 'MetadataProvisionAgreement'
+	}), sdmx$1.SDMX({
+	  name: 'subscription',
+	  packageName: 'registry',
+	  className: 'Subscription'
+	}), sdmx$1.SDMX({
+	  name: 'categorySchemeMap',
+	  packageName: 'structuremapping',
+	  className: 'CategorySchemeMap'
+	}), sdmx$1.SDMX({
+	  name: 'conceptSchemeMap',
+	  packageName: 'structuremapping',
+	  className: 'ConceptSchemeMap'
+	}), sdmx$1.SDMX({
+	  name: 'organisationSchemeMap',
+	  packageName: 'structuremapping',
+	  className: 'OrganisationSchemeMap'
+	}), sdmx$1.SDMX({
+	  name: 'reportingTaxonomyMap',
+	  packageName: 'structuremapping',
+	  className: 'ReportingTaxonomyMap'
+	}), sdmx$1.SDMX({
+	  name: 'representationMap',
+	  packageName: 'structuremapping',
+	  className: 'RepresentationMap'
+	}), sdmx$1.SDMX({
+	  name: 'structureMap',
+	  packageName: 'structuremapping',
+	  className: 'StructureMap'
+	}), sdmx$1.Item({
+	  name: 'category',
+	  packageName: 'categoryscheme',
+	  className: 'Category'
+	}), sdmx$1.SDMX({
+	  name: 'reportingCategory',
+	  packageName: 'categoryscheme',
+	  className: 'ReportingCategory'
+	}), sdmx$1.SDMX({
+	  name: 'reportingTaxonomy',
+	  packageName: 'categoryscheme',
+	  className: 'ReportingTaxonomy'
+	}), sdmx$1.Item({
+	  name: 'concept',
+	  packageName: 'conceptscheme',
+	  className: 'Concept'
+	}), sdmx$1.Item({
+	  name: 'code',
+	  packageName: 'codelist',
+	  className: 'Code'
+	}), sdmx$1.SDMX({
+	  name: 'hierarchy',
+	  packageName: 'codelist',
+	  className: 'Hierarchy'
+	}), sdmx$1.SDMX({
+	  name: 'hierarchyAssociation',
+	  packageName: 'codelist',
+	  className: 'HierarchyAssociation'
+	}), sdmx$1.SDMX({
+	  name: 'level',
+	  packageName: 'codelist',
+	  className: 'Level'
+	}), sdmx$1.SDMX({
+	  name: 'valueList',
+	  packageName: 'codelist',
+	  className: 'ValueList'
+	}), sdmx$1.SDMX({
+	  name: 'customType',
+	  packageName: 'transformation',
+	  className: 'CustomType'
+	}), sdmx$1.SDMX({
+	  name: 'customTypeScheme',
+	  packageName: 'transformation',
+	  className: 'CustomTypeScheme'
+	}), sdmx$1.SDMX({
+	  name: 'namePersonalisation',
+	  packageName: 'transformation',
+	  className: 'NamePersonalisation'
+	}), sdmx$1.SDMX({
+	  name: 'namePersonalisationScheme',
+	  packageName: 'transformation',
+	  className: 'NamePersonalisationScheme'
+	}), sdmx$1.SDMX({
+	  name: 'ruleset',
+	  packageName: 'transformation',
+	  className: 'Ruleset'
+	}), sdmx$1.SDMX({
+	  name: 'rulesetScheme',
+	  packageName: 'transformation',
+	  className: 'RulesetScheme'
+	}), sdmx$1.SDMX({
+	  name: 'transformation',
+	  packageName: 'transformation',
+	  className: 'Transformation'
+	}), sdmx$1.SDMX({
+	  name: 'transformationScheme',
+	  packageName: 'transformation',
+	  className: 'TransformationScheme'
+	}), sdmx$1.SDMX({
+	  name: 'userDefinedOperator',
+	  packageName: 'transformation',
+	  className: 'UserDefinedOperator'
+	}), sdmx$1.SDMX({
+	  name: 'userDefinedOperatorScheme',
+	  packageName: 'transformation',
+	  className: 'UserDefinedOperatorScheme'
+	}), sdmx$1.SDMX({
+	  name: 'vtlCodelistMapping',
+	  packageName: 'transformation',
+	  className: 'VtlCodelistMapping'
+	}), sdmx$1.SDMX({
+	  name: 'vtlConceptMapping',
+	  packageName: 'transformation',
+	  className: 'VtlConceptMapping'
+	}), sdmx$1.SDMX({
+	  name: 'vtlDataflowMapping',
+	  packageName: 'transformation',
+	  className: 'VtlDataflowMapping'
+	}), sdmx$1.SDMX({
+	  name: 'vtlMappingScheme',
+	  packageName: 'transformation',
+	  className: 'VtlMappingScheme'
+	}), ...artefacts.Artefacts];
+
+	/**
+	 * Object to get an artefact description from its structure name
+	 *
+	 * @constant
+	 * @function STRUCTURE_NAMES
+	 * @tag artefact
+	 * @tag core
+	 */
+
+	const STRUCTURE_NAMES = SDMXTypes.reduce((acc, artefact) => {
+	  acc[artefact.structureName] = artefact;
+	  return acc;
+	}, {});
+
+	/**
+	 * Object to get an artefact description from its class name
+	 *
+	 * @constant
+	 * @function CLASSES
+	 * @tag artefact
+	 * @tag core
+	 */
+
+	const CLASSES = SDMXTypes.reduce((acc, artefact) => {
+	  acc[artefact.className] = artefact;
+	  return acc;
+	}, {});
+
+	/**
+	 * Object to get an artefact description from its name
+	 *
+	 * @constant
+	 * @function RESOURCES
+	 * @tag artefact
+	 * @tag core
+	 */
+
+	const RESOURCES = SDMXTypes.reduce((acc, artefact) => {
+	  acc[artefact.name] = artefact.name;
+	  return acc;
+	}, {});
+	const hResourceTypes = SDMXTypes.reduce((acc, artefact) => {
+	  acc[artefact.name] = artefact;
+	  return acc;
+	}, {});
+	const urnType = type => `sdmx.infomodel.${type.packageName || type.name}.${type.className}`;
+	const hArtefactUrnTypes = SDMXTypes.reduce((acc, artefact) => {
+	  acc[urnType(artefact)] = artefact;
+	  return acc;
+	}, {});
+
+	/**
+	 * Returns artefact description from its name
+	 *
+	 * @function getArtefactByType
+	 * @tag artefact
+	 * @tag core
+	 * @param {string} - Artefact type
+	 * @return {AttributeDescriptor}
+	 *
+	 * @example
+	 *    getArtefactByType('dataflow') //=> ArtefactDescription
+	 */
+
+	const getArtefactByType = type => hResourceTypes[type];
+	const getItemArtefactByResourceType = resourceType => SDMXTypes.find(obj => obj.schemeName === resourceType);
+	const getArtefactByStructureName = name => STRUCTURE_NAMES[name];
+
+	/**
+	 * Returns artefact description from its URN type
+	 *
+	 * @function getArtefactByUrnType
+	 * @tag artefact
+	 * @tag core
+	 * @param {string} - Package name
+	 * @param {string} - Class name
+	 * @return {ArtefactDescription}
+	 *
+	 * @example
+	 *    getArtefactByType('dataflow') //=> ArtefactDescription
+	 */
+
+	const getArtefactByUrnType = (packageName, className) => hArtefactUrnTypes[urnType({
+	  packageName,
+	  className
+	})];
+
+	/**
+	 * Checks if the parameter is a valid artefact name
+	 *
+	 * @function isValidArtefactName
+	 * @tag artefact
+	 * @tag core
+	 * @param {string} - Artefact name to validate
+	 * @return {Boolean} - Returns true if the parameter is a valid artefact name, otherwise false
+	 */
+	const isValidArtefactName = name => STRUCTURE_NAMES[name];
+
+	/**
+	 * Checks if the parameter is a valid structure name
+	 *
+	 * @function isValidStructureName
+	 * @tag artefact
+	 * @tag core
+	 * @param {string} - Structure name to validate
+	 * @return {Boolean} - Returns true if the parameter is a valid structure name, otherwise false
+	 */
+	const isValidStructureName = name => STRUCTURE_NAMES[name];
+
+	/**
+	 * Checks if the parameter is a valid resourceType
+	 *
+	 * @function isValidResourceType
+	 * @tag artefact
+	 * @tag core
+	 * @param {string} - Resource type to validate
+	 * @return {Boolean} - Returns true if the parameter is a valid resourceType, otherwise false
+	 */
+	const isValidResourceType = type => hResourceTypes[type];
+	const SDMXPrefix = 'urn:sdmx:org';
+	// const parseURN = urn => urn.match(/^urn:sdmx:org\.sdmx\.infomodel\.(\w+)\.(\w+)=(.+):(.+)\((.+)\)(?:\.([\w.-]+))?/)
+	const parseURN = urn => urn.match(/^urn:sdmx:org\.sdmx\.infomodel\.(\w+)\.(\w+)=(.+):(.+)\((.+)\)(?:\.(.+))?/);
+
+	/**
+	 * @typedef FullRef
+	 * @property {string} - resourceType
+	 * @property {string} - agencyID
+	 * @property {string} - id
+	 * @property {string} - semver version
+	 * @property {string=} - itemId
+	 */
+
+	/**
+	 * Returns URN from full reference
+	 *
+	 * @function makeUrn
+	 * @tag core
+	 * @tag URN
+	 * @param {FullRef} - Full reference
+	 * @return {string} - URN
+	 *
+	 * @example
+	 *
+	 * makeUrn({ resourceType = 'codelist', agencyID: 'SDMX', id: 'CL_AGE', version; '1.0.1-draft') //=> 'urn:sdmx:org.sdmx.infomodel.codelist.Codelist=SDMX:CL_AGE(1.0.1-draft)'
+	 * makeUrn({ resourceType = 'codelist', agencyID: 'SDMX', id: 'CL_AGE', version; '1.0', itemId: 'YOT4') //=> 'urn:sdmx:org.sdmx.infomodel.codelist.Codelist=SDMX:CL_AGE(1.0).YOT4'
+	 */
+	const makeUrn = ({
+	  resourceType,
+	  agencyID,
+	  id,
+	  resourceId,
+	  resourceID,
+	  version,
+	  itemId,
+	  itemID
+	} = {}, type) => {
+	  const localID = id ?? resourceId ?? resourceID;
+	  const localItemID = itemId ?? itemID;
+	  if (!agencyID || !localID || !version) throw new Error(`Wrong ref to build URN: ${JSON.stringify({
+	    resourceType,
+	    agencyID,
+	    localID,
+	    version,
+	    localItemID
+	  })}`);
+	  const localType = type ?? resourceType;
+	  const artefact = getArtefactByType(localType) ?? getArtefactByStructureName(localType);
+	  if (!artefact) throw new Error(`Unknow artefact: ${localType}`);
+	  const base = `${SDMXPrefix}.${urnType(artefact)}=${agencyID}:${localID}(${version})`;
+	  if (!localItemID) return base;
+	  if (artefact.isArtefact) return base;
+	  if (artefact.isItem && artefact.name !== 'category') return `${base}.${localItemID.split('.').pop()}`;
+	  return `${base}.${localItemID}`;
+	};
+	/**
+	 * Returns full reference from URN
+	 *
+	 * @function urn2FullRef
+	 * @tag core
+	 * @tag URN
+	 * @param {string} - URN
+	 * @return  {FullRef} - Full reference
+	 *
+	 * @example
+	 *
+	 *   const urn = 'urn:sdmx:org.sdmx.infomodel.codelist.Codelist=SDMX:CL_AGE(1.0).YOT4'
+	 *   urn2FullRef(urn) //=> { resourceType = 'codelist', agencyID: 'SDMX", id: 'CL_AGE', version; '1.0', itemId: 'YOT4')
+	 */
+	const urn2FullRef = urn => {
+	  if (!urn) return;
+	  const res = parseURN(urn);
+	  if (!res) throw new Error(`Malformed URN: ${urn}`);
+	  const [_, packageName, className, agencyID, id, version, itemId] = res; // eslint-disable-line
+	  const artefact = getArtefactByUrnType(packageName, className);
+	  if (!artefact) throw new Error(`Unknow artefact for URN: ${urn}`);
+	  const resource = {
+	    resourceType: artefact.name,
+	    agencyID,
+	    id,
+	    version
+	  };
+	  if (artefact.isItem && !itemId) throw new Error(`Inconsistent urn for an item: ${urn}`);
+	  if (itemId) resource.itemId = itemId;
+	  return resource;
+	};
+	const getName = (locale, obj = {}) => obj.names?.[locale];
+	const getDescription = (locale, obj = {}) => obj.descriptions?.[locale];
+
+	/**
+	 * Returns reference from URN
+	 *
+	 * @function urn2Ref
+	 * @tag core
+	 * @tag URN
+	 * @param {string} - URN
+	 * @return  {Ref} - Reference
+	 *
+	 */
+
+	const urn2Ref = urn => dissoc('itemId', urn2FullRef(urn));
+
+	/**
+	 * @typedef SDMXVersion
+	 * @property {string} - extension
+	 * @property {number} - major
+	 * @property {number} - minor
+	 * @property {number} - patch
+	 * @property {string} - version (major.minor.patch)
+	 */
+	/**
+	 * Returns version of a meta object (structure or data message)
+	 *
+	 * @function getSdmxVersion
+	 * @tag core
+	 * @param {object} - a `meta` object from a Structure or Data SDMX message
+	 * @param {object=} - options, allow to define default version to return when previous prams to not contains a `meta` prop
+	 * @return  {SDMXVersion}
+	 *
+	 * @example
+	 *
+	 *   getSdmxVersion(meta) // => { major: '1', minor: '0', patch: '0', version: '1.0.0' )
+	 */
+	const getSdmxVersion = ({
+	  schema
+	} = {}, {
+	  defaultVersion = '2.0.0'
+	} = {}) => {
+	  if (!schema) return semver.SemVer(defaultVersion);
+	  const res = schema.match(/\/schemas\/(.*)\//);
+	  try {
+	    if (!res) return semver.SemVer(defaultVersion);
+	    return semver.SemVer(res[1]);
+	  } catch (err) {
+	    return semver.SemVer(defaultVersion);
+	  }
+	};
+
+	/**
+	 * Returns the major version of a meta object (structure or data message)
+	 *
+	 * @function getMajorSdmxVersion
+	 * @tag core
+	 * @param {object} - a `meta` object from a Structure or Data SDMX message
+	 * @param {object=} - options, allow to define default version to return when previous prams to not contains a `meta` prop
+	 * @return  {string} - Major version
+	 *
+	 * @example
+	 *
+	 *   getMajorSdmxVersion(meta) // => 1
+	 */
+	const getMajorSdmxVersion = ({
+	  schema
+	} = {}, {
+	  defaultVersion = '2.0.0'
+	} = {}) => {
+	  return getSdmxVersion({
+	    schema
+	  }, {
+	    defaultVersion
+	  }).major;
+	};
+
+	/**
+	 * Returns a reference from a resource
+	 *
+	 * @function getRef
+	 * @tag core
+	 * @tag resource
+	 * @param {object} - Input structure
+	 * @param {string=} - Resource type
+	 * @return {Ref} - pick(['agencyID', 'id', 'version'], resource)
+	 *
+	 */
+
+	const getRef = (resource = {}, resourceType) => {
+	  const localResourceType = resourceType ?? resource.resourceType;
+	  const res = pick(['id', 'agencyID', 'version'], resource);
+	  if (localResourceType) res.resourceType = localResourceType;
+	  return res;
+	};
+
+	/**
+	 * Returns a full reference from a resource
+	 *
+	 * @function getFullRef
+	 * @tag core
+	 * @tag resource
+	 * @param {object} - Input structure
+	 * @param {string=} - Resource type
+	 * @return {FullRef} - Full reference
+	 *
+	 */
+
+	const getFullRef = (resource, resourceType) => {
+	  const res = getRef(resource, resourceType);
+	  if (resource.itemId) res.itemId = resource.itemId;
+	  return res;
+	};
+
+	/**
+	 * Returns an external resource from the input
+	 *
+	 * @function makeExternal
+	 * @tag core
+	 * @tag structure
+	 * @param {string} - resourceType
+	 * @param {string} - href to get input structure
+	 * @param {object} - input structure
+	 * @return {object} - input structure converted to an external one
+	 *
+	 * @example
+	 *
+	 *   const source = {}
+	 *   const resource = makeExternal(CLASSES.Dataflow.name, 'href2', urn)
+	 *   expect(isExternal(resource).toBeTruthy()
+	 *   expect(getExternalUrl(resource)).toEqual('href2')
+	 */
+	const makeExternal = (resourceType, href, source) => {
+	  const linkRefs = {
+	    ...getRef(source),
+	    resourceType,
+	    href
+	  };
+	  return {
+	    ...pick(['id', 'agencyID', 'version', 'names', 'descriptions'], source),
+	    isExternalReference: true,
+	    links: makeLinks([selfLink(linkRefs), relLink(linkRefs)])
+	  };
+	};
+
+	/**
+	 * Returns an identifier for an artefact based on { agencyID, id, version }
+	 *
+	 * @function ID
+	 * @tag core
+	 * @param {object} - Source input
+	 * @example
+	 *
+	 *   const resource1 = { agencyID: 'AG', id: 'ID1', version: '1.0.3'}
+	 *   const resource2 = { agencyID: 'AG', id: 'ID2', version: '1.0'}
+	 *   expect(ID(resource1) !== ID(resource2)).toBeTruthy()
+	 */
+
+	const ID = ({
+	  agencyID,
+	  id,
+	  version,
+	  itemId
+	} = {}) => {
+	  if (!agencyID) throw new Error('agencyID cannot be null');
+	  if (!id) throw new Error('id cannot be null');
+	  return itemId ? `${agencyID}:${id}:${version}:${itemId}` : `${agencyID}:${id}:${version}`;
+	};
+	const fullID = (resourceType, resource) => `${resourceType}:${ID(resource)}`;
+	const refFullID = (ref, resourceType) => `${resourceType ?? ref.resourceType}:${ID(ref)}`;
+
+	/**
+	 * Returns if a version is patterned (contains '+') - do not check if Range(version) is valid
+	 *
+	 * @function isPatternedVersion
+	 * @tag core
+	 * @tag version
+	 * @param {string} - Version
+	 *
+	 * @example
+	 *
+	 *   expect(isPatternedVersion('3.2+.0')).toBeTruthy()
+	 *   expect(isPatternedVersion('3.2.0')).toBeFalsy()
+	 */
+
+	const isPatternedVersion = version => version && version.indexOf('+') !== -1;
+
+	/**
+	 * Returns if a source artefact is semver compatible with a target one
+	 *
+	 * @function isTargetVersionCompatible
+	 * @tag core
+	 * @tag semver
+	 * @param {object} - { version }
+	 * @param {object} - { version }
+	 *
+	 * @example
+	 *
+	 *   expect(isTargetVersionCompatible({ version: '3.2.0'}, { version: '1.0'})).toBeFalsy()
+	 */
+
+	const isTargetVersionCompatible = (source = {}, target = {}) => {
+	  const sourceIsStable = semver.SemVer(source.version).isStable();
+	  return !sourceIsStable || semver.SemVer(target.version).isStable();
+	};
+
+	/**
+	 * Resolves an item from a structure
+	 *
+	 * @function resolveItemFromStructure
+	 * @tag core
+	 * @tag item
+	 * @param {object} - SDMX structure
+	 * @param {FullRef} - source resource
+	 * @param {FullRef} - item's fullRef
+	 *
+	 */
+
+	const resolveItemFromStructure = ({
+	  data = {}
+	} = {}, source, ref = {}) => {
+	  if (!ref.itemId) throw new Error(`Wrong fullRef '${JSON.stringify(ref)}': 'itemId' is required to get an item!`);
+	  const toType = getArtefactByType(ref.resourceType);
+	  const resources = getResourcesFromStructure({
+	    data
+	  }, toType.schemeName);
+	  // const resource = resolveDependency(resources, source, getRef(ref, toType.schemeName))
+	  const resource = dependencyResolver$1.resolveDependency(resources, source, getRef(ref));
+	  const items$1 = items.getFullyQualifiedItems(items.getItems(toType.schemeName, resource), {
+	    flatten: true
+	  });
+	  let item;
+	  if (toType.name === 'category') item = items$1.find(item => item.fullId === ref.itemId);else item = items$1.find(item => item.id === ref.itemId);
+	  return {
+	    resource,
+	    item
+	  };
+	};
+
+	/**
+	 * Gets structure.data[resourceType]
+	 *
+	 * @function getResourcesFromStructure
+	 * @tag core
+	 * @param {object} - SDMX structure
+	 * @param {type} - resourceType | structureName
+	 * @return {object} - structure.data[resourceType]
+	 *
+	 */
+
+	const getResourcesFromStructure = ({
+	  data = {}
+	} = {}, type) => data[type] ?? data[getArtefactByType(type)?.structureName] ?? [];
+
+	/**
+	 * Gets fullRef from structure
+	 *
+	 * @function getResourceFromStructure
+	 * @tag core
+	 * @param {object} - SDMX structure
+	 * @param {FullRef} - fullRef
+	 * @param {string} - resourceType
+	 * @return {object} - resource
+	 *
+	 */
+
+	const getResourceFromStructure = (structure = {}, fullRef = {}, type) => {
+	  const resources = getResourcesFromStructure(structure, fullRef.resourceType ?? type);
+	  return resources.find(resource => ID(resource) === ID(fullRef));
+	};
+
+	/**
+	 * Resolved resource from structure
+	 *
+	 * @function resolveResourceFromStructure
+	 * @tag core
+	 * @param {object} - SDMX structure
+	 * @param {object} - { version } of the source dependency
+	 * @param {Ref} - Ref of the target dependency
+	 * @return {object} - resolved resource
+	 *
+	 * @example
+	 *
+	 * const structure = {
+	 *     data: {
+	 *       categorySchemes: [artefact],
+	 *     },
+	 *   }
+	 *   const res = resolveResourceFromStructure(
+	 *     structure,
+	 *     { version: '1.0.0' },
+	 *     { ...getRef(artefact, 'categoryscheme'), version: '1+.0.0' },
+	 *   )
+	 *   expect(res).toEqual(artefact)
+	 *
+	 */
+	const resolveResourceFromStructure = ({
+	  data = {}
+	} = {}, source, ref = {}, {
+	  noError
+	} = {}) => {
+	  const resources = getResourcesFromStructure({
+	    data
+	  }, ref.resourceType);
+	  try {
+	    const res = dependencyResolver$1.resolveDependency(resources, source, getRef(ref));
+	    return res;
+	  } catch (err) {
+	    if (err instanceof semver.SemVerError) {
+	      if (noError) return;
+	      throw err;
+	    } else throw err;
+	  }
+	};
+
+	/**
+	 * Gets a Map of resources indexed by URN from structure
+	 *
+	 * @function getURNResourcesMapFromStructure
+	 * @tag core
+	 * @param {object} - SDMX structure
+	 *
+	 *
+	 */
+
+	const getURNResourcesMapFromStructure = ({
+	  data = {}
+	} = {}) => {
+	  const res = new Map();
+	  for (const structureName of Object.keys(data)) {
+	    for (const resource of data[structureName]) res.set(makeUrn(resource, structureName), resource);
+	  }
+	  return res;
+	};
+	const isUrlRegex = url => urlRegexp$1.test(url);
+
+	/**
+	 * Gets the latest minor version for a provided source version
+	 *
+	 * @function getLatestMinor
+	 * @tag core
+	 * @param {string} - Version
+	 * @return  {string} - Latest minor version
+	 * @example
+	 *
+	 *   getLatestMinor({ version: '1.0.0-draft' })
+	 */
+	const getLatestMinor = version => {
+	  const semver$1 = semver.SemVer(version);
+	  if (semver$1.patch === null) return `${semver$1.major}.${semver$1.minor}`;
+	  return `${semver$1.major}.${semver$1.minor}+.${semver$1.patch}`;
+	};
+
+	/**
+	 * Retrieves the data structure from an artefact based on the provided full reference
+	 * This function is particularly useful for obtaining the data structure associated with a specific artefact
+	 *
+	 * @function getDataStructureFromArtefact
+	 * @param {object} structure - SDMX structure object containing data
+	 * @param {FullRef} fullRef - Full reference of the artefact
+	 * @throws {Error} - Throws an error if the data structure cannot be retrieved
+	 */
+	const getDataStructureFromArtefact = (structure, fullRef) => {
+	  const target = getResourceFromStructure(structure, fullRef);
+	  if (!target) throw new Error(`Cannot get dataStructure for ${JSON.stringify(fullRef)}!`);
+	  if (fullRef.resourceType === 'dataflow') return [resolveResourceFromStructure(structure, target, urn2FullRef(target.structure)), target];
+	  return [target, target];
+	};
+
+	/**
+	 * Returns an object link with `rel` === 'self'
+	 *
+	 * @function selfLink
+	 * @tag links
+	 * @param {FullRef} - resource
+	 *
+	 */
+
+	const selfLink = ({
+	  resourceType,
+	  agencyID,
+	  id,
+	  version,
+	  itemId
+	}) => ({
+	  rel: 'self',
+	  urn: makeUrn({
+	    resourceType,
+	    agencyID,
+	    id,
+	    version,
+	    itemId
+	  })
+	});
+
+	/**
+	 * Returns an object link with `rel` === 'external'
+	 *
+	 * @function relLink
+	 * @tag links
+	 * @param {FullRef} - resource
+	 *
+	 */
+
+	const relLink = ({
+	  href,
+	  resourceType,
+	  agencyID,
+	  id,
+	  version
+	}) => ({
+	  rel: 'external',
+	  urn: makeUrn({
+	    resourceType,
+	    agencyID,
+	    id,
+	    version
+	  }),
+	  href
+	});
+	const makeLinks = links => {
+	  const hrels = reduce((acc, link) => ({
+	    ...acc,
+	    [link.rel]: link
+	  }), {}, links);
+	  return values(hrels);
+	};
+
+	/**
+	 * Returns true if resource is external
+	 *
+	 * @function isExternal
+	 * @tag links
+	 * @tag core
+	 * @param {Artefact} - resource
+	 *
+	 */
+
+	const isExternal = prop('isExternalReference');
+
+	/**
+	 * Returns external reference from an external Artefact
+	 *
+	 * @function getExternalUrl
+	 * @tag core
+	 * @param {Artefact} - external resource
+	 *
+	 */
+
+	const getExternalUrl = ({
+	  isExternalReference,
+	  links = []
+	}) => {
+	  if (!isExternalReference) return;
+	  return getLinkType('external', links)?.href;
+	};
+
+	/**
+	 * Retrieves the link of a specific type from a list of links
+	 *
+	 * @function getLinkType
+	 * @param {string} type - Link type to retrieve (e.g., 'external', 'self')
+	 * @param {Array} links - Aarray of link objects
+	 * @return {object|undefined} - Link object of the specified type, or undefined if not found
+	 */
+	const getLinkType = (type, links = []) => links.find(link => link.rel === type);
+	core.CLASSES = CLASSES;
+	core.ID = ID;
+	core.RESOURCES = RESOURCES;
+	core.SDMXTypes = SDMXTypes;
+	core.STRUCTURE_NAMES = STRUCTURE_NAMES;
+	core.fullID = fullID;
+	core.getArtefactByStructureName = getArtefactByStructureName;
+	core.getArtefactByType = getArtefactByType;
+	core.getArtefactByUrnType = getArtefactByUrnType;
+	core.getDataStructureFromArtefact = getDataStructureFromArtefact;
+	core.getDescription = getDescription;
+	core.getExternalUrl = getExternalUrl;
+	core.getFullRef = getFullRef;
+	core.getItemArtefactByResourceType = getItemArtefactByResourceType;
+	core.getLatestMinor = getLatestMinor;
+	core.getLinkType = getLinkType;
+	core.getMajorSdmxVersion = getMajorSdmxVersion;
+	core.getName = getName;
+	core.getRef = getRef;
+	core.getResourceFromStructure = getResourceFromStructure;
+	core.getResourcesFromStructure = getResourcesFromStructure;
+	core.getSdmxVersion = getSdmxVersion;
+	core.getURNResourcesMapFromStructure = getURNResourcesMapFromStructure;
+	core.isExternal = isExternal;
+	core.isPatternedVersion = isPatternedVersion;
+	core.isTargetVersionCompatible = isTargetVersionCompatible;
+	core.isUrlRegex = isUrlRegex;
+	core.isValidArtefactName = isValidArtefactName;
+	core.isValidResourceType = isValidResourceType;
+	core.isValidStructureName = isValidStructureName;
+	core.makeExternal = makeExternal;
+	core.makeLinks = makeLinks;
+	core.makeUrn = makeUrn;
+	core.refFullID = refFullID;
+	core.relLink = relLink;
+	core.resolveItemFromStructure = resolveItemFromStructure;
+	core.resolveResourceFromStructure = resolveResourceFromStructure;
+	core.selfLink = selfLink;
+	core.urn2FullRef = urn2FullRef;
+	core.urn2Ref = urn2Ref;
+	return core;
+}
+
+export { requireCore as __require };
+//# sourceMappingURL=core.js.map