cocoda-sdk 3.2.3 → 3.3.1

package/dist/cjs/index.cjs

@@ -32,13 +32,15 @@ __export(src_exports, {
   LocApiProvider: () => LocApiProvider,
   LocalMappingsProvider: () => LocalMappingsProvider,
   MappingsApiProvider: () => MappingsApiProvider,
+  MyCoReProvider: () => MyCoReProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
   SkohubProvider: () => SkohubProvider,
   SkosmosApiProvider: () => SkosmosApiProvider,
   addAllProviders: () => addAllProviders,
   cdk: () => cdk,
-  errors: () => errors_exports
+  errors: () => errors_exports,
+  utils: () => utils_exports
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -112,7 +114,7 @@ var import_omit = __toESM(require("lodash/omit.js"), 1);
 var import_concat = __toESM(require("lodash/concat.js"), 1);
 
 // src/lib/CocodaSDK.js
-var import_jskos_tools11 = __toESM(require("jskos-tools"), 1);
+var import_jskos_tools12 = __toESM(require("jskos-tools"), 1);
 
 // src/providers/index.js
 var providers_exports = {};
@@ -123,6 +125,7 @@ __export(providers_exports, {
   LocApiProvider: () => LocApiProvider,
   LocalMappingsProvider: () => LocalMappingsProvider,
   MappingsApiProvider: () => MappingsApiProvider,
+  MyCoReProvider: () => MyCoReProvider,
   OccurrencesApiProvider: () => OccurrencesApiProvider,
   ReconciliationApiProvider: () => ReconciliationApiProvider,
   SkohubProvider: () => SkohubProvider,
@@ -134,6 +137,13 @@ var import_jskos_tools = __toESM(require("jskos-tools"), 1);
 var import_axios = __toESM(require("axios"), 1);
 
 // src/utils/index.js
+var utils_exports = {};
+__export(utils_exports, {
+  concatUrl: () => concatUrl,
+  listOfCapabilities: () => listOfCapabilities,
+  requestMethods: () => requestMethods,
+  withCustomProps: () => withCustomProps
+});
 var requestMethods = [
   {
     method: "getRegistries",
@@ -347,8 +357,8 @@ var BaseProvider = class {
       }
       return config;
     });
-    this.axios.interceptors.response.use(({ data, headers = {}, config = {} }) => {
-      data = import_jskos_tools.default.normalize(data);
+    this.axios.interceptors.response.use(({ data: data3, headers = {}, config = {} }) => {
+      data3 = import_jskos_tools.default.normalize(data3);
       let url = config.url;
       if (!url.endsWith("?")) {
         url += "?";
@@ -356,14 +366,14 @@ var BaseProvider = class {
       import_forOwn.default(config.params || {}, (value, key) => {
         url += `${key}=${encodeURIComponent(value)}&`;
       });
-      if (import_isArray.default(data) || import_isObject.default(data)) {
+      if (import_isArray.default(data3) || import_isObject.default(data3)) {
         let totalCount = parseInt(headers["x-total-count"]);
         if (!isNaN(totalCount)) {
-          data._totalCount = totalCount;
+          data3._totalCount = totalCount;
         }
-        data._url = url;
+        data3._url = url;
       }
-      return data;
+      return data3;
     }, (error) => {
       const count = import_get.default(error, "config._retryCount", 0);
       const method = import_get.default(error, "config.method");
@@ -592,7 +602,7 @@ var BaseProvider = class {
       return (await this.getConcepts({ ...config, concepts: [concept] }))[0];
     };
     for (let type of ["broader", "narrower", "ancestors"]) {
-      if (Array.isArray(concept[type]) && !concept[type].includes(null)) {
+      if (Array.isArray(concept[type]) && concept[type].length && !concept[type].includes(null)) {
         concept[type] = this.adjustConcepts(concept[type]);
       }
     }
@@ -1391,9 +1401,13 @@ MappingsApiProvider.stored = true;
 
 // src/providers/occurrences-api-provider.js
 var import_jskos_tools4 = __toESM(require("jskos-tools"), 1);
+var cache = {};
 var OccurrencesApiProvider = class extends BaseProvider {
+  get _cache() {
+    return cache[this.uri];
+  }
   _prepare() {
-    this._cache = [];
+    cache[this.uri] = [];
     this._occurrencesSupportedSchemes = [];
     this.has.occurrences = true;
     this.has.mappings = true;
@@ -1406,11 +1420,11 @@ var OccurrencesApiProvider = class extends BaseProvider {
     } else {
       try {
         const url = concatUrl(this._api.api, "voc");
-        const data = await this.axios({
+        const data3 = await this.axios({
           method: "get",
           url
         });
-        this._occurrencesSupportedSchemes = data || [];
+        this._occurrencesSupportedSchemes = data3 || [];
       } catch (error) {
       }
     }
@@ -1524,19 +1538,19 @@ var OccurrencesApiProvider = class extends BaseProvider {
     if (resultsFromCache) {
       return resultsFromCache.data;
     }
-    const data = await this.axios({
+    const data3 = await this.axios({
       ...config,
       method: "get",
       url: this._api.api
     });
     this._cache.push({
       config,
-      data
+      data: data3
     });
     if (this._cache.length > 20) {
-      this._cache = this._cache.slice(this._cache.length - 20);
+      cache[this.uri] = this._cache.slice(this._cache.length - 20);
     }
-    return data;
+    return data3;
   }
 };
 OccurrencesApiProvider.providerName = "OccurrencesApi";
@@ -1746,34 +1760,34 @@ var ConceptApiProvider = class extends BaseProvider {
       }
     });
   }
-  async suggest({ use = "notation,label", types = [], sort = "score", ...config }) {
+  async suggest({ use = "notation,label", types = [], sort = "score", params = {}, ...config }) {
     return this._search({
       ...config,
       endpoint: "suggest",
       params: {
-        ...config.params,
+        ...params,
         type: types.join("|"),
         use,
         sort
       }
     });
   }
-  async search({ types = [], ...config }) {
+  async search({ types = [], params = {}, ...config }) {
     return this._search({
       ...config,
       endpoint: "search",
       params: {
-        ...config.params,
+        ...params,
         type: types.join("|")
       }
     });
   }
-  async vocSuggest({ use = "notation,label", sort = "score", ...config }) {
+  async vocSuggest({ use = "notation,label", sort = "score", params = {}, ...config }) {
     return this._search({
       ...config,
       endpoint: "voc-suggest",
       params: {
-        ...config.params,
+        ...params,
         use,
         sort
       }
@@ -1785,8 +1799,8 @@ var ConceptApiProvider = class extends BaseProvider {
       endpoint: "voc-search"
     });
   }
-  async _search({ endpoint, scheme, search, limit, offset, params, ...config }) {
-    let url = this._api[endpoint];
+  async _search({ endpoint, scheme, search, limit, offset, params, url, ...config }) {
+    url = url ?? this._api[endpoint];
     if (!url) {
       throw new MissingApiUrlError();
     }
@@ -1836,9 +1850,13 @@ ConceptApiProvider.providerType = "http://bartoc.org/api-type/jskos";
 
 // src/providers/reconciliation-api-provider.js
 var import_jskos_tools6 = __toESM(require("jskos-tools"), 1);
+var cache2 = {};
 var ReconciliationApiProvider = class extends BaseProvider {
+  get _cache() {
+    return cache2[this.uri];
+  }
   _prepare() {
-    this._cache = [];
+    cache2[this.uri] = [];
     this.has.mappings = true;
     listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
       this.has[c] = false;
@@ -1950,22 +1968,22 @@ var ReconciliationApiProvider = class extends BaseProvider {
     }
     const encodedData = `queries=${encodeURIComponent(JSON.stringify(queries))}`;
     import_set.default(config, ["headers", "Content-Type"], "application/x-www-form-urlencoded");
-    let data = await this.axios({
+    let data3 = await this.axios({
       ...config,
       method: "post",
       url,
       data: encodedData
     });
-    data = data || {};
+    data3 = data3 || {};
     let newCacheEntry = {
       labels,
       language,
-      data,
+      data: data3,
       url: `${url}${url.includes("?") ? "&" : "?"}${encodedData}`
     };
     this._cache.push(newCacheEntry);
     if (this._cache.length > 20) {
-      this._cache = this._cache.slice(this._cache.length - 20);
+      cache2[this.uri] = this._cache.slice(this._cache.length - 20);
     }
     return newCacheEntry;
   }
@@ -1984,7 +2002,7 @@ var LabelSearchSuggestionProvider = class extends BaseProvider {
     });
   }
   supportsScheme(scheme) {
-    return import_get.default(scheme, "_registry.has.search", false);
+    return super.supportsScheme(scheme) && import_get.default(scheme, "_registry.has.search", false);
   }
   async getMappings({ from, to, mode, selected, limit = 10, ...config }) {
     if (mode != "or") {
@@ -2059,8 +2077,10 @@ var LabelSearchSuggestionProvider = class extends BaseProvider {
     if (!registry || registry.has.search === false) {
       return [];
     }
-    const data = await registry.search({
+    let url = this._jskos.overrides.find((o) => import_jskos_tools7.default.compare(o, targetScheme))?.search;
+    const data3 = await registry.search({
       ...config,
+      url,
       search: label,
       scheme: targetScheme,
       limit
@@ -2068,9 +2088,9 @@ var LabelSearchSuggestionProvider = class extends BaseProvider {
     if (!this._cache[targetScheme.uri]) {
       this._cache[targetScheme.uri] = {};
     }
-    this._cache[targetScheme.uri][label] = data;
+    this._cache[targetScheme.uri][label] = data3;
     this._cache[targetScheme.uri][label]._limit = limit;
-    return data;
+    return data3;
   }
 };
 LabelSearchSuggestionProvider.providerName = "LabelSearchSuggestion";
@@ -2141,11 +2161,11 @@ var SkosmosApiProvider = class extends BaseProvider {
       return null;
     }
     const url = this._getApiUrl(scheme, "/");
-    const data = await this.axios({
+    const data3 = await this.axios({
       method: "get",
       url
     });
-    const resultScheme = data.conceptschemes.find((s) => import_jskos_tools8.default.compare(s, scheme));
+    const resultScheme = data3.conceptschemes.find((s) => import_jskos_tools8.default.compare(s, scheme));
     if (resultScheme) {
       this._approvedSchemes.push({
         uri: resultScheme.uri,
@@ -2236,12 +2256,12 @@ var SkosmosApiProvider = class extends BaseProvider {
     const schemes = [];
     for (let scheme of this.schemes || []) {
       const url = this._getApiUrl(scheme, "/");
-      const data = await this.axios({
+      const data3 = await this.axios({
         ...config,
         method: "get",
         url
       });
-      const resultScheme = data.conceptschemes.find((s) => import_jskos_tools8.default.compare(s, scheme));
+      const resultScheme = data3.conceptschemes.find((s) => import_jskos_tools8.default.compare(s, scheme));
       const label = resultScheme && (resultScheme.prefLabel || resultScheme.label || resultScheme.title);
       if (label) {
         import_set.default(scheme, `prefLabel.${this._language}`, label);
@@ -2442,28 +2462,28 @@ var supportedSchemes = [
   }
 ];
 var lccUri = `${locUriPrefix}classification`;
-function madsToJskosItem(data) {
+function madsToJskosItem(data3) {
   const item = {};
-  item.uri = data["@id"];
-  item.notation = (data["http://www.loc.gov/mads/rdf/v1#code"] || []).map((n) => n["@value"]);
-  const prefLabelArray = data["http://www.loc.gov/mads/rdf/v1#authoritativeLabel"] || data["http://www.w3.org/2000/01/rdf-schema#label"] || [];
+  item.uri = data3["@id"];
+  item.notation = (data3["http://www.loc.gov/mads/rdf/v1#code"] || []).map((n) => n["@value"]);
+  const prefLabelArray = data3["http://www.loc.gov/mads/rdf/v1#authoritativeLabel"] || data3["http://www.w3.org/2000/01/rdf-schema#label"] || [];
   if (prefLabelArray.length) {
     item.prefLabel = {};
     item.prefLabel[prefLabelArray[0]["@language"] || "en"] = prefLabelArray[0]["@value"];
   }
-  const altLabelArray = data["http://www.w3.org/2004/02/skos/core#altLabel"] || [];
+  const altLabelArray = data3["http://www.w3.org/2004/02/skos/core#altLabel"] || [];
   if (altLabelArray.length) {
     item.altLabel = { en: altLabelArray.map((l) => l["@value"]) };
   }
-  for (let definition of data["http://www.w3.org/2000/01/rdf-schema#comment"] || []) {
+  for (let definition of data3["http://www.w3.org/2000/01/rdf-schema#comment"] || []) {
     item.definition = item.definition || {};
     item.definition.en = item.definition.en || [];
     item.definition.en.push(definition["@value"]);
   }
   return item;
 }
-function madsToJskosScheme(data) {
-  const scheme = madsToJskosItem(data);
+function madsToJskosScheme(data3) {
+  const scheme = madsToJskosItem(data3);
   scheme.namespace = scheme.uri + "/";
   scheme.type = ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
   return scheme;
@@ -2474,16 +2494,16 @@ var schemeNamespaceFilter = (scheme) => (c) => {
   }
   return c.uri.startsWith(scheme.namespace);
 };
-function madsToJskosConcept(data, { scheme }) {
-  const concept = madsToJskosItem(data);
+function madsToJskosConcept(data3, { scheme }) {
+  const concept = madsToJskosItem(data3);
   concept.type = ["http://www.w3.org/2004/02/skos/core#Concept"];
-  concept.inScheme = scheme ? [scheme] : (data["http://www.loc.gov/mads/rdf/v1#isMemberOfMADSScheme"] || []).map((s) => supportedSchemes.find((s2) => s2.uri === s["@id"]));
+  concept.inScheme = scheme ? [scheme] : (data3["http://www.loc.gov/mads/rdf/v1#isMemberOfMADSScheme"] || []).map((s) => supportedSchemes.find((s2) => s2.uri === s["@id"]));
   if (!concept.inScheme.length || !concept.inScheme[0]) {
     delete concept.inScheme;
   }
-  const narrower = data["http://www.loc.gov/mads/rdf/v1#hasNarrowerAuthority"] || import_jskos_tools9.default.compare(concept.inScheme[0], { uri: lccUri }) && data["http://www.loc.gov/mads/rdf/v1#hasMADSCollectionMember"] || [];
+  const narrower = data3["http://www.loc.gov/mads/rdf/v1#hasNarrowerAuthority"] || import_jskos_tools9.default.compare(concept.inScheme[0], { uri: lccUri }) && data3["http://www.loc.gov/mads/rdf/v1#hasMADSCollectionMember"] || [];
   concept.narrower = narrower.map((n) => ({ uri: n["@id"] })).filter(schemeNamespaceFilter(concept.inScheme && concept.inScheme[0]));
-  const broader = data["http://www.loc.gov/mads/rdf/v1#hasBroaderAuthority"] || import_jskos_tools9.default.compare(concept.inScheme[0], { uri: lccUri }) && data["http://www.loc.gov/mads/rdf/v1#isMemberOfMADSCollection"] || [];
+  const broader = data3["http://www.loc.gov/mads/rdf/v1#hasBroaderAuthority"] || import_jskos_tools9.default.compare(concept.inScheme[0], { uri: lccUri }) && data3["http://www.loc.gov/mads/rdf/v1#isMemberOfMADSCollection"] || [];
   concept.broader = broader.map((n) => ({ uri: n["@id"] })).filter(schemeNamespaceFilter(concept.inScheme && concept.inScheme[0]));
   return concept;
 }
@@ -2515,9 +2535,9 @@ var LocApiProvider = class extends BaseProvider {
       supportedSchemes.filter((s) => !this.schemes || !this.schemes.length || this.schemes.find((s2) => import_jskos_tools9.default.compare(s, s2))).map((s) => (0, import_axios2.default)({
         method: "get",
         url: `${s.uri.replace("http:", "https:")}.json`
-      }).then(({ status, data }) => {
+      }).then(({ status, data: data3 }) => {
         if (status === 200) {
-          let scheme2 = data.find((d) => s.uri === d["@id"]);
+          let scheme2 = data3.find((d) => s.uri === d["@id"]);
           if (scheme2) {
             scheme2 = import_jskos_tools9.default.merge(madsToJskosScheme(scheme2), s);
             scheme2.topConcepts = (scheme2.topConcepts || []).filter((c) => c);
@@ -2541,9 +2561,9 @@ var LocApiProvider = class extends BaseProvider {
     for (let concept of await Promise.all(concepts.map((c) => (0, import_axios2.default)({
       method: "get",
       url: `${c.uri.replace("http:", "https:")}.json`
-    }).then(({ status, data }) => {
+    }).then(({ status, data: data3 }) => {
       if (status === 200) {
-        let concept2 = data.find((d) => c.uri === d["@id"]);
+        let concept2 = data3.find((d) => c.uri === d["@id"]);
         if (concept2) {
           return madsToJskosConcept(concept2, { scheme: c.inScheme && c.inScheme[0] });
         }
@@ -2577,7 +2597,7 @@ var LocApiProvider = class extends BaseProvider {
     }
     limit = limit || this._jskos.suggestResultLimit || 100;
     offset = offset || 0;
-    const { data } = await (0, import_axios2.default)({
+    const { data: data3 } = await (0, import_axios2.default)({
       method: "get",
       url: `${schemeUri}/suggest2`.replace("http:", "https:"),
       params: {
@@ -2587,7 +2607,7 @@ var LocApiProvider = class extends BaseProvider {
         searchtype: "keyword"
       }
     });
-    return (data.hits || []).map((d) => ({
+    return (data3.hits || []).map((d) => ({
       uri: d.uri,
       notation: [d.token],
       prefLabel: { en: d.aLabel },
@@ -2609,6 +2629,7 @@ function decodeUnicode(text) {
     }
   );
 }
+var data = {};
 var SkohubProvider = class extends BaseProvider {
   _prepare() {
     this.has.schemes = true;
@@ -2622,11 +2643,20 @@ var SkohubProvider = class extends BaseProvider {
     listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
       this.has[c] = false;
     });
+    data[this.uri] = {
+      index: {},
+      conceptCache: {},
+      schemeCache: {}
+    };
   }
-  _setup() {
-    this._index = {};
-    this._conceptCache = {};
-    this._schemeCache = {};
+  get _index() {
+    return data[this.uri] && data[this.uri].index;
+  }
+  get _conceptCache() {
+    return data[this.uri] && data[this.uri].conceptCache;
+  }
+  get _schemeCache() {
+    return data[this.uri] && data[this.uri].schemeCache;
   }
   static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
     if (!url || !scheme) {
@@ -2652,11 +2682,11 @@ var SkohubProvider = class extends BaseProvider {
     if (uri.endsWith("/")) {
       postfix = "index.json";
     }
-    const data = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
-    if (data.id !== uri) {
+    const data3 = await this.axios({ ...config, url: `${uri}${postfix}`, _skipAdditionalParameters: true });
+    if (data3.id !== uri) {
       throw new InvalidRequestError({ message: "Skohub URL did not return expected concept scheme" });
     }
-    const { title, preferredNamespaceUri, hasTopConcept, description } = data;
+    const { title, preferredNamespaceUri, hasTopConcept, description } = data3;
     scheme = { uri, identifier: uris.filter((u) => u !== uri) };
     scheme.prefLabel = title;
     Object.keys(scheme.prefLabel || {}).forEach((key) => {
@@ -2684,33 +2714,33 @@ var SkohubProvider = class extends BaseProvider {
       return this._conceptCache[uri];
     }
     try {
-      const data = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
-      if (data.id !== uri) {
+      const data3 = await this.axios({ ...config, url: `${uri}.json`, _skipAdditionalParameters: true });
+      if (data3.id !== uri) {
         throw new InvalidRequestError({ message: "Skohub URL did not return expected concept URI" });
       }
-      const concept = this._toJskosConcept(data);
+      const concept = this._toJskosConcept(data3);
       this._conceptCache[uri] = concept;
       return concept;
     } catch (error) {
       return null;
     }
   }
-  _toJskosConcept(data) {
-    const concept = { uri: data.id };
-    concept.prefLabel = data.prefLabel;
+  _toJskosConcept(data3) {
+    const concept = { uri: data3.id };
+    concept.prefLabel = data3.prefLabel;
     Object.keys(concept.prefLabel || {}).forEach((key) => {
       concept.prefLabel[key] = decodeUnicode(concept.prefLabel[key]);
     });
-    concept.narrower = (data.narrower || []).map((c) => this._toJskosConcept(c));
-    concept.notation = data.notation || [];
-    if (data.broader && data.broader.id) {
-      concept.broader = [{ uri: data.broader.id }];
+    concept.narrower = (data3.narrower || []).map((c) => this._toJskosConcept(c));
+    concept.notation = data3.notation || [];
+    if (data3.broader && data3.broader.id) {
+      concept.broader = [{ uri: data3.broader.id }];
     }
-    if (data.inScheme && data.inScheme.id) {
-      concept.inScheme = [{ uri: data.inScheme.id }];
+    if (data3.inScheme && data3.inScheme.id) {
+      concept.inScheme = [{ uri: data3.inScheme.id }];
     }
-    if (data.scopeNote) {
-      concept.scopeNote = data.scopeNote;
+    if (data3.scopeNote) {
+      concept.scopeNote = data3.scopeNote;
       Object.keys(concept.scopeNote).forEach((key) => {
         concept.scopeNote[key] = [decodeUnicode(concept.scopeNote[key])];
       });
@@ -2782,13 +2812,13 @@ var SkohubProvider = class extends BaseProvider {
         if (scheme.uri.endsWith("/")) {
           postfix = `index${postfix}`;
         }
-        const data = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
-        if (data.length < 100) {
+        const data3 = await this.axios({ url: `${scheme.uri}${postfix}`, _skipAdditionalParameters: true });
+        if (data3.length < 100) {
           this._index[scheme.uri][lang] = null;
           continue;
         }
         index = import_flexsearch.default.create();
-        index.import(data);
+        index.import(data3);
         this._index[scheme.uri][lang] = index;
         break;
       } catch (error) {
@@ -2824,6 +2854,217 @@ var SkohubProvider = class extends BaseProvider {
 SkohubProvider.providerName = "Skohub";
 SkohubProvider.providerType = "http://bartoc.org/api-type/skohub";
 
+// src/providers/mycore-provider.js
+var import_jskos_tools11 = __toESM(require("jskos-tools"), 1);
+var import_flexsearch2 = __toESM(require("flexsearch"), 1);
+var data2 = {};
+var MyCoReProvider = class extends BaseProvider {
+  _prepare() {
+    this.has.schemes = true;
+    this.has.top = true;
+    this.has.data = true;
+    this.has.concepts = true;
+    this.has.narrower = true;
+    this.has.ancestors = true;
+    this.has.suggest = true;
+    this.has.search = true;
+    listOfCapabilities.filter((c) => !this.has[c]).forEach((c) => {
+      this.has[c] = false;
+    });
+  }
+  _setup() {
+    this._scheme = null;
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    return {
+      api: url
+    };
+  }
+  _schemeInfoToJSKOS(schemeInfo) {
+    const uri = schemeInfo.labels.find((l) => l.lang === "x-uri").text;
+    const prefLabel = {};
+    schemeInfo.labels.filter((l) => !l.lang.startsWith("x-")).forEach((l) => {
+      prefLabel[l.lang] = l.text;
+    });
+    const scheme = {
+      uri,
+      prefLabel
+    };
+    if (schemeInfo.categories && schemeInfo.categories.length) {
+      scheme.topConcepts = [null];
+    }
+    if (schemeInfo.category && schemeInfo.category.length) {
+      scheme.concepts = [null];
+    }
+    return scheme;
+  }
+  _categoryToJSKOS(category, { scheme, broader = [] }) {
+    if (!category || !scheme) {
+      return null;
+    }
+    const id = category.ID;
+    const uri = `${scheme.uri}/${id}`;
+    if (data2[scheme.uri].concepts[uri]) {
+      return data2[scheme.uri].concepts[uri];
+    }
+    const prefLabel = {};
+    category.labels.filter((l) => !l.lang.startsWith("x-") && l.text).forEach((l) => {
+      prefLabel[l.lang] = l.text.replace(`${id} `, "");
+      data2[scheme.uri].searchIndex.add(uri, prefLabel[l.lang]);
+    });
+    const scopeNote = {};
+    category.labels.filter((l) => !l.lang.startsWith("x-") && l.description).forEach((l) => {
+      if (!scopeNote[l.lang]) {
+        scopeNote[l.lang] = [];
+      }
+      scopeNote[l.lang].push(l.description);
+    });
+    data2[scheme.uri].concepts[uri] = {
+      uri,
+      notation: [id],
+      prefLabel,
+      scopeNote,
+      inScheme: [{ uri: scheme.uri }],
+      narrower: (category.categories || []).map((c) => ({ uri: `${scheme.uri}/${c.ID}` })),
+      broader
+    };
+    return data2[scheme.uri].concepts[uri];
+  }
+  _removeNarrower(concept) {
+    if (!concept)
+      return concept;
+    return Object.assign({}, concept, { narrower: concept.narrower && concept.narrower.length ? [null] : [] });
+  }
+  async _loadSchemeData(config) {
+    const schemeInfo = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.api,
+      _skipAdditionalParameters: true
+    });
+    this._scheme = this._schemeInfoToJSKOS(schemeInfo);
+    const uri = this._scheme.uri;
+    data2[uri] = {
+      schemeInfo,
+      searchIndex: import_flexsearch2.default.create({
+        tokenize: "full"
+      }),
+      concepts: {}
+    };
+    const dealWithCategory = (category, { broader = [] } = {}) => {
+      const concept = this._categoryToJSKOS(category, { scheme: this._scheme, broader });
+      (category.categories || []).forEach((c) => dealWithCategory(c, { broader: [{ uri: concept.uri }] }));
+    };
+    schemeInfo.categories.forEach((category) => dealWithCategory(category));
+    data2[uri].topConcepts = schemeInfo.categories.map((category) => this._categoryToJSKOS(category, { scheme: this._scheme }));
+  }
+  async getSchemes(config = {}) {
+    if (!this._api.api) {
+      throw new MissingApiUrlError();
+    }
+    if (!this._scheme) {
+      if (!this._loadSchemeDataPromise) {
+        this._loadSchemeDataPromise = this._loadSchemeData(config);
+      }
+      await this._loadSchemeDataPromise;
+    }
+    return [this._scheme];
+  }
+  async getTop({ scheme, ...config }) {
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    if (!import_jskos_tools11.default.compare(scheme, this._scheme)) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    return data2[this._scheme.uri].topConcepts.map(this._removeNarrower);
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!import_isArray.default(concepts)) {
+      concepts = [concepts];
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    return concepts.map((c) => data2[this._scheme.uri].concepts[c.uri]).map(this._removeNarrower);
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.ancestors && concept.ancestors[0] !== null) {
+      return concept.ancestors;
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    concept = data2[this._scheme.uri].concepts[concept.uri];
+    const broader = concept && concept.broader && concept.broader[0];
+    if (!broader) {
+      return [];
+    }
+    return [broader].concat(await this.getAncestors({ concept: broader, ...config }));
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    if (concept.narrower && concept.narrower[0] !== null) {
+      return concept.narrower;
+    }
+    if (!this._scheme) {
+      await this.getSchemes(config);
+    }
+    concept = data2[this._scheme.uri].concepts[concept.uri];
+    return (concept && concept.narrower || []).map((c) => data2[this._scheme.uri].concepts[c.uri]).map(this._removeNarrower);
+  }
+  async search({ search, scheme, limit = 100 }) {
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    if (!search) {
+      throw new InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    if (!scheme || !scheme.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme URI" });
+    }
+    if (!this._scheme) {
+      await this.getSchemes();
+    }
+    if (!import_jskos_tools11.default.compare(scheme, this._scheme)) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    const result = await data2[this._scheme.uri].searchIndex.search(search);
+    return result.map((uri) => data2[this._scheme.uri].concepts[uri]).map(this._removeNarrower).slice(0, limit);
+  }
+  async suggest(config) {
+    config._raw = true;
+    const concepts = await this.search(config);
+    const result = [config.search, [], [], []];
+    for (let concept of concepts) {
+      const notation = import_jskos_tools11.default.notation(concept);
+      const label = import_jskos_tools11.default.prefLabel(concept);
+      result[1].push((notation ? notation + " " : "") + label);
+      result[2].push("");
+      result[3].push(concept.uri);
+    }
+    if (concepts._totalCount != void 0) {
+      result._totalCount = concepts._totalCount;
+    } else {
+      result._totalCount = concepts.length;
+    }
+    return result;
+  }
+};
+MyCoReProvider.providerName = "MyCoRe";
+MyCoReProvider.providerType = "http://bartoc.org/api-type/mycore";
+
 // src/lib/CocodaSDK.js
 var providers = {
   [BaseProvider.providerName]: BaseProvider,
@@ -3009,7 +3250,7 @@ var CocodaSDK = class {
             scheme._registry = registry;
             scheme.__DETAILSLOADED__ = 1;
             scheme.type = scheme.type || ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
-            let otherScheme = schemes.find((s) => import_jskos_tools11.default.compare(s, scheme)), prio, otherPrio, override = false;
+            let otherScheme = schemes.find((s) => import_jskos_tools12.default.compare(s, scheme)), prio, otherPrio, override = false;
             if (otherScheme) {
               prio = this.config.registries.indexOf(registry);
               if (prio != -1) {
@@ -3031,19 +3272,19 @@ var CocodaSDK = class {
             }
             if (!otherScheme || override) {
               if (override) {
-                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools11.default.compare(s, otherScheme));
+                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools12.default.compare(s, otherScheme));
                 if (otherSchemeIndex != -1) {
                   schemes.splice(otherSchemeIndex, 1);
                 }
-                scheme = import_jskos_tools11.default.merge(scheme, import_omit.default(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                scheme = import_jskos_tools12.default.merge(scheme, import_omit.default(otherScheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
               }
               scheme._registry = registry;
               schemes.push(scheme);
             } else {
-              const index = schemes.findIndex((s) => import_jskos_tools11.default.compare(s, scheme));
+              const index = schemes.findIndex((s) => import_jskos_tools12.default.compare(s, scheme));
               if (index != -1) {
                 const otherSchemeRegistry = schemes[index]._registry;
-                schemes[index] = import_jskos_tools11.default.merge(schemes[index], import_omit.default(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                schemes[index] = import_jskos_tools12.default.merge(schemes[index], import_omit.default(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
                 schemes[index]._registry = otherSchemeRegistry;
               }
             }
@@ -3065,7 +3306,7 @@ var CocodaSDK = class {
         scheme._registry = newRegistry;
       }
     });
-    return import_jskos_tools11.default.sortSchemes(schemes.filter(Boolean));
+    return import_jskos_tools12.default.sortSchemes(schemes.filter(Boolean));
   }
   registryForScheme(scheme) {
     let registry = scheme._registry;
@@ -3076,7 +3317,7 @@ var CocodaSDK = class {
       const url = config.url;
       if (registryCache[url]) {
         const registry2 = registryCache[url];
-        if (Array.isArray(registry2._jskos.schemes) && !import_jskos_tools11.default.isContainedIn(scheme, registry2._jskos.schemes)) {
+        if (Array.isArray(registry2._jskos.schemes) && !import_jskos_tools12.default.isContainedIn(scheme, registry2._jskos.schemes)) {
           registry2._jskos.schemes.push(scheme);
         }
         return registry2;
@@ -3121,11 +3362,13 @@ function addAllProviders(_cdk) {
   LocApiProvider,
   LocalMappingsProvider,
   MappingsApiProvider,
+  MyCoReProvider,
   OccurrencesApiProvider,
   ReconciliationApiProvider,
   SkohubProvider,
   SkosmosApiProvider,
   addAllProviders,
   cdk,
-  errors
+  errors,
+  utils
 });