cocoda-sdk 1.0.13 → 2.0.0

package/dist/cjs/index.cjs

@@ -0,0 +1,2673 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __require = typeof require !== "undefined" ? require : (x) => {
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+};
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+
+// src/index.js
+__export(exports, {
+  BaseProvider: () => BaseProvider,
+  CocodaSDK: () => CocodaSDK,
+  ConceptApiProvider: () => ConceptApiProvider,
+  LabelSearchSuggestionProvider: () => LabelSearchSuggestionProvider,
+  LocApiProvider: () => LocApiProvider,
+  LocalMappingsProvider: () => LocalMappingsProvider,
+  MappingsApiProvider: () => MappingsApiProvider,
+  OccurrencesApiProvider: () => OccurrencesApiProvider,
+  ReconciliationApiProvider: () => ReconciliationApiProvider,
+  SkosmosApiProvider: () => SkosmosApiProvider,
+  cdk: () => cdk,
+  errors: () => errors_exports
+});
+
+// src/errors/index.js
+var errors_exports = {};
+__export(errors_exports, {
+  BackendError: () => BackendError,
+  BackendUnavailableError: () => BackendUnavailableError,
+  CDKError: () => CDKError,
+  InvalidOrMissingParameterError: () => InvalidOrMissingParameterError,
+  InvalidProviderError: () => InvalidProviderError,
+  InvalidRequestError: () => InvalidRequestError,
+  MethodNotImplementedError: () => MethodNotImplementedError,
+  MissingApiUrlError: () => MissingApiUrlError,
+  NetworkError: () => NetworkError
+});
+var CDKError = class extends Error {
+  constructor({ message = "", relatedError = null, code = null } = {}) {
+    if (!message && relatedError && relatedError.message) {
+      message = relatedError.message;
+    }
+    super(message);
+    this.name = this.constructor.name;
+    this.relatedError = relatedError;
+    this.code = code;
+  }
+};
+var MethodNotImplementedError = class extends CDKError {
+  constructor({ method, message = "", ...options }) {
+    options.message = `Method not implemented: ${method} (${message})`;
+    super(options);
+  }
+};
+var InvalidOrMissingParameterError = class extends CDKError {
+  constructor({ parameter, message = "", ...options }) {
+    options.message = `Invalid or missing parameter: ${parameter} (${message})`;
+    super(options);
+  }
+};
+var InvalidRequestError = class extends CDKError {
+};
+var BackendError = class extends CDKError {
+};
+var BackendUnavailableError = class extends CDKError {
+};
+var NetworkError = class extends CDKError {
+};
+var MissingApiUrlError = class extends CDKError {
+};
+var InvalidProviderError = class extends CDKError {
+};
+
+// src/lib/CocodaSDK.js
+var import_axios3 = __toModule(require("axios"));
+
+// src/utils/lodash.js
+var import_lodash_es = __toModule(require("lodash-es"));
+
+// src/lib/CocodaSDK.js
+var import_jskos_tools10 = __toModule(require("jskos-tools"));
+
+// src/providers/base-provider.js
+var import_jskos_tools = __toModule(require("jskos-tools"));
+var import_axios = __toModule(require("axios"));
+
+// src/utils/index.js
+var requestMethods = [
+  {
+    method: "getRegistries",
+    fallback: [],
+    type: "Registries"
+  },
+  {
+    method: "getSchemes",
+    fallback: [],
+    type: "Schemes"
+  },
+  {
+    method: "vocSearch",
+    fallback: [],
+    type: "Schemes"
+  },
+  {
+    method: "getTypes",
+    fallback: [],
+    type: "Types"
+  },
+  {
+    method: "suggest",
+    fallback: ["", [], [], []]
+  },
+  {
+    method: "vocSuggest",
+    fallback: ["", [], [], []]
+  },
+  {
+    method: "getConcordances",
+    fallback: [],
+    type: "Concordances"
+  },
+  {
+    method: "getOccurrences",
+    fallback: [],
+    type: "Occurrences"
+  },
+  {
+    method: "getTop",
+    fallback: [],
+    type: "Concepts"
+  },
+  {
+    method: "getConcepts",
+    fallback: [],
+    type: "Concepts"
+  },
+  {
+    method: "getNarrower",
+    fallback: [],
+    type: "Concepts"
+  },
+  {
+    method: "getAncestors",
+    fallback: [],
+    type: "Concepts"
+  },
+  {
+    method: "search",
+    fallback: [],
+    type: "Concepts"
+  },
+  {
+    method: "getMapping",
+    fallback: null,
+    type: "Mapping"
+  },
+  {
+    method: "getMappings",
+    fallback: [],
+    type: "Mappings"
+  },
+  {
+    method: "postMapping",
+    fallback: null,
+    type: "Mapping"
+  },
+  {
+    method: "postMappings",
+    fallback: [],
+    type: "Mapping"
+  },
+  {
+    method: "putMapping",
+    fallback: null,
+    type: "Mapping"
+  },
+  {
+    method: "patchMapping",
+    fallback: null,
+    type: "Mapping"
+  },
+  {
+    method: "deleteMapping",
+    fallback: false
+  },
+  {
+    method: "deleteMappings",
+    fallback: []
+  },
+  {
+    method: "getAnnotations",
+    fallback: [],
+    type: "Annotations"
+  },
+  {
+    method: "postAnnotation",
+    fallback: null,
+    type: "Annotation"
+  },
+  {
+    method: "putAnnotation",
+    fallback: null,
+    type: "Annotation"
+  },
+  {
+    method: "patchAnnotation",
+    fallback: null,
+    type: "Annotation"
+  },
+  {
+    method: "deleteAnnotation",
+    fallback: false
+  }
+];
+function concatUrl(...parts) {
+  let [url, ...otherParts] = parts;
+  for (let part of otherParts) {
+    if (!url.endsWith("/")) {
+      url += "/";
+    }
+    if (part.startsWith("/")) {
+      part = part.slice(1);
+    }
+    url += part;
+  }
+  return url;
+}
+function withCustomProps(arr, from) {
+  arr._totalCount = from._totalCount;
+  arr._url = from._url;
+  return arr;
+}
+
+// src/providers/base-provider.js
+var BaseProvider = class {
+  constructor(registry = {}) {
+    this._jskos = registry;
+    this.axios = import_axios.default.create({
+      timeout: 2e4
+    });
+    this._path = typeof window !== "undefined" && window.location.pathname;
+    this.has = {};
+    this._defaultLanguages = "en,de,fr,es,nl,it,fi,pl,ru,cs,jp".split(",");
+    this.languages = [];
+    this._auth = {
+      key: null,
+      bearerToken: null
+    };
+    this._repeating = [];
+    this._api = {
+      status: registry.status,
+      schemes: registry.schemes,
+      top: registry.top,
+      data: registry.data,
+      concepts: registry.concepts,
+      narrower: registry.narrower,
+      ancestors: registry.ancestors,
+      types: registry.types,
+      suggest: registry.suggest,
+      search: registry.search,
+      "voc-suggest": registry["voc-suggest"],
+      "voc-search": registry["voc-search"],
+      mappings: registry.mappings,
+      concordances: registry.concordances,
+      annotations: registry.annotations,
+      occurrences: registry.occurrences,
+      reconcile: registry.reconcile,
+      api: registry.api
+    };
+    this._config = {};
+    this.setRetryConfig();
+    this.axios.interceptors.request.use((config) => {
+      const language = import_lodash_es.uniq([].concat(import_lodash_es.get(config, "params.language", "").split(","), this.languages, this._defaultLanguages).filter((lang) => lang != "")).join(",");
+      import_lodash_es.set(config, "params.language", language);
+      if (this.has.auth && this._auth.bearerToken && !import_lodash_es.get(config, "headers.Authorization")) {
+        import_lodash_es.set(config, "headers.Authorization", `Bearer ${this._auth.bearerToken}`);
+      }
+      if (config.url.startsWith("http:") && typeof window !== "undefined" && window.location.protocol == "https:") {
+        throw new import_axios.default.Cancel("Can't call http API from https.");
+      }
+      return config;
+    });
+    this.axios.interceptors.response.use(({ data, headers = {}, config = {} }) => {
+      data = import_jskos_tools.default.normalize(data);
+      let url = config.url;
+      if (!url.endsWith("?")) {
+        url += "?";
+      }
+      import_lodash_es.forOwn(config.params || {}, (value, key) => {
+        url += `${key}=${encodeURIComponent(value)}&`;
+      });
+      if (import_lodash_es.isArray(data) || import_lodash_es.isObject(data)) {
+        let totalCount = parseInt(headers["x-total-count"]);
+        if (!isNaN(totalCount)) {
+          data._totalCount = totalCount;
+        }
+        data._url = url;
+      }
+      return data;
+    }, (error) => {
+      const count = import_lodash_es.get(error, "config._retryCount", 0);
+      const method = import_lodash_es.get(error, "config.method");
+      const statusCode = import_lodash_es.get(error, "response.status");
+      if (this._retryConfig.methods.includes(method) && this._retryConfig.statusCodes.includes(statusCode) && count < this._retryConfig.count) {
+        error.config._retryCount = count + 1;
+        if (error.config.data)
+          error.config.data = JSON.parse(error.config.data);
+        return new Promise((resolve, reject) => {
+          setTimeout(() => {
+            this.axios(error.config).then(resolve).catch(reject);
+          }, (() => {
+            const delay = this._retryConfig.delay;
+            if (typeof delay === "function") {
+              return delay(count);
+            }
+            return delay;
+          })());
+        });
+      } else {
+        return Promise.reject(error);
+      }
+    });
+    const currentRequests = [];
+    for (let { method, type } of requestMethods) {
+      const existingMethod = this[method] && this[method].bind(this);
+      if (!existingMethod) {
+        this[method] = () => {
+          throw new MethodNotImplementedError({ method });
+        };
+        continue;
+      }
+      this[method] = (options = {}) => {
+        if (options._raw) {
+          delete options._raw;
+          return existingMethod(options);
+        }
+        const existingRequest = currentRequests.find((r) => r.method == method && import_lodash_es.isEqual(r.options, options));
+        if (existingRequest) {
+          return existingRequest.promise;
+        }
+        let source;
+        if (!options.cancelToken) {
+          source = this.getCancelTokenSource();
+          options.cancelToken = source.token;
+        }
+        const promise = this.init().then(() => existingMethod(options)).then((result) => {
+          if (import_lodash_es.isArray(result) && result._totalCount === void 0) {
+            result._totalCount = result.length;
+          } else if (import_lodash_es.isObject(result) && result._totalCount === void 0) {
+            result._totalCount = 1;
+          }
+          if (result && type && this[`adjust${type}`]) {
+            result = this[`adjust${type}`](result);
+          }
+          return result;
+        }).catch((error) => {
+          if (error instanceof CDKError) {
+            throw error;
+          } else {
+            if (error.response) {
+              if (error.response.status.toString().startsWith(4)) {
+                throw new InvalidRequestError({ relatedError: error, code: error.response.status });
+              } else {
+                throw new BackendError({ relatedError: error, code: error.response.status });
+              }
+            } else if (error.request) {
+              if (typeof navigator !== "undefined") {
+                if (navigator.connection || navigator.mozConnection || navigator.webkitConnection) {
+                  throw new BackendUnavailableError({ relatedError: error });
+                }
+              }
+              throw new NetworkError({ relatedError: error });
+            } else {
+              throw new CDKError({ relatedError: error });
+            }
+          }
+        });
+        if (source) {
+          promise.cancel = (...args) => {
+            return source.cancel(...args);
+          };
+        }
+        const request = {
+          method,
+          options: import_lodash_es.omit(options, ["cancelToken"]),
+          promise
+        };
+        currentRequests.push(request);
+        promise.catch(() => {
+        }).then(() => currentRequests.splice(currentRequests.indexOf(request), 1));
+        return promise;
+      };
+    }
+  }
+  get uri() {
+    return this._jskos.uri;
+  }
+  get notation() {
+    return this._jskos.notation;
+  }
+  get prefLabel() {
+    return this._jskos.prefLabel;
+  }
+  get definition() {
+    return this._jskos.definition;
+  }
+  get schemes() {
+    return this._jskos.schemes;
+  }
+  get excludedSchemes() {
+    return this._jskos.excludedSchemes;
+  }
+  get stored() {
+    return this._jskos.stored !== void 0 ? this._jskos.stored : this.constructor.stored;
+  }
+  async init() {
+    if (this._init) {
+      return this._init;
+    }
+    this._init = (async () => {
+      this._prepare();
+      let status;
+      if (import_lodash_es.isString(this._api.status)) {
+        try {
+          status = await this.axios({
+            method: "get",
+            url: this._api.status
+          });
+        } catch (error) {
+          if (import_lodash_es.get(error, "response.status") === 404) {
+            this._api.status = null;
+          }
+        }
+      } else {
+        status = this._api.status;
+      }
+      if (import_lodash_es.isObject(status) && !import_lodash_es.isEmpty(status)) {
+        this._config = status.config || {};
+        for (let key of Object.keys(this._api)) {
+          if (this._api[key] === void 0) {
+            this._api[key] = status[key] || null;
+          }
+        }
+      }
+      this._setup();
+    })();
+    return this._init;
+  }
+  _prepare() {
+  }
+  _setup() {
+  }
+  getCancelTokenSource() {
+    return import_axios.default.CancelToken.source();
+  }
+  setAuth({ key = this._auth.key, bearerToken = this._auth.bearerToken }) {
+    this._auth.key = key;
+    this._auth.bearerToken = bearerToken;
+  }
+  setRetryConfig(config = {}) {
+    this._retryConfig = Object.assign({
+      methods: ["get", "head", "options"],
+      statusCodes: [401, 403],
+      count: 3,
+      delay: (count) => {
+        return 300 * count;
+      }
+    }, config);
+  }
+  isAuthorizedFor({ type, action, user, crossUser }) {
+    if (action == "read" && this.has[type] === true) {
+      return true;
+    }
+    if (!this.has[type]) {
+      return false;
+    }
+    const options = import_lodash_es.get(this._config, `${type}.${action}`);
+    if (!options) {
+      return !!this.has[type][action];
+    }
+    if (options.auth && (!user || !this._auth.key)) {
+      return false;
+    }
+    if (options.auth && this._auth.key != import_lodash_es.get(this._config, "auth.key")) {
+      return false;
+    }
+    if (options.auth && options.identities) {
+      const uris = [user.uri].concat(Object.values(user.identities || {}).map((id) => id.uri)).filter((uri) => uri != null);
+      if (import_lodash_es.intersection(uris, options.identities).length == 0) {
+        return false;
+      }
+    }
+    if (options.auth && options.identityProviders) {
+      const providers2 = Object.keys(user && user.identities || {});
+      if (import_lodash_es.intersection(providers2, options.identityProviders).length == 0) {
+        return false;
+      }
+    }
+    if (crossUser) {
+      return !!options.crossUser;
+    }
+    return !!this.has[type][action];
+  }
+  supportsScheme(scheme) {
+    if (!scheme) {
+      return false;
+    }
+    let schemes = import_lodash_es.isArray(this.schemes) ? this.schemes : null;
+    if (schemes == null && !import_jskos_tools.default.isContainedIn(scheme, this.excludedSchemes || [])) {
+      return true;
+    }
+    return import_jskos_tools.default.isContainedIn(scheme, schemes);
+  }
+  adjustConcept(concept) {
+    concept._getNarrower = (config) => {
+      return this.getNarrower({ ...config, concept });
+    };
+    concept._getAncestors = (config) => {
+      return this.getAncestors({ ...config, concept });
+    };
+    concept._getDetails = async (config) => {
+      return (await this.getConcepts({ ...config, concepts: [concept] }))[0];
+    };
+    for (let type of ["broader", "narrower", "ancestors"]) {
+      if (Array.isArray(concept[type]) && !concept[type].includes(null)) {
+        concept[type] = this.adjustConcepts(concept[type]);
+      }
+    }
+    concept._registry = this;
+    return concept;
+  }
+  adjustConcepts(concepts) {
+    return withCustomProps(concepts.map((concept) => this.adjustConcept(concept)), concepts);
+  }
+  adjustRegistries(registries) {
+    return registries;
+  }
+  adjustScheme(scheme) {
+    scheme._registry = this.cdk && this.cdk.registryForScheme(scheme) || this;
+    if (scheme._registry) {
+      scheme._getTop = (config) => {
+        return scheme._registry.getTop({ ...config, scheme });
+      };
+      scheme._getTypes = (config) => {
+        return scheme._registry.getTypes({ ...config, scheme });
+      };
+      scheme._suggest = ({ search, ...config }) => {
+        return scheme._registry.suggest({ ...config, search, scheme });
+      };
+    }
+    return scheme;
+  }
+  adjustSchemes(schemes) {
+    return withCustomProps(schemes.map((scheme) => this.adjustScheme(scheme)), schemes);
+  }
+  adjustConcordances(concordances) {
+    for (let concordance of concordances) {
+      concordance._registry = this;
+    }
+    return concordances;
+  }
+  adjustMapping(mapping) {
+    for (let side of ["from", "to"]) {
+      let sideScheme = `${side}Scheme`;
+      if (!mapping[sideScheme]) {
+        mapping[sideScheme] = import_lodash_es.get(import_jskos_tools.default.conceptsOfMapping(mapping, side), "[0].inScheme[0]", null);
+      }
+    }
+    mapping._registry = this;
+    if (!mapping.identifier) {
+      let identifier = import_lodash_es.get(import_jskos_tools.default.addMappingIdentifiers(mapping), "identifier");
+      if (identifier) {
+        mapping.identifier = identifier;
+      }
+    }
+    return mapping;
+  }
+  adjustMappings(mappings) {
+    return withCustomProps(mappings.map((mapping) => this.adjustMapping(mapping)), mappings);
+  }
+  async postMappings({ mappings, ...config } = {}) {
+    if (!mappings || !mappings.length) {
+      throw new InvalidOrMissingParameterError({ parameter: "mappings" });
+    }
+    return Promise.all(mappings.map((mapping) => this.postMapping({ mapping, ...config, _raw: true })));
+  }
+  async deleteMappings({ mappings, ...config } = {}) {
+    if (!mappings || !mappings.length) {
+      throw new InvalidOrMissingParameterError({ parameter: "mappings" });
+    }
+    return Promise.all(mappings.map((mapping) => this.deleteMapping({ mapping, ...config, _raw: true })));
+  }
+};
+BaseProvider.providerName = "Base";
+
+// src/providers/local-mappings-provider.js
+var import_jskos_tools2 = __toModule(require("jskos-tools"));
+var import_localforage = __toModule(require("localforage"));
+var import_uuid = __toModule(require("uuid"));
+var uriPrefix = "urn:uuid:";
+var LocalMappingsProvider = class extends BaseProvider {
+  _setup() {
+    this.has.mappings = {
+      read: true,
+      create: true,
+      update: true,
+      delete: true
+    };
+    this.queue = [];
+    this.localStorageKey = "cocoda-mappings--" + this._path;
+    let oldLocalStorageKey = "mappings";
+    let addUris = () => {
+      return import_localforage.default.getItem(this.localStorageKey).then((mappings) => {
+        mappings = mappings || [];
+        let adjusted = 0;
+        for (let mapping of mappings.filter((m) => !m.uri || !m.uri.startsWith(uriPrefix))) {
+          if (mapping.uri) {
+            if (!mapping.identifier) {
+              mapping.identifier = [];
+            }
+            mapping.identifier.push(mapping.uri);
+          }
+          mapping.uri = `${uriPrefix}${(0, import_uuid.v4)()}`;
+          adjusted += 1;
+        }
+        if (adjusted) {
+          console.warn(`URIs added to ${adjusted} local mappings.`);
+        }
+        return import_localforage.default.setItem(this.localStorageKey, mappings);
+      });
+    };
+    import_localforage.default.getItem(oldLocalStorageKey).then((results) => {
+      if (results) {
+        console.warn(`Warning: There is old data in local storage (or IndexedDB, depending on the ) with the key "${oldLocalStorageKey}". This data will not be used anymore. A manual export is necessary to get this data back.`);
+      }
+    });
+    this.queue.push(addUris().catch((error) => {
+      console.warn("Error when adding URIs to local mappings:", error);
+    }));
+  }
+  isAuthorizedFor({ type, action }) {
+    if (type == "mappings" && action != "anonymous") {
+      return true;
+    }
+    return false;
+  }
+  _getMappingsQueue() {
+    let last2 = import_lodash_es.last(this.queue) || Promise.resolve();
+    return new Promise((resolve) => {
+      function defer() {
+        var res, rej;
+        var promise2 = new Promise((resolve2, reject) => {
+          res = resolve2;
+          rej = reject;
+        });
+        promise2.resolve = res;
+        promise2.reject = rej;
+        return promise2;
+      }
+      let promise = defer();
+      let done = () => {
+        promise.resolve();
+      };
+      this.queue.push(promise);
+      last2.then(() => {
+        return import_localforage.default.getItem(this.localStorageKey);
+      }).then((mappings) => {
+        resolve({ mappings, done });
+      });
+    });
+  }
+  async getMapping({ mapping, ...config }) {
+    config._raw = true;
+    if (!mapping || !mapping.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    return (await this.getMappings({ ...config, uri: mapping.uri }))[0];
+  }
+  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, uri } = {}) {
+    let params = {};
+    if (from) {
+      params.from = import_lodash_es.isString(from) ? from : from.uri;
+    }
+    if (fromScheme) {
+      params.fromScheme = import_lodash_es.isString(fromScheme) ? { uri: fromScheme } : fromScheme;
+    }
+    if (to) {
+      params.to = import_lodash_es.isString(to) ? to : to.uri;
+    }
+    if (toScheme) {
+      params.toScheme = import_lodash_es.isString(toScheme) ? { uri: toScheme } : toScheme;
+    }
+    if (creator) {
+      params.creator = import_lodash_es.isString(creator) ? creator : import_jskos_tools2.default.prefLabel(creator);
+    }
+    if (type) {
+      params.type = import_lodash_es.isString(type) ? type : type.uri;
+    }
+    if (partOf) {
+      params.partOf = import_lodash_es.isString(partOf) ? partOf : partOf.uri;
+    }
+    if (offset) {
+      params.offset = offset;
+    }
+    if (limit) {
+      params.limit = limit;
+    }
+    if (direction) {
+      params.direction = direction;
+    }
+    if (mode) {
+      params.mode = mode;
+    }
+    if (identifier) {
+      params.identifier = identifier;
+    }
+    if (uri) {
+      params.uri = uri;
+    }
+    return this._getMappingsQueue().catch((relatedError) => {
+      throw new CDKError({ message: "Could not get mappings from local storage", relatedError });
+    }).then(({ mappings, done }) => {
+      done();
+      let checkConcept = (concept, param) => concept.uri == param || param && concept.notation && concept.notation[0].toLowerCase() == param.toLowerCase();
+      if (params.from || params.to) {
+        mappings = mappings.filter((mapping) => {
+          let fromInFrom = import_jskos_tools2.default.conceptsOfMapping(mapping, "from").find((concept) => checkConcept(concept, params.from)) != null;
+          let fromInTo = import_jskos_tools2.default.conceptsOfMapping(mapping, "to").find((concept) => checkConcept(concept, params.from)) != null;
+          let toInFrom = import_jskos_tools2.default.conceptsOfMapping(mapping, "from").find((concept) => checkConcept(concept, params.to)) != null;
+          let toInTo = import_jskos_tools2.default.conceptsOfMapping(mapping, "to").find((concept) => checkConcept(concept, params.to)) != null;
+          if (params.direction == "backward") {
+            if (params.mode == "or") {
+              return params.from && fromInTo || params.to && toInFrom;
+            } else {
+              return (!params.from || fromInTo) && (!params.to || toInFrom);
+            }
+          } else if (params.direction == "both") {
+            if (params.mode == "or") {
+              return params.from && (fromInFrom || fromInTo) || params.to && (toInFrom || toInTo);
+            } else {
+              return (!params.from || fromInFrom) && (!params.to || toInTo) || (!params.from || fromInTo) && (!params.to || toInFrom);
+            }
+          } else {
+            if (params.mode == "or") {
+              return params.from && fromInFrom || params.to && toInTo;
+            } else {
+              return (!params.from || fromInFrom) && (!params.to || toInTo);
+            }
+          }
+        });
+      }
+      if (params.fromScheme || params.toScheme) {
+        mappings = mappings.filter((mapping) => {
+          let fromInFrom = import_jskos_tools2.default.compare(mapping.fromScheme, params.fromScheme);
+          let fromInTo = import_jskos_tools2.default.compare(mapping.toScheme, params.fromScheme);
+          let toInFrom = import_jskos_tools2.default.compare(mapping.fromScheme, params.toScheme);
+          let toInTo = import_jskos_tools2.default.compare(mapping.toScheme, params.toScheme);
+          if (params.direction == "backward") {
+            if (params.mode == "or") {
+              return params.fromScheme && fromInTo || params.toScheme && toInFrom;
+            } else {
+              return (!params.fromScheme || fromInTo) && (!params.toScheme || toInFrom);
+            }
+          } else if (params.direction == "both") {
+            if (params.mode == "or") {
+              return params.fromScheme && (fromInFrom || fromInTo) || params.toScheme && (toInFrom || toInTo);
+            } else {
+              return (!params.fromScheme || fromInFrom) && (!params.toScheme || toInTo) || (!params.fromScheme || fromInTo) && (!params.toScheme || toInFrom);
+            }
+          } else {
+            if (params.mode == "or") {
+              return params.fromScheme && fromInFrom || params.toScheme && toInTo;
+            } else {
+              return (!params.fromScheme || fromInFrom) && (!params.toScheme || toInTo);
+            }
+          }
+        });
+      }
+      if (params.creator) {
+        let creators = params.creator.split("|");
+        mappings = mappings.filter((mapping) => {
+          return (mapping.creator && mapping.creator.find((creator2) => creators.includes(import_jskos_tools2.default.prefLabel(creator2)) || creators.includes(creator2.uri))) != null;
+        });
+      }
+      if (params.type) {
+        mappings = mappings.filter((mapping) => (mapping.type || [import_jskos_tools2.default.defaultMappingType.uri]).includes(params.type));
+      }
+      if (params.partOf) {
+        mappings = mappings.filter((mapping) => {
+          return mapping.partOf != null && mapping.partOf.find((partOf2) => import_jskos_tools2.default.compare(partOf2, { uri: params.partOf })) != null;
+        });
+      }
+      if (params.identifier) {
+        mappings = mappings.filter((mapping) => {
+          return params.identifier.split("|").map((identifier2) => {
+            return (mapping.identifier || []).includes(identifier2) || mapping.uri == identifier2;
+          }).reduce((current, total) => current || total);
+        });
+      }
+      if (params.uri) {
+        mappings = mappings.filter((mapping) => mapping.uri == params.uri);
+      }
+      let totalCount = mappings.length;
+      mappings = mappings.sort((a, b) => {
+        let aDate = a.modified || a.created;
+        let bDate = b.modified || b.created;
+        if (bDate == null) {
+          return -1;
+        }
+        if (aDate == null) {
+          return 1;
+        }
+        if (aDate > bDate) {
+          return -1;
+        }
+        return 1;
+      });
+      mappings = mappings.slice(params.offset || 0);
+      mappings = mappings.slice(0, params.limit);
+      mappings._totalCount = totalCount;
+      return mappings;
+    });
+  }
+  async postMapping({ mapping }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    if (!mapping.uri || !mapping.uri.startsWith(uriPrefix)) {
+      if (mapping.uri) {
+        if (!mapping.identifier) {
+          mapping.identifier = [];
+        }
+        mapping.identifier.push(mapping.uri);
+      }
+      mapping.uri = `${uriPrefix}${(0, import_uuid.v4)()}`;
+    }
+    if (localMappings.find((m) => m.uri == mapping.uri)) {
+      done();
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "Duplicate URI" });
+    }
+    if (!mapping.created) {
+      mapping.created = new Date().toISOString();
+    }
+    if (!mapping.modified) {
+      mapping.modified = mapping.created;
+    }
+    localMappings.push(mapping);
+    localMappings = localMappings.map((mapping2) => import_jskos_tools2.default.minifyMapping(mapping2));
+    try {
+      await import_localforage.default.setItem(this.localStorageKey, localMappings);
+      done();
+      return mapping;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+  async putMapping({ mapping }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    const index = localMappings.findIndex((m) => m.uri == mapping.uri);
+    if (index == -1) {
+      done();
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "Mapping not found" });
+    }
+    if (!mapping.created) {
+      mapping.created = localMappings[index].created;
+    }
+    mapping.modified = new Date().toISOString();
+    localMappings[index] = mapping;
+    localMappings = localMappings.map((mapping2) => import_jskos_tools2.default.minifyMapping(mapping2));
+    try {
+      await import_localforage.default.setItem(this.localStorageKey, localMappings);
+      done();
+      return mapping;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+  async patchMapping({ mapping }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    const index = localMappings.findIndex((m) => m.uri == mapping.uri);
+    if (index == -1) {
+      done();
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "Mapping not found" });
+    }
+    if (!mapping.created) {
+      mapping.created = localMappings[index].created;
+    }
+    mapping.modified = new Date().toISOString();
+    localMappings[index] = Object.assign(localMappings[index], mapping);
+    localMappings = localMappings.map((mapping2) => import_jskos_tools2.default.minifyMapping(mapping2));
+    try {
+      await import_localforage.default.setItem(this.localStorageKey, localMappings);
+      done();
+      return mapping;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+  async deleteMapping({ mapping }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    let { mappings: localMappings, done } = await this._getMappingsQueue();
+    try {
+      localMappings = localMappings.filter((m) => m.uri != mapping.uri);
+      localMappings = localMappings.map((mapping2) => import_jskos_tools2.default.minifyMapping(mapping2));
+      await import_localforage.default.setItem(this.localStorageKey, localMappings);
+      done();
+      return true;
+    } catch (error) {
+      done();
+      throw error;
+    }
+  }
+};
+LocalMappingsProvider.providerName = "LocalMappings";
+LocalMappingsProvider.stored = true;
+
+// src/providers/mappings-api-provider.js
+var import_jskos_tools3 = __toModule(require("jskos-tools"));
+var MappingsApiProvider = class extends BaseProvider {
+  _prepare() {
+    if (this._api.api && this._api.status === void 0) {
+      this._api.status = concatUrl(this._api.api, "/status");
+    }
+  }
+  _setup() {
+    if (this._api.api) {
+      const endpoints = {
+        mappings: "/mappings",
+        concordances: "/concordances",
+        annotations: "/annotations"
+      };
+      for (let key of Object.keys(endpoints)) {
+        if (this._api[key] === void 0) {
+          this._api[key] = concatUrl(this._api.api, endpoints[key]);
+        }
+      }
+    }
+    this.has.mappings = this._api.mappings ? {} : false;
+    if (this.has.mappings) {
+      this.has.mappings.read = !!import_lodash_es.get(this._config, "mappings.read", true);
+      this.has.mappings.create = !!import_lodash_es.get(this._config, "mappings.create");
+      this.has.mappings.update = !!import_lodash_es.get(this._config, "mappings.update");
+      this.has.mappings.delete = !!import_lodash_es.get(this._config, "mappings.delete");
+      this.has.mappings.anonymous = !!import_lodash_es.get(this._config, "mappings.anonymous");
+    }
+    this.has.concordances = !!this._api.concordances;
+    this.has.annotations = this._api.annotations ? {} : false;
+    if (this.has.annotations) {
+      this.has.annotations.read = !!import_lodash_es.get(this._config, "annotations.read");
+      this.has.annotations.create = !!import_lodash_es.get(this._config, "annotations.create");
+      this.has.annotations.update = !!import_lodash_es.get(this._config, "annotations.update");
+      this.has.annotations.delete = !!import_lodash_es.get(this._config, "annotations.delete");
+    }
+    this.has.auth = import_lodash_es.get(this._config, "auth.key") != null;
+    this._defaultParams = {
+      properties: "annotations"
+    };
+  }
+  async getMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    if (!mapping.uri || !mapping.uri.startsWith(this._api.mappings)) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
+    }
+    try {
+      return await this.axios({
+        ...config,
+        url: mapping.uri,
+        params: {
+          ...this._defaultParams,
+          ...config.params || {}
+        }
+      });
+    } catch (error) {
+      if (import_lodash_es.get(error, "response.status") == 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getMappings({ from, fromScheme, to, toScheme, creator, type, partOf, offset, limit, direction, mode, identifier, sort, order, ...config }) {
+    let params = {}, url = this._api.mappings;
+    if (from) {
+      params.from = import_lodash_es.isString(from) ? from : from.uri;
+    }
+    if (fromScheme) {
+      params.fromScheme = import_lodash_es.isString(fromScheme) ? fromScheme : fromScheme.uri;
+    }
+    if (to) {
+      params.to = import_lodash_es.isString(to) ? to : to.uri;
+    }
+    if (toScheme) {
+      params.toScheme = import_lodash_es.isString(toScheme) ? toScheme : toScheme.uri;
+    }
+    if (creator) {
+      params.creator = import_lodash_es.isString(creator) ? creator : import_jskos_tools3.default.prefLabel(creator);
+    }
+    if (type) {
+      params.type = import_lodash_es.isString(type) ? type : type.uri;
+    }
+    if (partOf) {
+      params.partOf = import_lodash_es.isString(partOf) ? partOf : partOf.uri;
+    }
+    if (offset) {
+      params.offset = offset;
+    }
+    if (limit) {
+      params.limit = limit;
+    }
+    if (direction) {
+      params.direction = direction;
+    }
+    if (mode) {
+      params.mode = mode;
+    }
+    if (identifier) {
+      params.identifier = identifier;
+    }
+    if (sort) {
+      params.sort = sort;
+    }
+    if (order) {
+      params.order = order;
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {},
+        ...params
+      }
+    });
+  }
+  async postMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    mapping = import_jskos_tools3.default.minifyMapping(mapping);
+    mapping = import_jskos_tools3.default.addMappingIdentifiers(mapping);
+    return this.axios({
+      ...config,
+      method: "post",
+      url: this._api.mappings,
+      data: mapping,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async putMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    mapping = import_jskos_tools3.default.minifyMapping(mapping);
+    mapping = import_jskos_tools3.default.addMappingIdentifiers(mapping);
+    const uri = mapping.uri;
+    if (!uri || !uri.startsWith(this._api.mappings)) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "put",
+      url: uri,
+      data: mapping,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async patchMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    mapping = import_jskos_tools3.default.minifyMapping(mapping);
+    mapping = import_jskos_tools3.default.addMappingIdentifiers(mapping);
+    const uri = mapping.uri;
+    if (!uri || !uri.startsWith(this._api.mappings)) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "patch",
+      url: uri,
+      data: mapping,
+      params: {
+        ...this._defaultParams,
+        ...config.params || {}
+      }
+    });
+  }
+  async deleteMapping({ mapping, ...config }) {
+    if (!mapping) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping" });
+    }
+    const uri = mapping.uri;
+    if (!uri || !uri.startsWith(this._api.mappings)) {
+      throw new InvalidOrMissingParameterError({ parameter: "mapping", message: "URI doesn't seem to be part of this registry." });
+    }
+    await this.axios({
+      ...config,
+      method: "delete",
+      url: uri
+    });
+    return true;
+  }
+  async getAnnotations({ target, ...config }) {
+    if (target) {
+      import_lodash_es.set(config, "params.target", target);
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.annotations
+    });
+  }
+  async postAnnotation({ annotation, ...config }) {
+    return this.axios({
+      ...config,
+      method: "post",
+      url: this._api.annotations,
+      data: annotation
+    });
+  }
+  async putAnnotation({ annotation, ...config }) {
+    const uri = annotation.id;
+    if (!uri || !uri.startsWith(this._api.annotations)) {
+      throw new InvalidOrMissingParameterError({ parameter: "annotation", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "put",
+      url: uri,
+      data: annotation
+    });
+  }
+  async patchAnnotation({ annotation, ...config }) {
+    const uri = annotation.id;
+    if (!uri || !uri.startsWith(this._api.annotations)) {
+      throw new InvalidOrMissingParameterError({ parameter: "annotation", message: "URI doesn't seem to be part of this registry." });
+    }
+    return this.axios({
+      ...config,
+      method: "patch",
+      url: uri,
+      data: annotation
+    });
+  }
+  async deleteAnnotation({ annotation, ...config }) {
+    const uri = annotation.id;
+    if (!uri || !uri.startsWith(this._api.annotations)) {
+      throw new InvalidOrMissingParameterError({ parameter: "annotation", message: "URI doesn't seem to be part of this registry." });
+    }
+    await this.axios({
+      ...config,
+      method: "delete",
+      url: uri
+    });
+    return true;
+  }
+  async getConcordances(config) {
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.concordances
+    });
+  }
+};
+MappingsApiProvider.providerName = "MappingsApi";
+MappingsApiProvider.stored = true;
+
+// src/providers/occurrences-api-provider.js
+var import_jskos_tools4 = __toModule(require("jskos-tools"));
+var OccurrencesApiProvider = class extends BaseProvider {
+  _setup() {
+    this._cache = [];
+    this._occurrencesSupportedSchemes = [];
+    this.has.occurrences = true;
+    this.has.mappings = true;
+  }
+  async _occurrencesIsSupported(scheme) {
+    if (this._occurrencesSupportedSchemes && this._occurrencesSupportedSchemes.length) {
+    } else {
+      try {
+        const url = concatUrl(this._api.api, "voc");
+        const data = await this.axios({
+          method: "get",
+          url
+        });
+        this._occurrencesSupportedSchemes = data || [];
+      } catch (error) {
+      }
+    }
+    let supported = false;
+    for (let supportedScheme of this._occurrencesSupportedSchemes) {
+      if (import_jskos_tools4.default.compare(scheme, supportedScheme)) {
+        supported = true;
+      }
+    }
+    return supported;
+  }
+  async getMappings(config) {
+    const occurrences = await this.getOccurrences(config);
+    const fromScheme = import_lodash_es.get(config, "from.inScheme[0]") || config.fromScheme;
+    const toScheme = import_lodash_es.get(config, "to.inScheme[0]") || config.toScheme;
+    const mappings = [];
+    for (let occurrence of occurrences) {
+      if (!occurrence) {
+        continue;
+      }
+      let mapping = {};
+      mapping.from = import_lodash_es.get(occurrence, "memberSet[0]");
+      if (mapping.from) {
+        mapping.from = { memberSet: [mapping.from] };
+      } else {
+        mapping.from = null;
+      }
+      mapping.fromScheme = import_lodash_es.get(occurrence, "memberSet[0].inScheme[0]");
+      mapping.to = import_lodash_es.get(occurrence, "memberSet[1]");
+      if (mapping.to) {
+        mapping.to = { memberSet: [mapping.to] };
+      } else {
+        mapping.to = { memberSet: [] };
+      }
+      mapping.toScheme = import_lodash_es.get(occurrence, "memberSet[1].inScheme[0]");
+      if (fromScheme && mapping.fromScheme && !import_jskos_tools4.default.compare(mapping.fromScheme, fromScheme) || toScheme && mapping.toScheme && !import_jskos_tools4.default.compare(mapping.toScheme, toScheme)) {
+        [mapping.from, mapping.fromScheme, mapping.to, mapping.toScheme] = [mapping.to, mapping.toScheme, mapping.from, mapping.fromScheme];
+      }
+      if (!mapping.fromScheme && fromScheme) {
+        mapping.fromScheme = fromScheme;
+      }
+      if (!mapping.toScheme && toScheme) {
+        mapping.toScheme = toScheme;
+      }
+      mapping.type = [import_jskos_tools4.default.defaultMappingType.uri];
+      mapping._occurrence = occurrence;
+      mapping = import_jskos_tools4.default.addMappingIdentifiers(mapping);
+      if (occurrence.database) {
+        mapping.creator = [occurrence.database];
+      }
+      mappings.push(mapping);
+    }
+    return mappings;
+  }
+  async getOccurrences({ from, to, concepts, ...config }) {
+    let promises = [];
+    concepts = (concepts || []).concat([from, to]).filter((c) => !!c);
+    for (let concept of concepts) {
+      promises.push(this._occurrencesIsSupported(import_lodash_es.get(concept, "inScheme[0]")).then((supported) => {
+        if (supported && concept.uri) {
+          return concept.uri;
+        } else {
+          return null;
+        }
+      }));
+    }
+    let uris = await Promise.all(promises);
+    uris = uris.filter((uri) => uri != null);
+    if (uris.length == 0) {
+      throw new InvalidOrMissingParameterError({ parameter: "concepts" });
+    }
+    promises = [];
+    for (let uri of uris) {
+      promises.push(this._getOccurrences({
+        ...config,
+        params: {
+          member: uri,
+          scheme: "*",
+          threshold: 5
+        }
+      }));
+    }
+    if (uris.length > 1) {
+      let urisString = uris.join(" ");
+      promises.push(this._getOccurrences({
+        ...config,
+        params: {
+          member: urisString,
+          threshold: 5
+        }
+      }));
+    }
+    const results = await Promise.all(promises);
+    let occurrences = import_lodash_es.concat([], ...results);
+    let existingUris = [];
+    let indexesToDelete = [];
+    for (let i = 0; i < occurrences.length; i += 1) {
+      let occurrence = occurrences[i];
+      if (!occurrence) {
+        continue;
+      }
+      let uris2 = occurrence.memberSet.reduce((total, current) => total.concat(current.uri), []).sort().join(" ");
+      if (existingUris.includes(uris2)) {
+        indexesToDelete.push(i);
+      } else {
+        existingUris.push(uris2);
+      }
+    }
+    indexesToDelete.forEach((value) => {
+      delete occurrences[value];
+    });
+    occurrences = occurrences.filter((o) => o != null);
+    return occurrences.sort((a, b) => parseInt(b.count || 0) - parseInt(a.count || 0));
+  }
+  async _getOccurrences(config) {
+    let resultsFromCache = this._cache.find((item) => {
+      return import_lodash_es.isEqual(item.config.params, config.params);
+    });
+    if (resultsFromCache) {
+      return resultsFromCache.data;
+    }
+    const data = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.api
+    });
+    this._cache.push({
+      config,
+      data
+    });
+    if (this._cache.length > 20) {
+      this._cache = this._cache.slice(this._cache.length - 20);
+    }
+    return data;
+  }
+};
+OccurrencesApiProvider.providerName = "OccurrencesApi";
+OccurrencesApiProvider.stored = false;
+
+// src/providers/concept-api-provider.js
+var import_jskos_tools5 = __toModule(require("jskos-tools"));
+var ConceptApiProvider = class extends BaseProvider {
+  _prepare() {
+    if (this._api.api && this._api.status === void 0) {
+      this._api.status = concatUrl(this._api.api, "/status");
+    }
+  }
+  _setup() {
+    if (this._api.api) {
+      const endpoints = {
+        schemes: "/voc",
+        top: "/voc/top",
+        concepts: "/voc/concepts",
+        data: "/data",
+        narrower: "/narrower",
+        ancestors: "/ancestors",
+        types: "/types",
+        suggest: "/suggest",
+        search: "/search"
+      };
+      for (let key of Object.keys(endpoints)) {
+        if (this._api[key] === void 0) {
+          this._api[key] = concatUrl(this._api.api, endpoints[key]);
+        }
+      }
+    }
+    this.has.schemes = !!this._api.schemes;
+    this.has.top = !!this._api.top;
+    this.has.data = !!this._api.data;
+    this.has.concepts = !!this._api.concepts || this.has.data;
+    this.has.narrower = !!this._api.narrower;
+    this.has.ancestors = !!this._api.ancestors;
+    this.has.types = !!this._api.types;
+    this.has.suggest = !!this._api.suggest;
+    this.has.search = !!this._api.search;
+    this.has.auth = import_lodash_es.get(this._config, "auth.key") != null;
+    this._defaultParams = {
+      properties: "uri,prefLabel,notation,inScheme"
+    };
+  }
+  static _registryConfigForBartocApiConfig({ url } = {}) {
+    if (!url) {
+      return null;
+    }
+    return {
+      api: url
+    };
+  }
+  async _getSchemeUri(scheme) {
+    this._approvedSchemes = this._approvedSchemes || [];
+    this._rejectedSchemes = this._rejectedSchemes || [];
+    let _scheme = this._approvedSchemes.find((s) => import_jskos_tools5.default.compare(scheme, s));
+    if (_scheme) {
+      return _scheme.uri;
+    }
+    if (this._rejectedSchemes.find((s) => import_jskos_tools5.default.compare(scheme, s))) {
+      return null;
+    }
+    const schemes = await this.getSchemes({ uri: import_jskos_tools5.default.getAllUris(scheme) });
+    const resultScheme = schemes.find((s) => import_jskos_tools5.default.compare(s, scheme));
+    if (resultScheme) {
+      this._approvedSchemes.push({
+        uri: resultScheme.uri,
+        identifier: import_jskos_tools5.default.getAllUris(scheme)
+      });
+      return resultScheme.uri;
+    } else {
+      this._rejectedSchemes.push({
+        uri: scheme.uri,
+        identifier: scheme.identifier
+      });
+      return null;
+    }
+  }
+  async getSchemes(config) {
+    if (!this._api.schemes) {
+      throw new MissingApiUrlError();
+    }
+    if (Array.isArray(this._api.schemes)) {
+      return this._api.schemes;
+    }
+    const schemes = await this.axios({
+      ...config,
+      method: "get",
+      url: this._api.schemes,
+      params: {
+        ...this._defaultParams,
+        limit: 500,
+        ...config.params || {}
+      }
+    });
+    if (Array.isArray(this._jskos.schemes)) {
+      return withCustomProps(schemes.filter((s) => import_jskos_tools5.default.isContainedIn(s, this._jskos.schemes)), schemes);
+    } else {
+      return schemes;
+    }
+  }
+  async getTop({ scheme, ...config }) {
+    if (!this._api.top) {
+      throw new MissingApiUrlError();
+    }
+    if (!scheme) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme" });
+    }
+    const schemeUri = await this._getSchemeUri(scheme);
+    if (!schemeUri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Requested vocabulary seems to be unsupported by this API." });
+    }
+    if (Array.isArray(this._api.top)) {
+      return this._api.top;
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.top,
+      params: {
+        ...this._defaultParams,
+        limit: 1e4,
+        ...config.params || {},
+        uri: schemeUri
+      }
+    });
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!this.has.data) {
+      throw new MissingApiUrlError();
+    }
+    if (!concepts) {
+      throw new InvalidOrMissingParameterError({ parameter: "concepts" });
+    }
+    if (!Array.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    let uris = concepts.map((concept) => concept.uri).filter((uri) => uri != null);
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.data,
+      params: {
+        ...this._defaultParams,
+        limit: 500,
+        ...config.params || {},
+        uri: uris.join("|")
+      }
+    });
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!this._api.narrower) {
+      throw new MissingApiUrlError();
+    }
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.narrower,
+      params: {
+        ...this._defaultParams,
+        limit: 1e4,
+        ...config.params || {},
+        uri: concept.uri
+      }
+    });
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!this._api.ancestors) {
+      throw new MissingApiUrlError();
+    }
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.ancestors,
+      params: {
+        ...this._defaultParams,
+        limit: 1e4,
+        ...config.params || {},
+        uri: concept.uri
+      }
+    });
+  }
+  async suggest({ scheme, use = "notation,label", types = [], sort = "score", ...config }) {
+    return this._search({
+      ...config,
+      endpoint: "suggest",
+      params: {
+        ...config.params,
+        voc: import_lodash_es.get(scheme, "uri", ""),
+        type: types.join("|"),
+        use,
+        sort
+      }
+    });
+  }
+  async search({ scheme, types = [], ...config }) {
+    return this._search({
+      ...config,
+      endpoint: "search",
+      params: {
+        ...config.params,
+        voc: import_lodash_es.get(scheme, "uri", ""),
+        type: types.join("|")
+      }
+    });
+  }
+  async vocSuggest({ use = "notation,label", sort = "score", ...config }) {
+    return this._search({
+      ...config,
+      endpoint: "voc-suggest",
+      params: {
+        ...config.params,
+        use,
+        sort
+      }
+    });
+  }
+  async vocSearch(config) {
+    return this._search({
+      ...config,
+      endpoint: "voc-search"
+    });
+  }
+  async _search({ endpoint, search, limit, offset, params, ...config }) {
+    let url = this._api[endpoint];
+    if (!url) {
+      throw new MissingApiUrlError();
+    }
+    if (!search) {
+      throw new InvalidOrMissingParameterError({ parameter: "search" });
+    }
+    limit = limit || this._jskos.suggestResultLimit || 100;
+    offset = offset || 0;
+    url = url.replace("{searchTerms}", search);
+    return this.axios({
+      ...config,
+      params: {
+        ...this._defaultParams,
+        ...params,
+        limit,
+        count: limit,
+        offset,
+        search,
+        query: search
+      },
+      method: "get",
+      url
+    });
+  }
+  async getTypes({ scheme, ...config }) {
+    if (!this._api.types) {
+      throw new MissingApiUrlError();
+    }
+    if (Array.isArray(this._api.types)) {
+      return this._api.types;
+    }
+    const schemeUri = scheme && await this._getSchemeUri(scheme);
+    if (schemeUri) {
+      import_lodash_es.set(config, "params.uri", schemeUri);
+    }
+    return this.axios({
+      ...config,
+      method: "get",
+      url: this._api.types
+    });
+  }
+};
+ConceptApiProvider.providerName = "ConceptApi";
+ConceptApiProvider.providerType = "http://bartoc.org/api-type/jskos";
+
+// src/providers/reconciliation-api-provider.js
+var import_jskos_tools6 = __toModule(require("jskos-tools"));
+var ReconciliationApiProvider = class extends BaseProvider {
+  _setup() {
+    this.has.mappings = true;
+    this._cache = [];
+  }
+  async getMappings({ from, to, mode, ...config }) {
+    let schemes = [];
+    if (import_lodash_es.isArray(this.schemes)) {
+      schemes = this.schemes;
+    }
+    let swap;
+    let concept;
+    let fromConceptScheme = import_lodash_es.get(from, "inScheme[0]");
+    let toConceptScheme = import_lodash_es.get(to, "inScheme[0]");
+    let fromScheme;
+    let toScheme;
+    if (!from || import_jskos_tools6.default.isContainedIn(fromConceptScheme, schemes)) {
+      swap = true;
+      concept = to;
+      fromScheme = toConceptScheme;
+      toScheme = schemes.find((scheme) => import_jskos_tools6.default.compare(scheme, fromConceptScheme)) || schemes[0];
+    } else {
+      swap = false;
+      concept = from;
+      fromScheme = fromConceptScheme;
+      toScheme = schemes.find((scheme) => import_jskos_tools6.default.compare(scheme, toConceptScheme)) || schemes[0];
+    }
+    if (mode != "or") {
+      return [];
+    }
+    if (!this._api.api) {
+      throw new MissingApiUrlError();
+    }
+    if (!concept) {
+      throw new InvalidOrMissingParameterError({ parameter: swap ? "to" : "from" });
+    }
+    let language = import_jskos_tools6.default.languagePreference.selectLanguage(concept.prefLabel);
+    if (!language) {
+      throw new InvalidOrMissingParameterError({ parameter: swap ? "to" : "from", message: "Missing language" });
+    }
+    let altLabels = import_lodash_es.get(concept, `altLabel.${language}`, []);
+    if (import_lodash_es.isString(altLabels)) {
+      altLabels = [altLabels];
+    }
+    let prefLabel = import_lodash_es.get(concept, `prefLabel.${language}`);
+    let labels = altLabels.concat([prefLabel]);
+    labels = [prefLabel];
+    let { url, data: results } = await this._getReconciliationResults({ ...config, labels, language });
+    results = [].concat(...Object.values(results).map((value) => value.result)).filter((r) => r);
+    results = results.sort((a, b) => {
+      if (a.score != b.score) {
+        return b.score - a.score;
+      }
+      if (a.match != b.match) {
+        if (a.match) {
+          return -1;
+        } else {
+          return 1;
+        }
+      }
+      return a.id.length - b.id.length;
+    });
+    let namespace = import_lodash_es.get(toScheme, "namespace", "");
+    let mappings = results.map((result) => ({
+      fromScheme,
+      from: { memberSet: [concept] },
+      toScheme,
+      to: {
+        memberSet: [
+          {
+            uri: namespace + result.id
+          }
+        ]
+      },
+      type: [
+        result.match ? "http://www.w3.org/2004/02/skos/core#exactMatch" : result.score >= 80 ? "http://www.w3.org/2004/02/skos/core#closeMatch" : "http://www.w3.org/2004/02/skos/core#mappingRelation"
+      ]
+    }));
+    if (swap) {
+      mappings = mappings.map((mapping) => Object.assign(mapping, {
+        fromScheme: mapping.toScheme,
+        from: mapping.to,
+        toScheme: mapping.fromScheme,
+        to: mapping.from
+      }));
+    }
+    mappings._url = url;
+    return mappings;
+  }
+  async _getReconciliationResults({ labels, language, ...config }) {
+    labels = labels.sort();
+    let resultsFromCache = this._cache.find((item) => {
+      return import_lodash_es.isEqual(item.labels, labels) && item.language == language;
+    });
+    if (resultsFromCache) {
+      return resultsFromCache;
+    }
+    let queries = {};
+    let index = 0;
+    for (let label of labels) {
+      queries[`q${index}`] = {
+        query: label
+      };
+      index += 1;
+    }
+    let url = this._api.api;
+    if (language) {
+      url = url.replace("{language}", language);
+    }
+    const encodedData = `queries=${encodeURIComponent(JSON.stringify(queries))}`;
+    import_lodash_es.set(config, ["headers", "Content-Type"], "application/x-www-form-urlencoded");
+    let data = await this.axios({
+      ...config,
+      method: "post",
+      url,
+      data: encodedData
+    });
+    data = data || {};
+    let newCacheEntry = {
+      labels,
+      language,
+      data,
+      url: `${url}${url.includes("?") ? "&" : "?"}${encodedData}`
+    };
+    this._cache.push(newCacheEntry);
+    if (this._cache.length > 20) {
+      this._cache = this._cache.slice(this._cache.length - 20);
+    }
+    return newCacheEntry;
+  }
+};
+ReconciliationApiProvider.providerName = "ReconciliationApi";
+ReconciliationApiProvider.stored = false;
+
+// src/providers/label-search-suggestion-provider.js
+var import_jskos_tools7 = __toModule(require("jskos-tools"));
+var LabelSearchSuggestionProvider = class extends BaseProvider {
+  _setup() {
+    this._cache = [];
+    this.has.mappings = true;
+  }
+  supportsScheme(scheme) {
+    return import_lodash_es.get(scheme, "_registry.has.search", false);
+  }
+  async getMappings({ from, to, mode, selected, limit = 10, ...config }) {
+    if (mode != "or") {
+      return [];
+    }
+    if (!selected) {
+      throw new InvalidOrMissingParameterError({ parameter: "selected" });
+    }
+    let promises = [];
+    if (from && this.supportsScheme(selected.scheme[false])) {
+      promises.push(this._getMappings({ ...config, concept: from, sourceScheme: selected.scheme[true], targetScheme: selected.scheme[false], limit }));
+    } else {
+      promises.push(Promise.resolve([]));
+    }
+    if (to && this.supportsScheme(selected.scheme[true])) {
+      promises.push(this._getMappings({ ...config, concept: to, sourceScheme: selected.scheme[false], targetScheme: selected.scheme[true], limit, swap: true }));
+    } else {
+      promises.push(Promise.resolve([]));
+    }
+    let [fromResult, toResult] = await Promise.all(promises);
+    toResult = toResult.filter((m) => !fromResult.find((n) => import_jskos_tools7.default.compareMappingMembers(m, n)));
+    while (fromResult.length + toResult.length > limit) {
+      if (toResult.length >= fromResult.length) {
+        toResult = toResult.slice(0, -1);
+      } else {
+        fromResult = fromResult.slice(0, -1);
+      }
+    }
+    return import_lodash_es.union(fromResult, toResult);
+  }
+  async _getMappings({ concept, sourceScheme, targetScheme, limit, swap = false, ...config }) {
+    if (!concept || !sourceScheme || !targetScheme) {
+      return [];
+    }
+    if (import_jskos_tools7.default.compare(sourceScheme, targetScheme)) {
+      return [];
+    }
+    let label = import_jskos_tools7.default.prefLabel(concept, {
+      fallbackToUri: false,
+      language: this.languages[0] || this._defaultLanguages[0]
+    });
+    if (!label) {
+      return [];
+    }
+    const results = await this._getResults({ ...config, label, targetScheme, limit });
+    let mappings = results.map((result) => ({
+      fromScheme: sourceScheme,
+      from: { memberSet: [concept] },
+      toScheme: targetScheme,
+      to: { memberSet: [result] },
+      type: ["http://www.w3.org/2004/02/skos/core#mappingRelation"]
+    }));
+    if (swap) {
+      mappings = mappings.map((mapping) => Object.assign(mapping, {
+        fromScheme: mapping.toScheme,
+        from: mapping.to,
+        toScheme: mapping.fromScheme,
+        to: mapping.from
+      }));
+    }
+    return mappings;
+  }
+  async _getResults({ label, targetScheme, limit, ...config }) {
+    let resultsFromCache = (this._cache[targetScheme.uri] || {})[label];
+    if (resultsFromCache && resultsFromCache._limit >= limit) {
+      return resultsFromCache;
+    }
+    const registry = import_lodash_es.get(targetScheme, "_registry");
+    if (!registry || !registry.has.search) {
+      return [];
+    }
+    const data = await registry.search({
+      ...config,
+      search: label,
+      scheme: targetScheme,
+      limit
+    });
+    if (!this._cache[targetScheme.uri]) {
+      this._cache[targetScheme.uri] = {};
+    }
+    this._cache[targetScheme.uri][label] = data;
+    this._cache[targetScheme.uri][label]._limit = limit;
+    return data;
+  }
+};
+LabelSearchSuggestionProvider.providerName = "LabelSearchSuggestion";
+LabelSearchSuggestionProvider.stored = false;
+
+// src/providers/skosmos-api-provider.js
+var import_jskos_tools8 = __toModule(require("jskos-tools"));
+var SkosmosApiProvider = class extends BaseProvider {
+  _setup() {
+    this.has.schemes = true;
+    this.has.top = false;
+    this.has.data = true;
+    this.has.concepts = true;
+    this.has.narrower = true;
+    this.has.ancestors = true;
+    this.has.types = true;
+    this.has.suggest = true;
+    this.has.search = true;
+    for (let scheme of this.schemes) {
+      scheme.concepts = [null];
+      scheme.topConcepts = [];
+    }
+  }
+  static _registryConfigForBartocApiConfig({ url, scheme } = {}) {
+    if (!url || !scheme) {
+      return null;
+    }
+    const config = {};
+    const match = url.match(/(.+\/)([^/]+)\/$/);
+    if (!match) {
+      return null;
+    }
+    config.api = match[1] + "rest/v1/";
+    scheme.VOCID = match[2];
+    config.schemes = [scheme];
+    return config;
+  }
+  get _language() {
+    return this.languages[0] || this._defaultLanguages[0] || "en";
+  }
+  _getApiUrl(scheme, endpoint, params) {
+    if (!scheme || !scheme.VOCID) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing scheme or VOCID property on scheme" });
+    }
+    endpoint = endpoint || "";
+    params = params || {};
+    if (!params.lang) {
+      params.lang = this._language;
+    }
+    const paramString = Object.keys(params).map((k) => `${k}=${encodeURIComponent(params[k])}`).join("&");
+    return `${this._api.api}${scheme.VOCID}${endpoint}${paramString ? "?" + paramString : ""}`;
+  }
+  _getDataUrl(concept, { addFormatParameter = true } = {}) {
+    const scheme = import_lodash_es.get(concept, "inScheme[0]");
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept", message: "Missing concept URI" });
+    }
+    return this._getApiUrl(scheme, "/data", addFormatParameter ? { format: "application/json" } : {});
+  }
+  async _getSchemeUri(scheme) {
+    this._approvedSchemes = this._approvedSchemes || [];
+    this._rejectedSchemes = this._rejectedSchemes || [];
+    let _scheme = this._approvedSchemes.find((s) => import_jskos_tools8.default.compare(scheme, s));
+    if (_scheme) {
+      return _scheme.uri;
+    }
+    if (this._rejectedSchemes.find((s) => import_jskos_tools8.default.compare(scheme, s))) {
+      return null;
+    }
+    const url = this._getApiUrl(scheme, "/");
+    const data = await this.axios({
+      method: "get",
+      url
+    });
+    const resultScheme = data.conceptschemes.find((s) => import_jskos_tools8.default.compare(s, scheme));
+    if (resultScheme) {
+      this._approvedSchemes.push({
+        uri: resultScheme.uri,
+        identifier: import_jskos_tools8.default.getAllUris(scheme)
+      });
+      return resultScheme.uri;
+    } else {
+      this._rejectedSchemes.push({
+        uri: scheme.uri,
+        identifier: scheme.identifier
+      });
+      return null;
+    }
+  }
+  _toJskosConcept(skosmosConcept, { concept, scheme, result, language } = {}) {
+    if (!skosmosConcept) {
+      return null;
+    }
+    concept = import_jskos_tools8.default.deepCopy(concept || {});
+    language = language || skosmosConcept.lang || "en";
+    concept.uri = skosmosConcept.uri;
+    if (scheme) {
+      concept.inScheme = [scheme];
+    }
+    let prefLabel = skosmosConcept.matchedPrefLabel || skosmosConcept.prefLabel || skosmosConcept.label;
+    if (import_lodash_es.isString(prefLabel)) {
+      import_lodash_es.set(concept, `prefLabel.${language}`, prefLabel);
+    } else {
+      if (prefLabel && !import_lodash_es.isArray(prefLabel)) {
+        prefLabel = [prefLabel];
+      }
+      for (let label of prefLabel || []) {
+        import_lodash_es.set(concept, `prefLabel.${label.lang}`, label.value);
+      }
+    }
+    let altLabel = skosmosConcept.altLabel;
+    if (import_lodash_es.isString(altLabel)) {
+      import_lodash_es.set(concept, `altLabel.${language}`, [altLabel]);
+    } else {
+      if (altLabel && !import_lodash_es.isArray(altLabel)) {
+        altLabel = [altLabel];
+      }
+      for (let label of altLabel || []) {
+        if (import_lodash_es.get(concept, `altLabel.${label.lang}`)) {
+          concept.altLabel[label.lang].push(label.value);
+          concept.altLabel[label.lang] = import_lodash_es.uniq(concept.altLabel[label.lang]);
+        } else {
+          import_lodash_es.set(concept, `altLabel.${label.lang}`, [label.value]);
+        }
+      }
+    }
+    const notation = skosmosConcept.notation || skosmosConcept["skos:notation"] || import_jskos_tools8.default.notation(concept);
+    if (notation) {
+      concept.notation = [notation.value || notation];
+    }
+    if (skosmosConcept.broader) {
+      if (!import_lodash_es.isArray(skosmosConcept.broader)) {
+        skosmosConcept.broader = [skosmosConcept.broader];
+      }
+      concept.broader = skosmosConcept.broader.map((concept2) => import_lodash_es.isString(concept2) ? { uri: concept2 } : concept2);
+    }
+    if (skosmosConcept.hasChildren === true) {
+      concept.narrower = [null];
+    } else if (skosmosConcept.hasChildren === false) {
+      concept.narrower = [];
+    }
+    if (skosmosConcept.type && !import_lodash_es.isArray(skosmosConcept.type)) {
+      skosmosConcept.type = [skosmosConcept.type];
+    }
+    concept.type = concept.type || [];
+    for (let type of skosmosConcept.type || []) {
+      if (!import_jskos_tools8.default.isValidUri(type)) {
+        continue;
+      }
+      const uriScheme = type.slice(0, type.indexOf(":"));
+      if (result && result["@context"] && result["@context"][uriScheme]) {
+        type = type.replace(uriScheme + ":", result["@context"][uriScheme]);
+      }
+      concept.type.push(type);
+    }
+    concept.type = import_lodash_es.uniq(concept.type);
+    if (!concept.type.length) {
+      concept.type = ["http://www.w3.org/2004/02/skos/core#Concept"];
+    }
+    return concept;
+  }
+  async getSchemes({ ...config }) {
+    const schemes = [];
+    for (let scheme of this.schemes || []) {
+      const url = this._getApiUrl(scheme, "/");
+      const data = await this.axios({
+        ...config,
+        method: "get",
+        url
+      });
+      const resultScheme = data.conceptschemes.find((s) => import_jskos_tools8.default.compare(s, scheme));
+      const label = resultScheme && (resultScheme.prefLabel || resultScheme.label || resultScheme.title);
+      if (label) {
+        import_lodash_es.set(scheme, `prefLabel.${this._language}`, label);
+      }
+      schemes.push(scheme);
+      this._approvedSchemes = this._approvedSchemes || [];
+      if (!this._approvedSchemes.find((s) => import_jskos_tools8.default.compare(scheme, s))) {
+        this._approvedSchemes.push({
+          uri: resultScheme.uri,
+          identifier: import_jskos_tools8.default.getAllUris(scheme)
+        });
+      }
+    }
+    return schemes;
+  }
+  async getTop({ scheme, ...config }) {
+    const url = this._getApiUrl(scheme, "/topConcepts");
+    const schemeUri = await this._getSchemeUri(scheme);
+    if (!schemeUri) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "Missing or unsupported scheme or VOCID property on scheme" });
+    }
+    import_lodash_es.set(config, "params.scheme", schemeUri);
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    const concepts = [];
+    for (let concept of response.topconcepts || []) {
+      const newConcept = this._toJskosConcept(concept, {
+        scheme,
+        language: this._language
+      });
+      newConcept.topConceptOf = [scheme];
+      concepts.push(newConcept);
+    }
+    return concepts;
+  }
+  async getConcepts({ concepts, ...config }) {
+    if (!import_lodash_es.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    concepts = concepts.map((c) => ({ uri: c.uri, inScheme: c.inScheme }));
+    const newConcepts = [];
+    for (let concept of concepts) {
+      const url = this._getDataUrl(concept, { addFormatParameter: false });
+      if (!url) {
+        continue;
+      }
+      const result = await this.axios({
+        ...config,
+        method: "get",
+        url,
+        params: {
+          uri: concept.uri,
+          format: "application/json"
+        }
+      });
+      const resultConcept = result && result.graph && result.graph.find((c) => import_jskos_tools8.default.compare(c, concept));
+      if (resultConcept) {
+        const newConcept = this._toJskosConcept(resultConcept, { concept, result });
+        for (let type of ["broader", "narrower"]) {
+          let relatives = resultConcept[type] || newConcept[type];
+          if (relatives && !import_lodash_es.isArray(relatives)) {
+            relatives = [relatives];
+          }
+          if (!relatives) {
+            relatives = [];
+          }
+          newConcept[type] = relatives.map((r) => this._toJskosConcept(result.graph.find((c) => import_jskos_tools8.default.compare(c, r)), { scheme: concept.inScheme[0], result }));
+        }
+        newConcept.ancestors = [];
+        newConcepts.push(newConcept);
+      }
+    }
+    return newConcepts;
+  }
+  async getNarrower({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    const scheme = concept.inScheme[0];
+    const url = this._getApiUrl(scheme, "/children");
+    import_lodash_es.set(config, "params.uri", concept.uri);
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    const concepts = (response.narrower || []).map((c) => this._toJskosConcept(c, { scheme }));
+    return concepts;
+  }
+  async getAncestors({ concept, ...config }) {
+    if (!concept || !concept.uri) {
+      throw new InvalidOrMissingParameterError({ parameter: "concept" });
+    }
+    const scheme = concept.inScheme[0];
+    const url = this._getApiUrl(scheme, "/broaderTransitive");
+    import_lodash_es.set(config, "params.uri", concept.uri);
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    let ancestors = [];
+    let uri = concept.uri;
+    while (uri) {
+      if (uri != concept.uri) {
+        const ancestor = import_lodash_es.get(response, `broaderTransitive["${uri}"]`);
+        ancestors = [ancestor].concat(ancestors);
+      }
+      uri = import_lodash_es.get(response, `broaderTransitive["${uri}"].broader[0]`);
+    }
+    const concepts = ancestors.map((c) => this._toJskosConcept(c, { scheme })).filter((c) => c.uri != concept.uri);
+    return concepts;
+  }
+  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_tools8.default.notation(concept);
+      const label = import_jskos_tools8.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;
+  }
+  async search({ search, scheme, limit, types = [], ...config }) {
+    const url = this._getApiUrl(scheme, "/search");
+    import_lodash_es.set(config, "params.query", `${search}*`);
+    import_lodash_es.set(config, "params.unique", 1);
+    import_lodash_es.set(config, "params.maxhits", limit || 100);
+    import_lodash_es.set(config, "params.type", types.join(" "));
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    const concepts = (response.results || []).map((c) => this._toJskosConcept(c, { scheme }));
+    return concepts;
+  }
+  async getTypes({ scheme, ...config }) {
+    const url = this._getApiUrl(scheme, "/types");
+    const types = [];
+    const response = await this.axios({
+      ...config,
+      method: "get",
+      url
+    });
+    for (let type of response && response.types || []) {
+      if (type.uri == "http://www.w3.org/2004/02/skos/core#Concept") {
+        continue;
+      }
+      if (type.label) {
+        type.prefLabel = {
+          [response["@context"]["@language"]]: type.label
+        };
+        delete type.label;
+      }
+      types.push(type);
+    }
+    types._url = url;
+    return types;
+  }
+};
+SkosmosApiProvider.providerName = "SkosmosApi";
+SkosmosApiProvider.providerType = "http://bartoc.org/api-type/skosmos";
+
+// src/providers/loc-api-provider.js
+var import_jskos_tools9 = __toModule(require("jskos-tools"));
+var import_axios2 = __toModule(require("axios"));
+var locUriPrefix = "http://id.loc.gov/authorities/";
+var supportedSchemes = [
+  {
+    uri: `${locUriPrefix}subjects`,
+    identifier: [
+      "http://bartoc.org/en/node/454"
+    ],
+    notation: ["LCSH"],
+    concepts: [null],
+    topConcepts: []
+  },
+  {
+    uri: `${locUriPrefix}names`,
+    identifier: [
+      "http://bartoc.org/en/node/18536"
+    ],
+    notation: ["LCNAF"],
+    concepts: [null],
+    topConcepts: []
+  }
+];
+var lccUri = `${locUriPrefix}classification`;
+function madsToJskosItem(data) {
+  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"] || [];
+  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"] || [];
+  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"] || []) {
+    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);
+  scheme.namespace = scheme.uri + "/";
+  scheme.type = ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
+  return scheme;
+}
+var schemeNamespaceFilter = (scheme) => (c) => {
+  if (!c || !scheme || !scheme.namespace) {
+    return true;
+  }
+  return c.uri.startsWith(scheme.namespace);
+};
+function madsToJskosConcept(data, { scheme }) {
+  const concept = madsToJskosItem(data);
+  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"]));
+  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"] || [];
+  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"] || [];
+  concept.broader = broader.map((n) => ({ uri: n["@id"] })).filter(schemeNamespaceFilter(concept.inScheme && concept.inScheme[0]));
+  return concept;
+}
+var LocApiProvider = class extends BaseProvider {
+  _setup() {
+    this.has.schemes = true;
+    this.has.top = false;
+    this.has.data = true;
+    this.has.concepts = true;
+    this.has.narrower = true;
+    this.has.ancestors = false;
+    this.has.suggest = true;
+    this.has.search = true;
+  }
+  static _registryConfigForBartocApiConfig({ scheme } = {}) {
+    if (!scheme || !supportedSchemes.find((s) => import_jskos_tools9.default.compare(s, scheme))) {
+      return null;
+    }
+    return {
+      schemes: [scheme]
+    };
+  }
+  async getSchemes() {
+    const schemes = [];
+    for (let scheme of await Promise.all(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 }) => {
+      if (status === 200) {
+        let scheme2 = data.find((d) => s.uri === d["@id"]);
+        if (scheme2) {
+          scheme2 = import_jskos_tools9.default.merge(madsToJskosScheme(scheme2), s);
+          scheme2.topConcepts = (scheme2.topConcepts || []).filter((c) => c);
+          return scheme2;
+        }
+      }
+      return null;
+    })))) {
+      if (scheme) {
+        schemes.push(scheme);
+      }
+    }
+    return schemes;
+  }
+  async getConcepts({ concepts }) {
+    if (!Array.isArray(concepts)) {
+      concepts = [concepts];
+    }
+    const resultConcepts = [];
+    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 }) => {
+      if (status === 200) {
+        let concept2 = data.find((d) => c.uri === d["@id"]);
+        if (concept2) {
+          return madsToJskosConcept(concept2, { scheme: c.inScheme && c.inScheme[0] });
+        }
+        return null;
+      }
+    })))) {
+      if (concept) {
+        resultConcepts.push(concept);
+      }
+    }
+    return resultConcepts;
+  }
+  async suggest(config) {
+    const results = await this.search(config);
+    return [
+      config.search,
+      results.map((c) => {
+        let string = "";
+        const notation = import_jskos_tools9.default.notation(c);
+        if (notation) {
+          string += notation + " ";
+        }
+        string += import_jskos_tools9.default.prefLabel(c, { fallbackToUri: string === "" });
+        return string;
+      }),
+      [],
+      results.map((c) => c.uri)
+    ];
+  }
+  async search({ search, scheme, limit, offset }) {
+    const schemeUri = import_jskos_tools9.default.getAllUris(scheme).find((uri) => uri.startsWith(locUriPrefix));
+    if (!schemeUri || !supportedSchemes.find((s) => import_jskos_tools9.default.compare(s, { uri: schemeUri }))) {
+      throw new InvalidOrMissingParameterError({ parameter: "scheme", message: "provided scheme is not supported (yet)" });
+    }
+    if (!search) {
+      throw new InvalidOrMissingParameterError({ parameter: "search", message: "parameter is empty or missing" });
+    }
+    limit = limit || this._jskos.suggestResultLimit || 100;
+    offset = offset || 0;
+    const { data } = await (0, import_axios2.default)({
+      method: "get",
+      url: `${schemeUri}/suggest2`.replace("http:", "https:"),
+      params: {
+        q: search,
+        count: limit || 100,
+        offset,
+        searchtype: "keyword"
+      }
+    });
+    return (data.hits || []).map((d) => ({
+      uri: d.uri,
+      notation: [d.token],
+      prefLabel: { en: d.aLabel },
+      inScheme: [scheme]
+    })).filter(schemeNamespaceFilter(scheme));
+  }
+};
+LocApiProvider.providerName = "LocApi";
+LocApiProvider.providerType = "http://bartoc.org/api-type/loc";
+
+// src/lib/CocodaSDK.js
+var providers = {
+  [BaseProvider.providerName]: BaseProvider,
+  init(registry) {
+    if (this[registry.provider]) {
+      return new this[registry.provider](registry);
+    }
+    throw new InvalidProviderError();
+  },
+  addProvider(provider) {
+    if (provider.prototype instanceof BaseProvider || provider === BaseProvider) {
+      this[provider.providerName] = provider;
+    } else {
+      throw new InvalidProviderError();
+    }
+  }
+};
+providers.addProvider(ConceptApiProvider);
+providers.addProvider(MappingsApiProvider);
+var CocodaSDK = class {
+  constructor(config) {
+    this.config = config;
+    this.axios = import_axios3.default.create();
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  get config() {
+    return this._config;
+  }
+  set config(config) {
+    config = config || {};
+    config.registries = config.registries || [];
+    config.registries = config.registries.map((registry) => providers.init(registry)).filter((r) => r);
+    config.registries.forEach((registry) => {
+      registry.cdk = this;
+    });
+    this._config = config;
+  }
+  get providers() {
+    return providers;
+  }
+  createInstance(config) {
+    return new CocodaSDK(config);
+  }
+  async loadConfig(url) {
+    const response = await this.axios.get(url);
+    this.config = response.data;
+  }
+  loadBuildInfo({ url, buildInfo = null, interval = 6e4, callback, ...config }) {
+    if (!url && !this.config.cocodaBaseUrl) {
+      throw new CDKError({ message: "Could not determine URL to load build config." });
+    }
+    if (!url) {
+      url = `${this.config.cocodaBaseUrl}build-info.json`;
+    }
+    return this.repeat({
+      ...config,
+      function: async () => {
+        return (await this.axios.get(url, {
+          headers: {
+            "Cache-Control": "no-cache"
+          }
+        })).data;
+      },
+      interval,
+      callback: (error, result, previousResult) => {
+        if (error) {
+          callback(error);
+        } else if (previousResult || !previousResult && buildInfo && !import_lodash_es.isEqual(result, buildInfo)) {
+          callback(null, result, previousResult || buildInfo);
+        }
+      }
+    });
+  }
+  getRegistryForUri(uri) {
+    return this.config.registries.find((r) => r.uri == uri);
+  }
+  initializeRegistry(registry) {
+    registry = providers.init(registry);
+    registry.cdk = this;
+    return registry;
+  }
+  addProvider(provider) {
+    providers.addProvider(provider);
+  }
+  static addProvider(provider) {
+    providers.addProvider(provider);
+  }
+  repeat({ function: func, interval = 15e3, callback, callImmediately = true } = {}) {
+    if (!func) {
+      throw new InvalidOrMissingParameterError({ parameter: "function" });
+    }
+    if (typeof func != "function") {
+      throw new InvalidOrMissingParameterError({ parameter: "function", message: "function needs to be a function" });
+    }
+    const asyncFunc = async () => func();
+    interval = parseInt(interval);
+    if (isNaN(interval)) {
+      throw new InvalidOrMissingParameterError({ parameter: "interval" });
+    }
+    if (!callback) {
+      throw new InvalidOrMissingParameterError({ parameter: "callback" });
+    }
+    if (typeof callback != "function") {
+      throw new InvalidOrMissingParameterError({ parameter: "callback", message: "callback needs to be a function" });
+    }
+    let repeat = {
+      timer: null,
+      result: null,
+      error: null,
+      isPaused: false
+    };
+    const handleResult = (result) => {
+      const previousResult = repeat.result;
+      if (!import_lodash_es.isEqual(previousResult, result)) {
+        repeat.result = result;
+        repeat.error = null;
+        callback(null, result, previousResult);
+      }
+    };
+    const handleError = (error) => {
+      repeat.error = error;
+      callback(error);
+    };
+    const repeatIfNecessary = (toCall) => {
+      if (repeat.isPaused) {
+        return;
+      }
+      repeat.timer = setTimeout(() => {
+        toCall();
+      }, interval);
+    };
+    const call = () => asyncFunc().then(handleResult).catch(handleError).then(() => repeatIfNecessary(call));
+    const setup = (_callImmediately = callImmediately) => {
+      if (_callImmediately) {
+        call();
+      } else {
+        repeatIfNecessary(call);
+      }
+    };
+    setup();
+    return {
+      start: (...params) => {
+        repeat.isPaused = false;
+        setup(...params);
+      },
+      stop: () => {
+        repeat.isPaused = true;
+        if (repeat.timer) {
+          clearTimeout(repeat.timer);
+        } else {
+          setTimeout(() => {
+            repeat.timer && clearTimeout(repeat.timer);
+          }, interval);
+        }
+      },
+      get isPaused() {
+        return repeat.isPaused;
+      },
+      get lastResult() {
+        return repeat.result;
+      },
+      get hasErrored() {
+        return !!repeat.error;
+      }
+    };
+  }
+  async getSchemes(config = {}) {
+    let schemes = [], promises = [];
+    for (let registry of this.config.registries) {
+      if (registry.has.schemes) {
+        let promise = registry.getSchemes(config).then((results) => {
+          for (let scheme of results) {
+            scheme.__DETAILSLOADED__ = 1;
+            scheme.type = scheme.type || ["http://www.w3.org/2004/02/skos/core#ConceptScheme"];
+            let otherScheme = schemes.find((s) => import_jskos_tools10.default.compare(s, scheme)), prio, otherPrio, override = false;
+            if (otherScheme) {
+              prio = this.config.registries.indexOf(registry);
+              if (prio != -1) {
+                prio = this.config.registries.length - prio;
+              }
+              otherPrio = this.config.registries.indexOf(import_lodash_es.get(otherScheme, "_registry"));
+              if (otherPrio != -1) {
+                otherPrio = this.config.registries.length - otherPrio;
+              }
+              let currentHasConcepts = !scheme.concepts ? 0 : scheme.concepts.length == 0 ? -1 : 1;
+              let otherHasConcepts = !otherScheme.concepts ? 0 : otherScheme.concepts.length == 0 ? -1 : 1;
+              if (currentHasConcepts > otherHasConcepts) {
+                override = true;
+              } else if (currentHasConcepts < otherHasConcepts) {
+                override = false;
+              } else {
+                override = otherPrio < prio;
+              }
+            }
+            if (!otherScheme || override) {
+              if (override) {
+                let otherSchemeIndex = schemes.findIndex((s) => import_jskos_tools10.default.compare(s, otherScheme));
+                if (otherSchemeIndex != -1) {
+                  schemes.splice(otherSchemeIndex, 1);
+                }
+                scheme = import_jskos_tools10.default.merge(scheme, otherScheme, { mergeUris: true, skipPaths: ["_registry"] });
+              }
+              scheme._registry = registry;
+              schemes.push(scheme);
+            } else {
+              let index = schemes.findIndex((s) => import_jskos_tools10.default.compare(s, scheme));
+              if (index != -1) {
+                let registry2 = schemes[index]._registry;
+                schemes[index] = import_jskos_tools10.default.merge(schemes[index], import_lodash_es.omit(scheme, ["concepts", "topConcepts"]), { mergeUris: true, skipPaths: ["_registry"] });
+                schemes[index]._registry = registry2;
+              }
+            }
+          }
+        }).catch((error) => {
+          console.warn("Couldn't load schemes for registry", registry.uri, error);
+        });
+        promises.push(promise);
+      }
+    }
+    return Promise.all(promises).then(() => {
+      for (let scheme of schemes) {
+        if (scheme.concepts && scheme.concepts.length == 0) {
+          delete scheme.concepts;
+        }
+        if (scheme.topConcepts && scheme.topConcepts.length == 0) {
+          delete scheme.topConcepts;
+        }
+      }
+      schemes = schemes.filter((scheme) => scheme != null);
+      schemes = import_jskos_tools10.default.sortSchemes(schemes);
+      return schemes;
+    });
+  }
+  registryForScheme(scheme) {
+    let registry = scheme._registry;
+    if (registry) {
+      return registry;
+    }
+    for (let { type, ...config } of scheme.API || []) {
+      const provider = Object.values(providers).find((p) => p.providerType === type);
+      if (!provider || !provider._registryConfigForBartocApiConfig) {
+        continue;
+      }
+      const providerName = provider.providerName;
+      config.scheme = scheme;
+      config = providers[providerName]._registryConfigForBartocApiConfig(config);
+      if (!config) {
+        continue;
+      }
+      config.provider = providerName;
+      try {
+        registry = this.initializeRegistry(config);
+        return registry;
+      } catch (error) {
+        continue;
+      }
+    }
+    return null;
+  }
+};
+
+// src/index.js
+var cdk = new CocodaSDK();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseProvider,
+  CocodaSDK,
+  ConceptApiProvider,
+  LabelSearchSuggestionProvider,
+  LocApiProvider,
+  LocalMappingsProvider,
+  MappingsApiProvider,
+  OccurrencesApiProvider,
+  ReconciliationApiProvider,
+  SkosmosApiProvider,
+  cdk,
+  errors
+});