@sfgrp/distinguish 0.0.1

package/dist/interactive-key.es.js

@@ -0,0 +1,2881 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { reactive, toRefs, defineComponent, computed, openBlock, createElementBlock, withDirectives, createElementVNode, isRef, vModelCheckbox, unref, createTextVNode, Fragment, renderList, toDisplayString, vModelSelect, normalizeClass, renderSlot, onMounted, onUnmounted, createBlock, Transition, withCtx, normalizeStyle, withModifiers, ref, createVNode, createCommentVNode, pushScopeId, popScopeId, watch, withKeys, vModelText, resolveDynamicComponent, createApp } from "vue";
+import { defineStore, createPinia } from "pinia";
+const state = reactive({
+  baseURL: "",
+  projectId: void 0,
+  projectToken: void 0,
+  userToken: void 0
+});
+const useAPIConfig = () => {
+  const updatePreferences = (preferences) => {
+    Object.assign(state, preferences);
+  };
+  return __spreadProps(__spreadValues({}, toRefs(state)), {
+    updatePreferences
+  });
+};
+var axios$2 = { exports: {} };
+var bind$2 = function bind(fn, thisArg) {
+  return function wrap() {
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+    return fn.apply(thisArg, args);
+  };
+};
+var bind$1 = bind$2;
+var toString = Object.prototype.toString;
+var kindOf = function(cache) {
+  return function(thing) {
+    var str = toString.call(thing);
+    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+  };
+}(/* @__PURE__ */ Object.create(null));
+function kindOfTest(type) {
+  type = type.toLowerCase();
+  return function isKindOf(thing) {
+    return kindOf(thing) === type;
+  };
+}
+function isArray(val) {
+  return Array.isArray(val);
+}
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+}
+var isArrayBuffer = kindOfTest("ArrayBuffer");
+function isArrayBufferView(val) {
+  var result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && isArrayBuffer(val.buffer);
+  }
+  return result;
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isObject(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject(val) {
+  if (kindOf(val) !== "object") {
+    return false;
+  }
+  var prototype2 = Object.getPrototypeOf(val);
+  return prototype2 === null || prototype2 === Object.prototype;
+}
+var isDate = kindOfTest("Date");
+var isFile = kindOfTest("File");
+var isBlob = kindOfTest("Blob");
+var isFileList = kindOfTest("FileList");
+function isFunction(val) {
+  return toString.call(val) === "[object Function]";
+}
+function isStream(val) {
+  return isObject(val) && isFunction(val.pipe);
+}
+function isFormData(thing) {
+  var pattern = "[object FormData]";
+  return thing && (typeof FormData === "function" && thing instanceof FormData || toString.call(thing) === pattern || isFunction(thing.toString) && thing.toString() === pattern);
+}
+var isURLSearchParams = kindOfTest("URLSearchParams");
+function trim(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function isStandardBrowserEnv() {
+  if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+    return false;
+  }
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function forEach(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (var i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    for (var key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        fn.call(null, obj[key], key, obj);
+      }
+    }
+  }
+}
+function merge() {
+  var result = {};
+  function assignValue(val, key) {
+    if (isPlainObject(result[key]) && isPlainObject(val)) {
+      result[key] = merge(result[key], val);
+    } else if (isPlainObject(val)) {
+      result[key] = merge({}, val);
+    } else if (isArray(val)) {
+      result[key] = val.slice();
+    } else {
+      result[key] = val;
+    }
+  }
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+function extend(a, b, thisArg) {
+  forEach(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a[key] = bind$1(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+function inherits(constructor, superConstructor, props, descriptors2) {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors2);
+  constructor.prototype.constructor = constructor;
+  props && Object.assign(constructor.prototype, props);
+}
+function toFlatObject(sourceObj, destObj, filter) {
+  var props;
+  var i;
+  var prop;
+  var merged = {};
+  destObj = destObj || {};
+  do {
+    props = Object.getOwnPropertyNames(sourceObj);
+    i = props.length;
+    while (i-- > 0) {
+      prop = props[i];
+      if (!merged[prop]) {
+        destObj[prop] = sourceObj[prop];
+        merged[prop] = true;
+      }
+    }
+    sourceObj = Object.getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+  return destObj;
+}
+function endsWith(str, searchString, position) {
+  str = String(str);
+  if (position === void 0 || position > str.length) {
+    position = str.length;
+  }
+  position -= searchString.length;
+  var lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+}
+function toArray(thing) {
+  if (!thing)
+    return null;
+  var i = thing.length;
+  if (isUndefined(i))
+    return null;
+  var arr = new Array(i);
+  while (i-- > 0) {
+    arr[i] = thing[i];
+  }
+  return arr;
+}
+var isTypedArray = function(TypedArray) {
+  return function(thing) {
+    return TypedArray && thing instanceof TypedArray;
+  };
+}(typeof Uint8Array !== "undefined" && Object.getPrototypeOf(Uint8Array));
+var utils$h = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isStandardBrowserEnv,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM,
+  inherits,
+  toFlatObject,
+  kindOf,
+  kindOfTest,
+  endsWith,
+  toArray,
+  isTypedArray,
+  isFileList
+};
+var utils$g = utils$h;
+function encode(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$2 = function buildURL(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$g.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$g.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$g.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$g.forEach(val, function parseValue(v) {
+        if (utils$g.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$g.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode(key) + "=" + encode(v));
+      });
+    });
+    serializedParams = parts.join("&");
+  }
+  if (serializedParams) {
+    var hashmarkIndex = url.indexOf("#");
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex);
+    }
+    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+  }
+  return url;
+};
+var utils$f = utils$h;
+function InterceptorManager$1() {
+  this.handlers = [];
+}
+InterceptorManager$1.prototype.use = function use(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled,
+    rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager$1.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$1.prototype.forEach = function forEach2(fn) {
+  utils$f.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1 = InterceptorManager$1;
+var utils$e = utils$h;
+var normalizeHeaderName$1 = function normalizeHeaderName(headers, normalizedName) {
+  utils$e.forEach(headers, function processHeader(value, name) {
+    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name];
+    }
+  });
+};
+var utils$d = utils$h;
+function AxiosError$5(message, code, config, request2, response) {
+  Error.call(this);
+  this.message = message;
+  this.name = "AxiosError";
+  code && (this.code = code);
+  config && (this.config = config);
+  request2 && (this.request = request2);
+  response && (this.response = response);
+}
+utils$d.inherits(AxiosError$5, Error, {
+  toJSON: function toJSON() {
+    return {
+      message: this.message,
+      name: this.name,
+      description: this.description,
+      number: this.number,
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      config: this.config,
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  }
+});
+var prototype = AxiosError$5.prototype;
+var descriptors = {};
+[
+  "ERR_BAD_OPTION_VALUE",
+  "ERR_BAD_OPTION",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ERR_NETWORK",
+  "ERR_FR_TOO_MANY_REDIRECTS",
+  "ERR_DEPRECATED",
+  "ERR_BAD_RESPONSE",
+  "ERR_BAD_REQUEST",
+  "ERR_CANCELED"
+].forEach(function(code) {
+  descriptors[code] = { value: code };
+});
+Object.defineProperties(AxiosError$5, descriptors);
+Object.defineProperty(prototype, "isAxiosError", { value: true });
+AxiosError$5.from = function(error, code, config, request2, response, customProps) {
+  var axiosError = Object.create(prototype);
+  utils$d.toFlatObject(error, axiosError, function filter(obj) {
+    return obj !== Error.prototype;
+  });
+  AxiosError$5.call(axiosError, error.message, code, config, request2, response);
+  axiosError.name = error.name;
+  customProps && Object.assign(axiosError, customProps);
+  return axiosError;
+};
+var AxiosError_1 = AxiosError$5;
+var transitional = {
+  silentJSONParsing: true,
+  forcedJSONParsing: true,
+  clarifyTimeoutError: false
+};
+var utils$c = utils$h;
+function toFormData$1(obj, formData) {
+  formData = formData || new FormData();
+  var stack = [];
+  function convertValue(value) {
+    if (value === null)
+      return "";
+    if (utils$c.isDate(value)) {
+      return value.toISOString();
+    }
+    if (utils$c.isArrayBuffer(value) || utils$c.isTypedArray(value)) {
+      return typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+    }
+    return value;
+  }
+  function build(data2, parentKey) {
+    if (utils$c.isPlainObject(data2) || utils$c.isArray(data2)) {
+      if (stack.indexOf(data2) !== -1) {
+        throw Error("Circular reference detected in " + parentKey);
+      }
+      stack.push(data2);
+      utils$c.forEach(data2, function each(value, key) {
+        if (utils$c.isUndefined(value))
+          return;
+        var fullKey = parentKey ? parentKey + "." + key : key;
+        var arr;
+        if (value && !parentKey && typeof value === "object") {
+          if (utils$c.endsWith(key, "{}")) {
+            value = JSON.stringify(value);
+          } else if (utils$c.endsWith(key, "[]") && (arr = utils$c.toArray(value))) {
+            arr.forEach(function(el) {
+              !utils$c.isUndefined(el) && formData.append(fullKey, convertValue(el));
+            });
+            return;
+          }
+        }
+        build(value, fullKey);
+      });
+      stack.pop();
+    } else {
+      formData.append(parentKey, convertValue(data2));
+    }
+  }
+  build(obj);
+  return formData;
+}
+var toFormData_1 = toFormData$1;
+var AxiosError$4 = AxiosError_1;
+var settle$1 = function settle(resolve, reject, response) {
+  var validateStatus2 = response.config.validateStatus;
+  if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
+    resolve(response);
+  } else {
+    reject(new AxiosError$4("Request failed with status code " + response.status, [AxiosError$4.ERR_BAD_REQUEST, AxiosError$4.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response));
+  }
+};
+var utils$b = utils$h;
+var cookies$1 = utils$b.isStandardBrowserEnv() ? function standardBrowserEnv() {
+  return {
+    write: function write(name, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name + "=" + encodeURIComponent(value));
+      if (utils$b.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils$b.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils$b.isString(domain)) {
+        cookie.push("domain=" + domain);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      document.cookie = cookie.join("; ");
+    },
+    read: function read(name) {
+      var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove: function remove(name) {
+      this.write(name, "", Date.now() - 864e5);
+    }
+  };
+}() : function nonStandardBrowserEnv() {
+  return {
+    write: function write() {
+    },
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {
+    }
+  };
+}();
+var isAbsoluteURL$1 = function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+};
+var combineURLs$1 = function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var isAbsoluteURL2 = isAbsoluteURL$1;
+var combineURLs2 = combineURLs$1;
+var buildFullPath$2 = function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL2(requestedURL)) {
+    return combineURLs2(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+var utils$a = utils$h;
+var ignoreDuplicateOf = [
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "user-agent"
+];
+var parseHeaders$1 = function parseHeaders(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i;
+  if (!headers) {
+    return parsed;
+  }
+  utils$a.forEach(headers.split("\n"), function parser(line) {
+    i = line.indexOf(":");
+    key = utils$a.trim(line.substr(0, i)).toLowerCase();
+    val = utils$a.trim(line.substr(i + 1));
+    if (key) {
+      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+        return;
+      }
+      if (key === "set-cookie") {
+        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+      } else {
+        parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+      }
+    }
+  });
+  return parsed;
+};
+var utils$9 = utils$h;
+var isURLSameOrigin$1 = utils$9.isStandardBrowserEnv() ? function standardBrowserEnv2() {
+  var msie = /(msie|trident)/i.test(navigator.userAgent);
+  var urlParsingNode = document.createElement("a");
+  var originURL;
+  function resolveURL(url) {
+    var href = url;
+    if (msie) {
+      urlParsingNode.setAttribute("href", href);
+      href = urlParsingNode.href;
+    }
+    urlParsingNode.setAttribute("href", href);
+    return {
+      href: urlParsingNode.href,
+      protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+      host: urlParsingNode.host,
+      search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+      hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+      hostname: urlParsingNode.hostname,
+      port: urlParsingNode.port,
+      pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+    };
+  }
+  originURL = resolveURL(window.location.href);
+  return function isURLSameOrigin2(requestURL) {
+    var parsed = utils$9.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() : function nonStandardBrowserEnv2() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+var AxiosError$3 = AxiosError_1;
+var utils$8 = utils$h;
+function CanceledError$3(message) {
+  AxiosError$3.call(this, message == null ? "canceled" : message, AxiosError$3.ERR_CANCELED);
+  this.name = "CanceledError";
+}
+utils$8.inherits(CanceledError$3, AxiosError$3, {
+  __CANCEL__: true
+});
+var CanceledError_1 = CanceledError$3;
+var parseProtocol$1 = function parseProtocol(url) {
+  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return match && match[1] || "";
+};
+var utils$7 = utils$h;
+var settle2 = settle$1;
+var cookies = cookies$1;
+var buildURL$1 = buildURL$2;
+var buildFullPath$1 = buildFullPath$2;
+var parseHeaders2 = parseHeaders$1;
+var isURLSameOrigin = isURLSameOrigin$1;
+var transitionalDefaults$1 = transitional;
+var AxiosError$2 = AxiosError_1;
+var CanceledError$2 = CanceledError_1;
+var parseProtocol2 = parseProtocol$1;
+var xhr = function xhrAdapter(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
+    var responseType = config.responseType;
+    var onCanceled;
+    function done() {
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(onCanceled);
+      }
+      if (config.signal) {
+        config.signal.removeEventListener("abort", onCanceled);
+      }
+    }
+    if (utils$7.isFormData(requestData) && utils$7.isStandardBrowserEnv()) {
+      delete requestHeaders["Content-Type"];
+    }
+    var request2 = new XMLHttpRequest();
+    if (config.auth) {
+      var username = config.auth.username || "";
+      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
+      requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+    }
+    var fullPath = buildFullPath$1(config.baseURL, config.url);
+    request2.open(config.method.toUpperCase(), buildURL$1(fullPath, config.params, config.paramsSerializer), true);
+    request2.timeout = config.timeout;
+    function onloadend() {
+      if (!request2) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request2 ? parseHeaders2(request2.getAllResponseHeaders()) : null;
+      var responseData = !responseType || responseType === "text" || responseType === "json" ? request2.responseText : request2.response;
+      var response = {
+        data: responseData,
+        status: request2.status,
+        statusText: request2.statusText,
+        headers: responseHeaders,
+        config,
+        request: request2
+      };
+      settle2(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+      request2 = null;
+    }
+    if ("onloadend" in request2) {
+      request2.onloadend = onloadend;
+    } else {
+      request2.onreadystatechange = function handleLoad() {
+        if (!request2 || request2.readyState !== 4) {
+          return;
+        }
+        if (request2.status === 0 && !(request2.responseURL && request2.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request2.onabort = function handleAbort() {
+      if (!request2) {
+        return;
+      }
+      reject(new AxiosError$2("Request aborted", AxiosError$2.ECONNABORTED, config, request2));
+      request2 = null;
+    };
+    request2.onerror = function handleError() {
+      reject(new AxiosError$2("Network Error", AxiosError$2.ERR_NETWORK, config, request2, request2));
+      request2 = null;
+    };
+    request2.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
+      var transitional3 = config.transitional || transitionalDefaults$1;
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(new AxiosError$2(timeoutErrorMessage, transitional3.clarifyTimeoutError ? AxiosError$2.ETIMEDOUT : AxiosError$2.ECONNABORTED, config, request2));
+      request2 = null;
+    };
+    if (utils$7.isStandardBrowserEnv()) {
+      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
+      if (xsrfValue) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      }
+    }
+    if ("setRequestHeader" in request2) {
+      utils$7.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request2.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils$7.isUndefined(config.withCredentials)) {
+      request2.withCredentials = !!config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request2.responseType = config.responseType;
+    }
+    if (typeof config.onDownloadProgress === "function") {
+      request2.addEventListener("progress", config.onDownloadProgress);
+    }
+    if (typeof config.onUploadProgress === "function" && request2.upload) {
+      request2.upload.addEventListener("progress", config.onUploadProgress);
+    }
+    if (config.cancelToken || config.signal) {
+      onCanceled = function(cancel) {
+        if (!request2) {
+          return;
+        }
+        reject(!cancel || cancel && cancel.type ? new CanceledError$2() : cancel);
+        request2.abort();
+        request2 = null;
+      };
+      config.cancelToken && config.cancelToken.subscribe(onCanceled);
+      if (config.signal) {
+        config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled);
+      }
+    }
+    if (!requestData) {
+      requestData = null;
+    }
+    var protocol = parseProtocol2(fullPath);
+    if (protocol && ["http", "https", "file"].indexOf(protocol) === -1) {
+      reject(new AxiosError$2("Unsupported protocol " + protocol + ":", AxiosError$2.ERR_BAD_REQUEST, config));
+      return;
+    }
+    request2.send(requestData);
+  });
+};
+var _null = null;
+var utils$6 = utils$h;
+var normalizeHeaderName2 = normalizeHeaderName$1;
+var AxiosError$1 = AxiosError_1;
+var transitionalDefaults = transitional;
+var toFormData = toFormData_1;
+var DEFAULT_CONTENT_TYPE = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset(headers, value) {
+  if (!utils$6.isUndefined(headers) && utils$6.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = xhr;
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = xhr;
+  }
+  return adapter;
+}
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$6.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$6.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$3 = {
+  transitional: transitionalDefaults,
+  adapter: getDefaultAdapter(),
+  transformRequest: [function transformRequest(data2, headers) {
+    normalizeHeaderName2(headers, "Accept");
+    normalizeHeaderName2(headers, "Content-Type");
+    if (utils$6.isFormData(data2) || utils$6.isArrayBuffer(data2) || utils$6.isBuffer(data2) || utils$6.isStream(data2) || utils$6.isFile(data2) || utils$6.isBlob(data2)) {
+      return data2;
+    }
+    if (utils$6.isArrayBufferView(data2)) {
+      return data2.buffer;
+    }
+    if (utils$6.isURLSearchParams(data2)) {
+      setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data2.toString();
+    }
+    var isObjectPayload = utils$6.isObject(data2);
+    var contentType = headers && headers["Content-Type"];
+    var isFileList2;
+    if ((isFileList2 = utils$6.isFileList(data2)) || isObjectPayload && contentType === "multipart/form-data") {
+      var _FormData = this.env && this.env.FormData;
+      return toFormData(isFileList2 ? { "files[]": data2 } : data2, _FormData && new _FormData());
+    } else if (isObjectPayload || contentType === "application/json") {
+      setContentTypeIfUnset(headers, "application/json");
+      return stringifySafely(data2);
+    }
+    return data2;
+  }],
+  transformResponse: [function transformResponse(data2) {
+    var transitional3 = this.transitional || defaults$3.transitional;
+    var silentJSONParsing = transitional3 && transitional3.silentJSONParsing;
+    var forcedJSONParsing = transitional3 && transitional3.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$6.isString(data2) && data2.length) {
+      try {
+        return JSON.parse(data2);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
+          }
+          throw e;
+        }
+      }
+    }
+    return data2;
+  }],
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  env: {
+    FormData: _null
+  },
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      "Accept": "application/json, text/plain, */*"
+    }
+  }
+};
+utils$6.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+  defaults$3.headers[method] = {};
+});
+utils$6.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  defaults$3.headers[method] = utils$6.merge(DEFAULT_CONTENT_TYPE);
+});
+var defaults_1 = defaults$3;
+var utils$5 = utils$h;
+var defaults$2 = defaults_1;
+var transformData$1 = function transformData(data2, headers, fns) {
+  var context = this || defaults$2;
+  utils$5.forEach(fns, function transform(fn) {
+    data2 = fn.call(context, data2, headers);
+  });
+  return data2;
+};
+var isCancel$1 = function isCancel(value) {
+  return !!(value && value.__CANCEL__);
+};
+var utils$4 = utils$h;
+var transformData2 = transformData$1;
+var isCancel2 = isCancel$1;
+var defaults$1 = defaults_1;
+var CanceledError$1 = CanceledError_1;
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+  if (config.signal && config.signal.aborted) {
+    throw new CanceledError$1();
+  }
+}
+var dispatchRequest$1 = function dispatchRequest(config) {
+  throwIfCancellationRequested(config);
+  config.headers = config.headers || {};
+  config.data = transformData2.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils$4.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils$4.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
+    delete config.headers[method];
+  });
+  var adapter = config.adapter || defaults$1.adapter;
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+    response.data = transformData2.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel2(reason)) {
+      throwIfCancellationRequested(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData2.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$3 = utils$h;
+var mergeConfig$2 = function mergeConfig(config1, config2) {
+  config2 = config2 || {};
+  var config = {};
+  function getMergedValue(target, source2) {
+    if (utils$3.isPlainObject(target) && utils$3.isPlainObject(source2)) {
+      return utils$3.merge(target, source2);
+    } else if (utils$3.isPlainObject(source2)) {
+      return utils$3.merge({}, source2);
+    } else if (utils$3.isArray(source2)) {
+      return source2.slice();
+    }
+    return source2;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$3.isUndefined(config2[prop])) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$3.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function valueFromConfig2(prop) {
+    if (!utils$3.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    }
+  }
+  function defaultToConfig2(prop) {
+    if (!utils$3.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    } else if (!utils$3.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function mergeDirectKeys(prop) {
+    if (prop in config2) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (prop in config1) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  var mergeMap = {
+    "url": valueFromConfig2,
+    "method": valueFromConfig2,
+    "data": valueFromConfig2,
+    "baseURL": defaultToConfig2,
+    "transformRequest": defaultToConfig2,
+    "transformResponse": defaultToConfig2,
+    "paramsSerializer": defaultToConfig2,
+    "timeout": defaultToConfig2,
+    "timeoutMessage": defaultToConfig2,
+    "withCredentials": defaultToConfig2,
+    "adapter": defaultToConfig2,
+    "responseType": defaultToConfig2,
+    "xsrfCookieName": defaultToConfig2,
+    "xsrfHeaderName": defaultToConfig2,
+    "onUploadProgress": defaultToConfig2,
+    "onDownloadProgress": defaultToConfig2,
+    "decompress": defaultToConfig2,
+    "maxContentLength": defaultToConfig2,
+    "maxBodyLength": defaultToConfig2,
+    "beforeRedirect": defaultToConfig2,
+    "transport": defaultToConfig2,
+    "httpAgent": defaultToConfig2,
+    "httpsAgent": defaultToConfig2,
+    "cancelToken": defaultToConfig2,
+    "socketPath": defaultToConfig2,
+    "responseEncoding": defaultToConfig2,
+    "validateStatus": mergeDirectKeys
+  };
+  utils$3.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    var merge2 = mergeMap[prop] || mergeDeepProperties;
+    var configValue = merge2(prop);
+    utils$3.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+  });
+  return config;
+};
+var data = {
+  "version": "0.27.2"
+};
+var VERSION = data.version;
+var AxiosError = AxiosError_1;
+var validators$1 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+  validators$1[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings = {};
+validators$1.transitional = function transitional2(validator2, version, message) {
+  function formatMessage(opt, desc) {
+    return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new AxiosError(formatMessage(opt, " has been removed" + (version ? " in " + version : "")), AxiosError.ERR_DEPRECATED);
+    }
+    if (version && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+      console.warn(formatMessage(opt, " has been deprecated since v" + version + " and will be removed in the near future"));
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options !== "object") {
+    throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE);
+  }
+  var keys = Object.keys(options);
+  var i = keys.length;
+  while (i-- > 0) {
+    var opt = keys[i];
+    var validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new AxiosError("option " + opt + " must be " + result, AxiosError.ERR_BAD_OPTION_VALUE);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw new AxiosError("Unknown option " + opt, AxiosError.ERR_BAD_OPTION);
+    }
+  }
+}
+var validator$1 = {
+  assertOptions,
+  validators: validators$1
+};
+var utils$2 = utils$h;
+var buildURL2 = buildURL$2;
+var InterceptorManager = InterceptorManager_1;
+var dispatchRequest2 = dispatchRequest$1;
+var mergeConfig$1 = mergeConfig$2;
+var buildFullPath2 = buildFullPath$2;
+var validator = validator$1;
+var validators = validator.validators;
+function Axios$1(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
+}
+Axios$1.prototype.request = function request(configOrUrl, config) {
+  if (typeof configOrUrl === "string") {
+    config = config || {};
+    config.url = configOrUrl;
+  } else {
+    config = configOrUrl || {};
+  }
+  config = mergeConfig$1(this.defaults, config);
+  if (config.method) {
+    config.method = config.method.toLowerCase();
+  } else if (this.defaults.method) {
+    config.method = this.defaults.method.toLowerCase();
+  } else {
+    config.method = "get";
+  }
+  var transitional3 = config.transitional;
+  if (transitional3 !== void 0) {
+    validator.assertOptions(transitional3, {
+      silentJSONParsing: validators.transitional(validators.boolean),
+      forcedJSONParsing: validators.transitional(validators.boolean),
+      clarifyTimeoutError: validators.transitional(validators.boolean)
+    }, false);
+  }
+  var requestInterceptorChain = [];
+  var synchronousRequestInterceptors = true;
+  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+    if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+      return;
+    }
+    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+  });
+  var responseInterceptorChain = [];
+  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+  });
+  var promise;
+  if (!synchronousRequestInterceptors) {
+    var chain = [dispatchRequest2, void 0];
+    Array.prototype.unshift.apply(chain, requestInterceptorChain);
+    chain = chain.concat(responseInterceptorChain);
+    promise = Promise.resolve(config);
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
+    }
+    return promise;
+  }
+  var newConfig = config;
+  while (requestInterceptorChain.length) {
+    var onFulfilled = requestInterceptorChain.shift();
+    var onRejected = requestInterceptorChain.shift();
+    try {
+      newConfig = onFulfilled(newConfig);
+    } catch (error) {
+      onRejected(error);
+      break;
+    }
+  }
+  try {
+    promise = dispatchRequest2(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$1.prototype.getUri = function getUri(config) {
+  config = mergeConfig$1(this.defaults, config);
+  var fullPath = buildFullPath2(config.baseURL, config.url);
+  return buildURL2(fullPath, config.params, config.paramsSerializer);
+};
+utils$2.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
+  Axios$1.prototype[method] = function(url, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils$2.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
+  function generateHTTPMethod(isForm) {
+    return function httpMethod(url, data2, config) {
+      return this.request(mergeConfig$1(config || {}, {
+        method,
+        headers: isForm ? {
+          "Content-Type": "multipart/form-data"
+        } : {},
+        url,
+        data: data2
+      }));
+    };
+  }
+  Axios$1.prototype[method] = generateHTTPMethod();
+  Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
+});
+var Axios_1 = Axios$1;
+var CanceledError = CanceledError_1;
+function CancelToken(executor) {
+  if (typeof executor !== "function") {
+    throw new TypeError("executor must be a function.");
+  }
+  var resolvePromise;
+  this.promise = new Promise(function promiseExecutor(resolve) {
+    resolvePromise = resolve;
+  });
+  var token = this;
+  this.promise.then(function(cancel) {
+    if (!token._listeners)
+      return;
+    var i;
+    var l = token._listeners.length;
+    for (i = 0; i < l; i++) {
+      token._listeners[i](cancel);
+    }
+    token._listeners = null;
+  });
+  this.promise.then = function(onfulfilled) {
+    var _resolve;
+    var promise = new Promise(function(resolve) {
+      token.subscribe(resolve);
+      _resolve = resolve;
+    }).then(onfulfilled);
+    promise.cancel = function reject() {
+      token.unsubscribe(_resolve);
+    };
+    return promise;
+  };
+  executor(function cancel(message) {
+    if (token.reason) {
+      return;
+    }
+    token.reason = new CanceledError(message);
+    resolvePromise(token.reason);
+  });
+}
+CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+  if (this.reason) {
+    throw this.reason;
+  }
+};
+CancelToken.prototype.subscribe = function subscribe(listener) {
+  if (this.reason) {
+    listener(this.reason);
+    return;
+  }
+  if (this._listeners) {
+    this._listeners.push(listener);
+  } else {
+    this._listeners = [listener];
+  }
+};
+CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
+  if (!this._listeners) {
+    return;
+  }
+  var index = this._listeners.indexOf(listener);
+  if (index !== -1) {
+    this._listeners.splice(index, 1);
+  }
+};
+CancelToken.source = function source() {
+  var cancel;
+  var token = new CancelToken(function executor(c) {
+    cancel = c;
+  });
+  return {
+    token,
+    cancel
+  };
+};
+var CancelToken_1 = CancelToken;
+var spread = function spread2(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+};
+var utils$1 = utils$h;
+var isAxiosError = function isAxiosError2(payload) {
+  return utils$1.isObject(payload) && payload.isAxiosError === true;
+};
+var utils = utils$h;
+var bind2 = bind$2;
+var Axios = Axios_1;
+var mergeConfig2 = mergeConfig$2;
+var defaults = defaults_1;
+function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  var instance = bind2(Axios.prototype.request, context);
+  utils.extend(instance, Axios.prototype, context);
+  utils.extend(instance, context);
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig2(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+var axios$1 = createInstance(defaults);
+axios$1.Axios = Axios;
+axios$1.CanceledError = CanceledError_1;
+axios$1.CancelToken = CancelToken_1;
+axios$1.isCancel = isCancel$1;
+axios$1.VERSION = data.version;
+axios$1.toFormData = toFormData_1;
+axios$1.AxiosError = AxiosError_1;
+axios$1.Cancel = axios$1.CanceledError;
+axios$1.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios$1.spread = spread;
+axios$1.isAxiosError = isAxiosError;
+axios$2.exports = axios$1;
+axios$2.exports.default = axios$1;
+var axios = axios$2.exports;
+const useRequest = (instanceConfiguration = {}) => {
+  const {
+    baseURL,
+    projectId,
+    projectToken,
+    userToken,
+    csrfToken
+  } = useAPIConfig();
+  const axiosConfiguration = __spreadValues({
+    baseURL: baseURL.value,
+    params: {
+      project_id: projectId == null ? void 0 : projectId.value,
+      project_token: projectToken == null ? void 0 : projectToken.value,
+      token: userToken == null ? void 0 : userToken.value
+    }
+  }, instanceConfiguration);
+  if (!projectToken || !(projectId && userToken)) {
+    const headers = { "X-CSRF-Token": csrfToken };
+    Object.assign(axiosConfiguration, { headers });
+  }
+  return axios.create(__spreadValues({}, axiosConfiguration));
+};
+class ObservationMatrix {
+  static key(id, params) {
+    return useRequest().get(`/observation_matrices/${id}/key`, params);
+  }
+}
+const makeCharacterState = (data2) => ({
+  characterStateId: data2.id,
+  depictionIds: data2.depiction_ids,
+  label: data2.label,
+  name: data2.name,
+  numberOfObjects: data2.number_of_objects,
+  position: data2.position,
+  status: data2.status
+});
+const makeDepiction = (data2) => ({
+  depictionId: data2.id,
+  caption: data2.caption,
+  figureLabel: data2.figure_label,
+  imageUrl: data2.image.medium
+});
+const descriptorTypes = {
+  Qualitative: "Descriptor::Qualitative",
+  Continuous: "Descriptor::Continuous",
+  Sample: "Descriptor::Sample",
+  Presence: "Descriptor::PresenceAbsence"
+};
+const makeBaseDescriptor = (data2) => ({
+  descriptorId: data2.id,
+  name: data2.name,
+  description: data2.description,
+  position: data2.position,
+  status: data2.status,
+  type: data2.type,
+  depictionIds: data2.depiction_ids,
+  usefulness: data2.usefulness,
+  weight: data2.weight
+});
+const makeDescriptorContinuos = (data2) => __spreadProps(__spreadValues({}, makeBaseDescriptor(data2)), {
+  defaultUnit: data2.default_unit,
+  max: data2.max,
+  min: data2.min
+});
+const makeDescriptorSample = (data2) => __spreadProps(__spreadValues({}, makeBaseDescriptor(data2)), {
+  defaultUnit: data2.default_unit,
+  max: data2.max,
+  min: data2.min
+});
+const makeDescriptorPresenceAbsence = (data2) => __spreadProps(__spreadValues({}, makeBaseDescriptor(data2)), {
+  presence: data2.precense
+});
+const makeDescriptorQualitative = (data2) => __spreadProps(__spreadValues({}, makeBaseDescriptor(data2)), {
+  characterStates: data2.states.map((item) => makeCharacterState(item))
+});
+const makeDescriptor = (data2) => {
+  switch (data2.type) {
+    case descriptorTypes.Continuous:
+      return makeDescriptorContinuos(data2);
+    case descriptorTypes.Sample:
+      return makeDescriptorSample(data2);
+    case descriptorTypes.PresenceAbsence:
+      return makeDescriptorPresenceAbsence(data2);
+    case descriptorTypes.Qualitative:
+      return makeDescriptorQualitative(data2);
+    default:
+      return makeBaseDescriptor(data2);
+  }
+};
+const makeObservationMatrix = (data2) => ({
+  observationMatrixId: data2.observation_matrix_id,
+  name: data2.observation_matrix.name,
+  globalId: data2.observation_matrix.global_id
+});
+const makeRow = (data2) => ({
+  errorDescriptors: data2.error_descriptors,
+  errors: data2.errors,
+  objectLabel: data2.object.object_label,
+  objectTag: data2.object.object_tag,
+  observationObjectId: data2.object.observation_object_id,
+  observationObjectType: data2.object.observation_object_type,
+  rowId: data2.object.id
+});
+const makeKeyword = (data2) => ({
+  keywordId: data2.id,
+  definition: data2.description,
+  name: data2.name
+});
+const makeLanguage = (data2) => ({
+  languageId: data2.id,
+  name: data2.english_name
+});
+const useObservationMatrixStore = defineStore("observationMatrix", {
+  state: () => ({
+    observationMatrix: void 0,
+    citation: void 0,
+    descriptors: [],
+    eliminated: [],
+    remaining: [],
+    availableKeywords: [],
+    availableLanguages: []
+  }),
+  getters: {
+    getCitation: (state2) => state2.citation,
+    getObservationMatrix: (state2) => state2.observationMatrix,
+    getDescriptors: (state2) => state2.descriptors,
+    getDescriptorById: (state2) => (id) => state2.descriptors.find((d) => d.descriptorId === id),
+    getDescriptorsUsed: (state2) => state2.descriptors.filter((d) => d.status === "used"),
+    getDescriptorsUseless: (state2) => state2.descriptors.filter((d) => d.status === "useless"),
+    getDescriptorsUseful: (state2) => state2.descriptors.filter((d) => d.status === "useful"),
+    getEliminated: (state2) => state2.eliminated,
+    getKeywords: (state2) => state2.availableKeywords,
+    getLanguages: (state2) => state2.availableLanguages,
+    getRemaining: (state2) => state2.remaining
+  },
+  actions: {
+    setDescriptors(descriptors2) {
+      this.descriptors = descriptors2;
+    },
+    setEliminated(rows) {
+      this.eliminated = rows;
+    },
+    setRemaining(rows) {
+      this.remaining = rows;
+    },
+    setLanguages(languages) {
+      this.availableLanguages = languages;
+    },
+    setKeywords(keywords) {
+      this.availableKeywords = keywords;
+    },
+    setObservationMatrix(observationMatrix) {
+      this.observationMatrix = observationMatrix;
+    },
+    async requestInteractiveKey({ observationMatrixId, params = {}, opt = {} }) {
+      const request2 = await ObservationMatrix.key(observationMatrixId, { params });
+      const { data: data2 } = request2;
+      if (!opt.refreshOnlyTaxa) {
+        this.setObservationMatrix(makeObservationMatrix(data2));
+        this.setDescriptors(data2.list_of_descriptors.map((d) => makeDescriptor(d)));
+        this.setKeywords(data2.descriptor_available_keywords.map((r) => makeKeyword(r)));
+        this.setLanguages(data2.descriptor_available_languages.map((r) => makeLanguage(r)));
+      }
+      this.setEliminated(data2.eliminated.map((r) => makeRow(r)));
+      this.setRemaining(data2.remaining.map((r) => makeRow(r)));
+      return request2;
+    }
+  }
+});
+const useFilterStore = defineStore("filter", {
+  state: () => ({
+    descriptors: {},
+    eliminateUnknown: void 0,
+    errorTolerance: void 0,
+    identifiedToRank: void 0,
+    keywordIds: [],
+    languageId: void 0,
+    rowIds: [],
+    sorting: void 0
+  }),
+  getters: {
+    getKeywordIds: (state2) => state2.keywordIds,
+    getLanguageId: (state2) => state2.languageId,
+    getRowIds: (state2) => state2.rowIds,
+    getDescriptors: (state2) => state2.descriptors,
+    getIdentifiedToRank: (state2) => state2.identifiedToRank,
+    getEliminateUknown: (state2) => state2.eliminateUnknown,
+    getErrorTolerance: (state2) => state2.errorTolerance,
+    getSorting: (state2) => state2.sorting,
+    getDescriptorValueById: (state2) => (id) => {
+      const value = state2.descriptors[id];
+      return typeof value === "boolean" ? value : value || "";
+    },
+    getFilterParams: (state2) => {
+      const descriptorsParam = Object.entries(state2.descriptors).map(([key, value]) => Array.isArray(value) ? `${key}:${value.join("|")}` : `${key}:${value}`).join("||");
+      return {
+        selected_descriptors: descriptorsParam,
+        language_id: state2.languageId,
+        keyword_ids: state2.keywordIds,
+        sorting: state2.sorting,
+        identified_to_rank: state2.identifiedToRank,
+        error_tolerance: state2.errorTolerance,
+        eliminate_unknown: state2.eliminateUnknown,
+        row_filter: state2.rowIds.join("|")
+      };
+    }
+  },
+  actions: {
+    setDescriptor({ descriptorId, value }) {
+      this.descriptors[descriptorId] = value;
+    },
+    removeDescriptor(descriptorId) {
+      delete this.descriptors[descriptorId];
+    },
+    removeKeywordId(id) {
+      const index = this.keywordIds.findIndex((keywordId) => keywordId === id);
+      if (index > -1) {
+        this.keywordIds.splice(index, 1);
+      }
+    },
+    addKeywordId(id) {
+      this.keywordIds.push(id);
+    },
+    setLanguageId(id) {
+      this.languageId = id;
+    },
+    setErrorTolerance(value) {
+      this.errorTolerance = value;
+    },
+    setEliminateUnknown(value) {
+      this.eliminateUnknown = value;
+    }
+  }
+});
+const useSettingsStore = defineStore("settings", {
+  state: () => ({
+    gridLayout: "layout-mode-1",
+    isLoading: false,
+    isRefreshing: false,
+    refreshOnlyTaxa: false,
+    rowFilter: true,
+    shouldUpdate: true,
+    observationMatrixId: void 0
+  }),
+  getters: {
+    getIsLoading: (state2) => state2.isLoading,
+    getLayout: (state2) => state2.gridLayout,
+    getRefreshOnlyTaxa: (state2) => state2.refreshOnlyTaxa,
+    getRowFilter: (state2) => state2.rowFilter,
+    getShouldUpdate: (state2) => state2.shouldUpdate,
+    getObservationMatrixId: (state2) => state2.observationMatrixId
+  },
+  actions: {
+    setObservationMatrixId(value) {
+      this.observationMatrixId = value;
+    },
+    setShouldUpdate(value) {
+      this.shouldUpdate = value;
+    },
+    setRefreshOnlyTaxa(value) {
+      this.refreshOnlyTaxa = value;
+    },
+    checkUpdate() {
+      const filterStore = useFilterStore();
+      const observationStore = useObservationMatrixStore();
+      const observationMatrixId = this.observationMatrixId;
+      if (this.shouldUpdate && observationMatrixId) {
+        this.isLoading = true;
+        observationStore.requestInteractiveKey({
+          observationMatrixId,
+          params: filterStore.getFilterParams,
+          opt: {
+            refreshOnlyTaxa: this.refreshOnlyTaxa
+          }
+        }).then((_) => {
+          this.isLoading = false;
+        });
+      }
+    }
+  }
+});
+const _hoisted_1$v = /* @__PURE__ */ createTextVNode(" Eliminate unknowns ");
+const _sfc_main$y = /* @__PURE__ */ defineComponent({
+  __name: "FilterEliminateUnknowns",
+  setup(__props) {
+    const store = useFilterStore();
+    const eliminateUknown = computed({
+      get: () => !!store.getEliminateUknown,
+      set: (value) => {
+        store.setEliminateUnknown(value);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", null, [
+        withDirectives(createElementVNode("input", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(eliminateUknown) ? eliminateUknown.value = $event : null),
+          type: "checkbox"
+        }, null, 512), [
+          [vModelCheckbox, unref(eliminateUknown)]
+        ]),
+        _hoisted_1$v
+      ]);
+    };
+  }
+});
+const _hoisted_1$u = /* @__PURE__ */ createElementVNode("label", {
+  for: "languages",
+  class: "d-block"
+}, " Error tolerance ", -1);
+const _hoisted_2$g = /* @__PURE__ */ createElementVNode("option", { value: "" }, null, -1);
+const _hoisted_3$9 = ["value"];
+const _sfc_main$x = /* @__PURE__ */ defineComponent({
+  __name: "FilterErrorTolerance",
+  setup(__props) {
+    const ERROR_TOLERANCE_VALUES = [0, 1, 2];
+    const filterStore = useFilterStore();
+    const errorTolerance = computed({
+      get: () => filterStore.getErrorTolerance,
+      set: (error) => {
+        filterStore.setErrorTolerance(error);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        _hoisted_1$u,
+        withDirectives(createElementVNode("select", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(errorTolerance) ? errorTolerance.value = $event : null),
+          name: "languages",
+          role: "listbox"
+        }, [
+          _hoisted_2$g,
+          (openBlock(), createElementBlock(Fragment, null, renderList(ERROR_TOLERANCE_VALUES, (value) => {
+            return createElementVNode("option", {
+              key: value,
+              value
+            }, toDisplayString(value), 9, _hoisted_3$9);
+          }), 64))
+        ], 512), [
+          [vModelSelect, unref(errorTolerance)]
+        ])
+      ]);
+    };
+  }
+});
+const RANK_TYPES = [
+  "otu",
+  "subspecies",
+  "species",
+  "subgenus",
+  "genus",
+  "subtribe",
+  "tribe",
+  "subfamily",
+  "family"
+];
+const _hoisted_1$t = /* @__PURE__ */ createElementVNode("label", { class: "d-block" }, "Identified to rank", -1);
+const _hoisted_2$f = /* @__PURE__ */ createElementVNode("option", { value: void 0 }, null, -1);
+const _sfc_main$w = /* @__PURE__ */ defineComponent({
+  __name: "FilterRank",
+  setup(__props) {
+    const store = useFilterStore();
+    const rankSelected = computed({
+      get() {
+        return store.getIdentifiedToRank;
+      },
+      set(value) {
+        store.$patch({ identifiedToRank: value });
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        _hoisted_1$t,
+        withDirectives(createElementVNode("select", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(rankSelected) ? rankSelected.value = $event : null)
+        }, [
+          _hoisted_2$f,
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(RANK_TYPES), (rank) => {
+            return openBlock(), createElementBlock("option", { key: rank }, toDisplayString(rank), 1);
+          }), 128))
+        ], 512), [
+          [vModelSelect, unref(rankSelected)]
+        ])
+      ]);
+    };
+  }
+});
+const _hoisted_1$s = /* @__PURE__ */ createElementVNode("label", { class: "d-block" }, "Descriptor sorting", -1);
+const _hoisted_2$e = /* @__PURE__ */ createElementVNode("option", { value: void 0 }, null, -1);
+const _sfc_main$v = /* @__PURE__ */ defineComponent({
+  __name: "FilterSort",
+  setup(__props) {
+    const SORT_TYPES = [
+      "ordered",
+      "weighted",
+      "optimized"
+    ];
+    const store = useFilterStore();
+    const sortDescriptors = computed({
+      get() {
+        return store.getSorting;
+      },
+      set(value) {
+        store.$patch({ sorting: value });
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        _hoisted_1$s,
+        withDirectives(createElementVNode("select", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(sortDescriptors) ? sortDescriptors.value = $event : null)
+        }, [
+          _hoisted_2$e,
+          (openBlock(), createElementBlock(Fragment, null, renderList(SORT_TYPES, (rank) => {
+            return createElementVNode("option", { key: rank }, toDisplayString(rank), 1);
+          }), 64))
+        ], 512), [
+          [vModelSelect, unref(sortDescriptors)]
+        ])
+      ]);
+    };
+  }
+});
+const _hoisted_1$r = /* @__PURE__ */ createElementVNode("label", {
+  for: "languages",
+  class: "d-block"
+}, " Languages ", -1);
+const _hoisted_2$d = ["value"];
+const _sfc_main$u = /* @__PURE__ */ defineComponent({
+  __name: "FilterLanguage",
+  setup(__props) {
+    const filterStore = useFilterStore();
+    const store = useObservationMatrixStore();
+    const language = computed({
+      get: () => filterStore.getLanguageId,
+      set: (languageId) => {
+        filterStore.setLanguageId(Number(languageId));
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        _hoisted_1$r,
+        withDirectives(createElementVNode("select", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(language) ? language.value = $event : null),
+          name: "languages",
+          role: "listbox"
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(store).getLanguages, ({ languageId, name }) => {
+            return openBlock(), createElementBlock("option", {
+              key: languageId,
+              value: languageId
+            }, toDisplayString(name), 9, _hoisted_2$d);
+          }), 128))
+        ], 512), [
+          [vModelSelect, unref(language)]
+        ])
+      ]);
+    };
+  }
+});
+var VBtn_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".btn{border-radius:8px;border:none}.btn-primary-color{background-color:var(--primary-color);color:#fff}.btn-medium-size{min-height:var(--btn-medium-size)}\n")();
+const _sfc_main$t = /* @__PURE__ */ defineComponent({
+  __name: "VBtn",
+  props: {
+    color: { default: "primary" },
+    size: { default: "medium" }
+  },
+  setup(__props) {
+    const props = __props;
+    const buttonClasses = computed(() => [
+      `btn-${props.color}-color`,
+      `btn-${props.size}-size`
+    ]);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        type: "button",
+        class: normalizeClass(["btn", unref(buttonClasses)])
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+var VModal_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => '.modal-mask{position:fixed;z-index:1099;top:0;left:0;width:100%;height:100%;background-color:#00000080;display:table;transition:opacity .3s ease}.modal-wrapper{display:table-cell;vertical-align:middle}.modal-container{position:relative;width:300px;margin:0 auto;padding:20px 30px;background-color:#fff;border-radius:2px;box-shadow:0 2px 8px #00000054;transition:all .3s ease;font-family:IBM Plex Sans,Helvetica,Arial,sans-serif;max-height:90vh;overflow-y:auto}.modal-close{position:absolute;cursor:pointer;top:26px;right:30px;width:10px;height:10px;background-image:image-url("close.svg");background-size:10px 10px;opacity:.4}.modal-close:hover{opacity:1}.modal-header h3{margin-top:0;color:#42b983}.modal-body{margin:20px 0}.modal-default-button{float:right}.modal-enter,.modal-leave-active{opacity:0}.modal-enter .modal-container,.modal-leave-active .modal-container{-webkit-transform:scale(1.1);transform:scale(1.1)}.transparent-modal{background-color:#000c!important}.transparent-modal .modal-header h3{margin:0 0 2em 2em;padding:6px 6px 6px 12px;border-radius:3px;background-color:#0000004d;color:#ffffff80}.transparent-modal .modal-close{right:42px;top:30px;color:#ffffff80;background-image:image-url("w_close.svg")}.transparent-modal .modal-container{width:70%;position:relative;background-color:transparent!important;box-shadow:none}.transparent-modal .modal-container .modal-body{overflow:auto;margin-right:1em;max-height:80vh}.transparent-modal .modal-container .modal-body::-webkit-scrollbar{position:absolute;right:40px;-webkit-appearance:none}.transparent-modal .modal-container .modal-body::-webkit-scrollbar:vertical{width:6px}.transparent-modal .modal-container .modal-body::-webkit-scrollbar:horizontal{height:6px}.transparent-modal .modal-container .modal-body::-webkit-scrollbar-thumb{border-radius:8px;width:11px;height:5px;border:rgba(255,255,255,.5);background-color:#ffffff80}.transparent-modal .modal-container .modal-body::-webkit-scrollbar-track{background-color:#0000004d;border-radius:8px}\n')();
+const _hoisted_1$q = { class: "modal-wrapper" };
+const _hoisted_2$c = { class: "modal-header" };
+const _hoisted_3$8 = { class: "modal-body" };
+const _hoisted_4$5 = { class: "modal-footer" };
+const _sfc_main$s = /* @__PURE__ */ defineComponent({
+  __name: "VModal",
+  props: {
+    containerClass: null,
+    containerStyle: null
+  },
+  emits: ["close"],
+  setup(__props, { emit }) {
+    const handleKeyboard = (event) => {
+      event.preventDefault();
+      if (event.key === "Escape") {
+        emit("close");
+      }
+    };
+    onMounted(() => document.addEventListener("keydown", handleKeyboard));
+    onUnmounted(() => document.removeEventListener("keydown", handleKeyboard));
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: "modal" }, {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            class: "modal-mask",
+            onClick: _cache[2] || (_cache[2] = ($event) => emit("close")),
+            onKey: _cache[3] || (_cache[3] = ($event) => emit("close"))
+          }, [
+            createElementVNode("div", _hoisted_1$q, [
+              createElementVNode("div", {
+                class: normalizeClass(["modal-container", __props.containerClass]),
+                style: normalizeStyle(__spreadValues({}, __props.containerStyle)),
+                onClick: _cache[1] || (_cache[1] = withModifiers(() => {
+                }, ["stop"]))
+              }, [
+                createElementVNode("div", _hoisted_2$c, [
+                  createElementVNode("div", {
+                    class: "modal-close",
+                    onClick: _cache[0] || (_cache[0] = ($event) => emit("close"))
+                  }),
+                  renderSlot(_ctx.$slots, "header")
+                ]),
+                createElementVNode("div", _hoisted_3$8, [
+                  renderSlot(_ctx.$slots, "body")
+                ]),
+                createElementVNode("div", _hoisted_4$5, [
+                  renderSlot(_ctx.$slots, "footer")
+                ])
+              ], 6)
+            ])
+          ], 32)
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const _hoisted_1$p = /* @__PURE__ */ createTextVNode(" Keyword ");
+const _hoisted_2$b = /* @__PURE__ */ createElementVNode("h3", null, "Keywords", -1);
+const _hoisted_3$7 = { class: "list-none p-0" };
+const _hoisted_4$4 = ["value"];
+const _sfc_main$r = /* @__PURE__ */ defineComponent({
+  __name: "FilterKeywords",
+  setup(__props) {
+    const store = useObservationMatrixStore();
+    const filterStore = useFilterStore();
+    const isModalVisible = ref(false);
+    const keywordIds = computed({
+      get: () => filterStore.getKeywordIds,
+      set: (value) => {
+        filterStore.$patch({ keywordIds: value });
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createVNode(_sfc_main$t, {
+          color: "primary",
+          size: "medium",
+          onClick: _cache[0] || (_cache[0] = ($event) => isModalVisible.value = true)
+        }, {
+          default: withCtx(() => [
+            _hoisted_1$p
+          ]),
+          _: 1
+        }),
+        isModalVisible.value ? (openBlock(), createBlock(_sfc_main$s, {
+          key: 0,
+          onClose: _cache[2] || (_cache[2] = ($event) => isModalVisible.value = false)
+        }, {
+          header: withCtx(() => [
+            _hoisted_2$b
+          ]),
+          body: withCtx(() => [
+            createElementVNode("ul", _hoisted_3$7, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(store).getKeywords, ({ keywordId, name }) => {
+                return openBlock(), createElementBlock("li", { key: keywordId }, [
+                  createElementVNode("label", null, [
+                    withDirectives(createElementVNode("input", {
+                      "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(keywordIds) ? keywordIds.value = $event : null),
+                      value: keywordId,
+                      type: "checkbox"
+                    }, null, 8, _hoisted_4$4), [
+                      [vModelCheckbox, unref(keywordIds)]
+                    ]),
+                    createTextVNode(" " + toDisplayString(name), 1)
+                  ])
+                ]);
+              }), 128))
+            ])
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$o = /* @__PURE__ */ createTextVNode(" Refresh only taxa ");
+const _sfc_main$q = /* @__PURE__ */ defineComponent({
+  __name: "SettingRefresh",
+  setup(__props) {
+    const store = useSettingsStore();
+    const refreshTaxa = computed({
+      get: () => store.getRefreshOnlyTaxa,
+      set: (value) => {
+        store.setRefreshOnlyTaxa(value);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", null, [
+        withDirectives(createElementVNode("input", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(refreshTaxa) ? refreshTaxa.value = $event : null),
+          type: "checkbox"
+        }, null, 512), [
+          [vModelCheckbox, unref(refreshTaxa)]
+        ]),
+        _hoisted_1$o
+      ]);
+    };
+  }
+});
+var MenuList_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".menu-list{display:flex;list-style:none;align-items:center;margin:0}.menu-list li:first-child{padding-left:0}\n")();
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$p = {};
+const _hoisted_1$n = { class: "menu-list" };
+function _sfc_render$2(_ctx, _cache) {
+  return openBlock(), createElementBlock("ul", _hoisted_1$n, [
+    renderSlot(_ctx.$slots, "default")
+  ]);
+}
+var MenuList = /* @__PURE__ */ _export_sfc(_sfc_main$p, [["render", _sfc_render$2]]);
+var MenuItem_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => ".list-item[data-v-3f00bdeb]{justify-content:center;padding-left:1em;padding-right:1em;border-right:1px solid #e5e5e5}\n")();
+const _sfc_main$o = {};
+const _hoisted_1$m = { class: "list-item" };
+function _sfc_render$1(_ctx, _cache) {
+  return openBlock(), createElementBlock("li", _hoisted_1$m, [
+    renderSlot(_ctx.$slots, "default", {}, void 0, true)
+  ]);
+}
+var MenuListItem = /* @__PURE__ */ _export_sfc(_sfc_main$o, [["render", _sfc_render$1], ["__scopeId", "data-v-3f00bdeb"]]);
+const LAYOUT_MODES = {
+  "layout-mode-1": "layout-mode-2",
+  "layout-mode-2": "layout-mode-1"
+};
+var VGrid_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => ".grid[data-v-203acd5e]{display:grid;grid-template-columns:repeat(2,1fr);grid-template-rows:repeat(2,1fr);grid-column-gap:0px;grid-row-gap:0px;grid-gap:1px;background-color:var(--border-color);box-shadow:0 2px 2px #0003}\n")();
+const _sfc_main$n = {};
+const _hoisted_1$l = { class: "grid" };
+function _sfc_render(_ctx, _cache) {
+  return openBlock(), createElementBlock("div", _hoisted_1$l, [
+    renderSlot(_ctx.$slots, "default", {}, void 0, true)
+  ]);
+}
+var VGrid = /* @__PURE__ */ _export_sfc(_sfc_main$n, [["render", _sfc_render], ["__scopeId", "data-v-203acd5e"]]);
+var GridToggle_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".grid-icon{width:20px;height:12px;border:2px solid transparent;background-color:transparent;grid-gap:2px}.grid-icon>div{background-color:#fff}\n")();
+const _hoisted_1$k = /* @__PURE__ */ createElementVNode("div", { class: "panel-descriptors" }, null, -1);
+const _hoisted_2$a = /* @__PURE__ */ createElementVNode("div", { class: "panel-remaining" }, null, -1);
+const _hoisted_3$6 = /* @__PURE__ */ createElementVNode("div", { class: "panel-eliminated" }, null, -1);
+const _sfc_main$m = /* @__PURE__ */ defineComponent({
+  __name: "GridToggle",
+  setup(__props) {
+    const store = useSettingsStore();
+    const gridLayout = computed(() => store.getLayout);
+    const setLayout = () => {
+      store.$patch({
+        gridLayout: LAYOUT_MODES[gridLayout.value]
+      });
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$t, {
+        class: normalizeClass(unref(LAYOUT_MODES)[unref(gridLayout)]),
+        onClick: setLayout
+      }, {
+        default: withCtx(() => [
+          createVNode(VGrid, { class: "grid-icon" }, {
+            default: withCtx(() => [
+              _hoisted_1$k,
+              _hoisted_2$a,
+              _hoisted_3$6
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["class"]);
+    };
+  }
+});
+const _hoisted_1$j = /* @__PURE__ */ createTextVNode(" Reset ");
+const _sfc_main$l = /* @__PURE__ */ defineComponent({
+  __name: "ResetButton",
+  setup(__props) {
+    const store = useFilterStore();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$t, {
+        color: "primary",
+        size: "medium",
+        onClick: _cache[0] || (_cache[0] = ($event) => unref(store).$reset())
+      }, {
+        default: withCtx(() => [
+          _hoisted_1$j
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+var HeaderBar_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => ".header-bar[data-v-2f031624]{background-color:var(--bg-panel-color);padding:1em;box-shadow:#24252614 4px 4px 15px;border-radius:.9rem;display:flex;justify-content:space-between;align-items:center}.header-bar__buttons[data-v-2f031624]{display:flex;align-items:center}\n")();
+const _withScopeId$1 = (n) => (pushScopeId("data-v-2f031624"), n = n(), popScopeId(), n);
+const _hoisted_1$i = { class: "header-bar" };
+const _hoisted_2$9 = /* @__PURE__ */ _withScopeId$1(() => /* @__PURE__ */ createElementVNode("div", null, null, -1));
+const _hoisted_3$5 = { class: "header-bar__buttons" };
+const _sfc_main$k = /* @__PURE__ */ defineComponent({
+  __name: "HeaderBar",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$i, [
+        _hoisted_2$9,
+        createVNode(MenuList, null, {
+          default: withCtx(() => [
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$q)
+              ]),
+              _: 1
+            }),
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$y)
+              ]),
+              _: 1
+            }),
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$x)
+              ]),
+              _: 1
+            }),
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$w)
+              ]),
+              _: 1
+            }),
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$u)
+              ]),
+              _: 1
+            }),
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$v)
+              ]),
+              _: 1
+            }),
+            createVNode(MenuListItem, null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$r)
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", _hoisted_3$5, [
+          createVNode(_sfc_main$l, { class: "margin-small-right" }),
+          createVNode(_sfc_main$m)
+        ])
+      ]);
+    };
+  }
+});
+var HeaderBar = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__scopeId", "data-v-2f031624"]]);
+const _hoisted_1$h = ["innerHTML"];
+const _sfc_main$j = /* @__PURE__ */ defineComponent({
+  __name: "PanelRowItem",
+  props: {
+    row: null
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("li", {
+        innerHTML: __props.row.objectTag
+      }, null, 8, _hoisted_1$h);
+    };
+  }
+});
+const _sfc_main$i = /* @__PURE__ */ defineComponent({
+  __name: "PanelEliminated",
+  setup(__props) {
+    const store = useObservationMatrixStore();
+    const eliminated = computed(() => store.getEliminated);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        createElementVNode("h2", null, "Eliminated (" + toDisplayString(unref(eliminated).length) + ")", 1),
+        createElementVNode("ul", null, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(eliminated), (item) => {
+            return openBlock(), createBlock(_sfc_main$j, {
+              key: item.rowId,
+              row: item,
+              class: "margin-small-bottom"
+            }, null, 8, ["row"]);
+          }), 128))
+        ])
+      ]);
+    };
+  }
+});
+const _hoisted_1$g = /* @__PURE__ */ createTextVNode(" Select ");
+const _hoisted_2$8 = /* @__PURE__ */ createElementVNode("h3", null, "Filter row", -1);
+const _hoisted_3$4 = { class: "list-none p-0" };
+const _hoisted_4$3 = ["value"];
+const _sfc_main$h = /* @__PURE__ */ defineComponent({
+  __name: "FilterRow",
+  setup(__props) {
+    const store = useObservationMatrixStore();
+    const settingStore = useSettingsStore();
+    const filterStore = useFilterStore();
+    const isModalVisible = ref(false);
+    const previousRowIds = ref([]);
+    const hasChanged = computed(() => {
+      const newValue = filterStore.getRowIds;
+      const oldValue = previousRowIds.value;
+      return newValue.length !== oldValue.length || !newValue.every((id) => oldValue.includes(id));
+    });
+    const rowIds = computed({
+      get: () => filterStore.getRowIds,
+      set: (value) => {
+        filterStore.$patch({ rowIds: value });
+      }
+    });
+    watch(isModalVisible, (newValue) => {
+      settingStore.setShouldUpdate(!newValue);
+      if (!newValue && hasChanged.value) {
+        settingStore.checkUpdate();
+      }
+      previousRowIds.value = filterStore.getRowIds;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createVNode(_sfc_main$t, {
+          color: "primary",
+          size: "medium",
+          onClick: _cache[0] || (_cache[0] = ($event) => isModalVisible.value = true)
+        }, {
+          default: withCtx(() => [
+            _hoisted_1$g
+          ]),
+          _: 1
+        }),
+        isModalVisible.value ? (openBlock(), createBlock(_sfc_main$s, {
+          key: 0,
+          onClose: _cache[2] || (_cache[2] = ($event) => isModalVisible.value = false)
+        }, {
+          header: withCtx(() => [
+            _hoisted_2$8
+          ]),
+          body: withCtx(() => [
+            createElementVNode("ul", _hoisted_3$4, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(store).getRemaining, (row) => {
+                return openBlock(), createElementBlock("li", {
+                  key: row.rowId
+                }, [
+                  createElementVNode("label", null, [
+                    withDirectives(createElementVNode("input", {
+                      "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(rowIds) ? rowIds.value = $event : null),
+                      value: row.rowId,
+                      type: "checkbox"
+                    }, null, 8, _hoisted_4$3), [
+                      [vModelCheckbox, unref(rowIds)]
+                    ]),
+                    createTextVNode(" " + toDisplayString(row.objectLabel), 1)
+                  ])
+                ]);
+              }), 128))
+            ])
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$f = { class: "d-flex justify-between align-center" };
+const _sfc_main$g = /* @__PURE__ */ defineComponent({
+  __name: "PanelRemaining",
+  setup(__props) {
+    const store = useObservationMatrixStore();
+    const remaining = computed(() => store.getRemaining);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        createElementVNode("div", _hoisted_1$f, [
+          createElementVNode("h2", null, "Remaining (" + toDisplayString(unref(remaining).length) + ")", 1),
+          createVNode(_sfc_main$h)
+        ]),
+        createElementVNode("ul", null, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(remaining), (item) => {
+            return openBlock(), createBlock(_sfc_main$j, {
+              key: item.rowId,
+              row: item,
+              class: "margin-small-bottom"
+            }, null, 8, ["row"]);
+          }), 128))
+        ])
+      ]);
+    };
+  }
+});
+class Depiction {
+  static find(id) {
+    return useRequest().get(`/depictions/${id}.json`, { params: { extend: ["image"] } });
+  }
+}
+var VDepiction_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".depiction-box{display:flex;align-items:center;justify-content:center;border:1px solid black;height:300px;width:300px}\n")();
+const _hoisted_1$e = {
+  key: 0,
+  class: "depiction-box"
+};
+const _hoisted_2$7 = ["src"];
+const _sfc_main$f = /* @__PURE__ */ defineComponent({
+  __name: "VDepiction",
+  props: {
+    depictionId: null
+  },
+  setup(__props) {
+    const props = __props;
+    const depiction = ref();
+    Depiction.find(props.depictionId).then(({ data: data2 }) => {
+      depiction.value = makeDepiction(data2);
+    });
+    return (_ctx, _cache) => {
+      return depiction.value ? (openBlock(), createElementBlock("div", _hoisted_1$e, [
+        createElementVNode("img", {
+          src: depiction.value.imageUrl
+        }, null, 8, _hoisted_2$7)
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+var CharacterStateCell_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".character-descriptor__cell{display:flex;align-items:flex-end}\n")();
+const _hoisted_1$d = { class: "character-descriptor__cell" };
+const _hoisted_2$6 = ["value"];
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
+  __name: "CharacterStateCell",
+  props: {
+    characterState: null,
+    descriptorId: null
+  },
+  setup(__props) {
+    const props = __props;
+    const store = useFilterStore();
+    const updateCharacterStateFilter = computed({
+      get: () => store.getDescriptorValueById(props.descriptorId) || [],
+      set: (value) => {
+        if (value.length) {
+          store.setDescriptor({
+            descriptorId: props.descriptorId,
+            value
+          });
+        } else {
+          store.removeDescriptor(props.descriptorId);
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$d, [
+        createElementVNode("label", null, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.characterState.depictionIds, (depictionId) => {
+            return openBlock(), createBlock(_sfc_main$f, {
+              key: depictionId,
+              "depiction-id": depictionId
+            }, null, 8, ["depiction-id"]);
+          }), 128)),
+          withDirectives(createElementVNode("input", {
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(updateCharacterStateFilter) ? updateCharacterStateFilter.value = $event : null),
+            value: __props.characterState.characterStateId,
+            type: "checkbox"
+          }, null, 8, _hoisted_2$6), [
+            [vModelCheckbox, unref(updateCharacterStateFilter)]
+          ]),
+          createTextVNode(" " + toDisplayString(__props.characterState.name), 1)
+        ])
+      ]);
+    };
+  }
+});
+var CharacterStateGrid_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".character-states-grid{display:grid;grid-template-columns:repeat(3,minmax(33.33%,1fr));gap:1em}\n")();
+const _hoisted_1$c = { class: "character-states-grid" };
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
+  __name: "CharacterStateGrid",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    const props = __props;
+    const filterStore = useFilterStore();
+    const settingStore = useSettingsStore();
+    const descriptorFilter = ref();
+    const hasChanged = computed(() => {
+      const newValue = filterStore.getDescriptorValueById(props.descriptor.descriptorId) || [];
+      const oldValue = descriptorFilter.value || [];
+      return newValue.length !== oldValue.length || !newValue.every((id) => oldValue.includes(id));
+    });
+    onMounted(() => {
+      settingStore.setShouldUpdate(false);
+      descriptorFilter.value = filterStore.getDescriptorValueById(props.descriptor.descriptorId);
+    });
+    onUnmounted(() => {
+      settingStore.setShouldUpdate(true);
+      if (hasChanged.value) {
+        settingStore.checkUpdate();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$c, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(__props.descriptor.characterStates, (characterState) => {
+          return openBlock(), createBlock(_sfc_main$e, {
+            key: characterState.characterStateId,
+            "descriptor-id": __props.descriptor.descriptorId,
+            "character-state": characterState
+          }, null, 8, ["descriptor-id", "character-state"]);
+        }), 128))
+      ]);
+    };
+  }
+});
+var DescriptorModal_vue_vue_type_style_index_0_lang = /* @__PURE__ */ (() => ".descriptor-modal{width:1000px;max-height:90vh;overflow-y:scroll}.descriptor-modal__depiction{display:flex;justify-content:center}\n")();
+const _hoisted_1$b = { key: 0 };
+const _hoisted_2$5 = { class: "descriptor-modal__depiction" };
+const _hoisted_3$3 = /* @__PURE__ */ createElementVNode("hr", null, null, -1);
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorModal",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$s, { "container-class": "descriptor-modal" }, {
+        header: withCtx(() => [
+          createElementVNode("h3", null, toDisplayString(__props.descriptor.name), 1),
+          __props.descriptor.description ? (openBlock(), createElementBlock("span", _hoisted_1$b, toDisplayString(__props.descriptor.description), 1)) : createCommentVNode("", true)
+        ]),
+        body: withCtx(() => [
+          createElementVNode("div", _hoisted_2$5, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.descriptor.depictionIds, (depictionId) => {
+              return openBlock(), createBlock(_sfc_main$f, {
+                key: depictionId,
+                "depiction-id": depictionId
+              }, null, 8, ["depiction-id"]);
+            }), 128))
+          ]),
+          _hoisted_3$3,
+          __props.descriptor.type === unref(descriptorTypes).Qualitative ? (openBlock(), createBlock(_sfc_main$d, {
+            key: 0,
+            descriptor: __props.descriptor
+          }, null, 8, ["descriptor"])) : createCommentVNode("", true)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const _hoisted_1$a = ["id"];
+const _hoisted_2$4 = { class: "d-block" };
+const _sfc_main$b = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorContainer",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    const isModalVisible = ref(false);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("div", {
+          id: `descriptor-${__props.descriptor.descriptorId}`
+        }, [
+          createElementVNode("div", _hoisted_2$4, [
+            createElementVNode("span", {
+              class: "link",
+              onClick: _cache[0] || (_cache[0] = ($event) => isModalVisible.value = true)
+            }, [
+              renderSlot(_ctx.$slots, "title", {}, () => [
+                createTextVNode(toDisplayString(__props.descriptor.name), 1)
+              ])
+            ])
+          ]),
+          renderSlot(_ctx.$slots, "default")
+        ], 8, _hoisted_1$a),
+        isModalVisible.value ? (openBlock(), createBlock(_sfc_main$c, {
+          key: 0,
+          descriptor: __props.descriptor,
+          onClose: _cache[1] || (_cache[1] = ($event) => isModalVisible.value = false)
+        }, null, 8, ["descriptor"])) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$9 = ["onKeyup"];
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorContinuous",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    const props = __props;
+    const useStore = useFilterStore();
+    const fieldValue = ref(String(useStore.getDescriptorValueById(props.descriptor.descriptorId)));
+    const setDescriptorValue = () => {
+      useStore.setDescriptor({
+        descriptorId: props.descriptor.descriptorId,
+        value: fieldValue.value
+      });
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$b, { descriptor: __props.descriptor }, {
+        title: withCtx(() => [
+          createTextVNode(toDisplayString(__props.descriptor.name) + " (" + toDisplayString(__props.descriptor.min) + "-" + toDisplayString(__props.descriptor.max) + " " + toDisplayString(__props.descriptor.defaultUnit) + ") ", 1)
+        ]),
+        default: withCtx(() => [
+          withDirectives(createElementVNode("input", {
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => fieldValue.value = $event),
+            type: "text",
+            onBlur: setDescriptorValue,
+            onKeyup: withKeys(setDescriptorValue, ["enter"])
+          }, null, 40, _hoisted_1$9), [
+            [vModelText, fieldValue.value]
+          ])
+        ]),
+        _: 1
+      }, 8, ["descriptor"]);
+    };
+  }
+});
+const _hoisted_1$8 = /* @__PURE__ */ createElementVNode("option", null, null, -1);
+const _hoisted_2$3 = /* @__PURE__ */ createElementVNode("option", { value: true }, " Present ", -1);
+const _hoisted_3$2 = /* @__PURE__ */ createElementVNode("option", { value: false }, " Absent ", -1);
+const _hoisted_4$2 = [
+  _hoisted_1$8,
+  _hoisted_2$3,
+  _hoisted_3$2
+];
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorPresenceAbsence",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    const props = __props;
+    const useStore = useFilterStore();
+    const descriptorValue = computed({
+      get: () => {
+        return useStore.getDescriptorValueById(props.descriptor.descriptorId);
+      },
+      set: (value) => {
+        const { descriptorId } = props.descriptor;
+        if (typeof value === "boolean") {
+          useStore.setDescriptor({
+            descriptorId,
+            value: Boolean(value)
+          });
+        } else {
+          useStore.removeDescriptor(descriptorId);
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$b, { descriptor: __props.descriptor }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("select", {
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(descriptorValue) ? descriptorValue.value = $event : null)
+          }, _hoisted_4$2, 512), [
+            [vModelSelect, unref(descriptorValue)]
+          ])
+        ]),
+        _: 1
+      }, 8, ["descriptor"]);
+    };
+  }
+});
+const _hoisted_1$7 = /* @__PURE__ */ createElementVNode("option", { value: "" }, null, -1);
+const _hoisted_2$2 = ["value", "selected"];
+const _hoisted_3$1 = { key: 0 };
+const _hoisted_4$1 = { key: 1 };
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorQualitative",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    const props = __props;
+    const useStore = useFilterStore();
+    const setDescriptorValue = (e) => {
+      const target = e.target;
+      const { descriptorId } = props.descriptor;
+      if (target.value) {
+        useStore.setDescriptor({
+          descriptorId,
+          value: [Number(target.value)]
+        });
+      } else {
+        useStore.removeDescriptor(descriptorId);
+      }
+    };
+    const selectedOption = (characterState) => {
+      const storedValue = useStore.getDescriptorValueById(props.descriptor.descriptorId);
+      return storedValue.includes(characterState.characterStateId);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$b, { descriptor: __props.descriptor }, {
+        default: withCtx(() => [
+          createElementVNode("select", {
+            name: "listbox",
+            onChange: setDescriptorValue
+          }, [
+            _hoisted_1$7,
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.descriptor.characterStates, (characterState) => {
+              return openBlock(), createElementBlock("option", {
+                key: characterState.characterStateId,
+                value: characterState.characterStateId,
+                selected: selectedOption(characterState)
+              }, [
+                selectedOption(characterState) ? (openBlock(), createElementBlock("span", _hoisted_3$1, ">")) : createCommentVNode("", true),
+                characterState.status === "useless" ? (openBlock(), createElementBlock("span", _hoisted_4$1, "-")) : createCommentVNode("", true),
+                createTextVNode(" " + toDisplayString(characterState.name) + " (" + toDisplayString(characterState.numberOfObjects) + ") ", 1)
+              ], 8, _hoisted_2$2);
+            }), 128))
+          ], 32)
+        ]),
+        _: 1
+      }, 8, ["descriptor"]);
+    };
+  }
+});
+const _hoisted_1$6 = ["onKeyup"];
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorSample",
+  props: {
+    descriptor: null
+  },
+  setup(__props) {
+    const props = __props;
+    const useStore = useFilterStore();
+    const fieldValue = ref(String(useStore.getDescriptorValueById(props.descriptor.descriptorId)));
+    const setDescriptorValue = () => {
+      useStore.setDescriptor({
+        descriptorId: props.descriptor.descriptorId,
+        value: fieldValue.value
+      });
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$b, { descriptor: __props.descriptor }, {
+        title: withCtx(() => [
+          createTextVNode(toDisplayString(__props.descriptor.name) + " (" + toDisplayString(__props.descriptor.min) + "-" + toDisplayString(__props.descriptor.max) + " " + toDisplayString(__props.descriptor.defaultUnit) + ") ", 1)
+        ]),
+        default: withCtx(() => [
+          withDirectives(createElementVNode("input", {
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => fieldValue.value = $event),
+            type: "text",
+            onBlur: setDescriptorValue,
+            onKeyup: withKeys(setDescriptorValue, ["enter"])
+          }, null, 40, _hoisted_1$6), [
+            [vModelText, fieldValue.value]
+          ])
+        ]),
+        _: 1
+      }, 8, ["descriptor"]);
+    };
+  }
+});
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "DescriptorsList",
+  props: {
+    title: null,
+    descriptors: null
+  },
+  setup(__props) {
+    const components = {
+      DescriptorContinuous: _sfc_main$a,
+      DescriptorPresenceAbsence: _sfc_main$9,
+      DescriptorQualitative: _sfc_main$8,
+      DescriptorSample: _sfc_main$7
+    };
+    const componentFor = (descriptorType) => {
+      const componentName = descriptorType.replace("::", "");
+      return components[componentName];
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("h2", null, toDisplayString(__props.title), 1),
+        createElementVNode("ol", null, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.descriptors, (descriptor) => {
+            return openBlock(), createElementBlock("li", {
+              key: descriptor.descriptorId
+            }, [
+              (openBlock(), createBlock(resolveDynamicComponent(componentFor(descriptor.type)), { descriptor }, null, 8, ["descriptor"]))
+            ]);
+          }), 128))
+        ])
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$5 = { class: "descriptors-view" };
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "PanelDescriptors",
+  setup(__props) {
+    const useStore = useObservationMatrixStore();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$5, [
+        unref(useStore).getDescriptorsUsed.length ? (openBlock(), createBlock(_sfc_main$6, {
+          key: 0,
+          descriptors: unref(useStore).getDescriptorsUsed,
+          title: "Used Descriptors"
+        }, null, 8, ["descriptors"])) : createCommentVNode("", true),
+        unref(useStore).getDescriptorsUseful.length ? (openBlock(), createBlock(_sfc_main$6, {
+          key: 1,
+          descriptors: unref(useStore).getDescriptorsUseful,
+          title: "Descriptors Useful for Identification"
+        }, null, 8, ["descriptors"])) : createCommentVNode("", true),
+        unref(useStore).getDescriptorsUseless.length ? (openBlock(), createBlock(_sfc_main$6, {
+          key: 2,
+          descriptors: unref(useStore).getDescriptorsUseless,
+          title: "Descriptors no longer relevant for identification"
+        }, null, 8, ["descriptors"])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+var VSpinner_vue_vue_type_style_index_0_scoped_true_lang = /* @__PURE__ */ (() => ".tw-spinner[data-v-3541fc5b]{display:flex;margin:0 auto;height:auto;width:auto;align-items:center;justify-content:center}.fade-enter-active[data-v-3541fc5b],.fade-leave-active[data-v-3541fc5b]{transition:opacity .5s}.fade-enter[data-v-3541fc5b],.fade-leave-to[data-v-3541fc5b]{opacity:0}.tw-spinner-left[data-v-3541fc5b]{flex-direction:row}.tw-spinner-right[data-v-3541fc5b]{flex-direction:row-reverse}.tw-spinner-top[data-v-3541fc5b]{flex-direction:column}.tw-spinner-bottom[data-v-3541fc5b]{flex-direction:column-reverse}.box-spinner[data-v-3541fc5b]{display:flex;position:absolute;box-shadow:0 1px 1px #0003;background-image:none!important;background-color:#fff;align-items:center;z-index:9999;height:100%;opacity:.9}.tw-spinner[data-v-3541fc5b]{font-size:20px;overflow:hidden;width:100%;position:relative}.tw-spinner svg[data-v-3541fc5b]{display:block;position:relative;width:30px;height:30px;margin:0 auto}.tw-spinner #Tail[data-v-3541fc5b]{opacity:0;animation:tail-3541fc5b 2s ease infinite;fill:#41ba8d}.tw-spinner #LeftBottom[data-v-3541fc5b]{fill:#00845d;opacity:0;animation:spinner-3541fc5b 1s ease alternate infinite;animation-delay:0s}.tw-spinner #LeftMid[data-v-3541fc5b]{fill:#28221b;opacity:0;animation:spinner-3541fc5b 1s ease alternate infinite;animation-delay:.2s}.tw-spinner #LeftTop[data-v-3541fc5b]{fill:#342d25;opacity:0;animation:spinner-3541fc5b 1s ease alternate infinite;animation-delay:.4s}.tw-spinner #Head[data-v-3541fc5b]{fill:#342d25;opacity:0;animation:spinner-3541fc5b 1s ease alternate infinite;animation-delay:.6s}@keyframes spinner-3541fc5b{0%{opacity:0}30%{opacity:0}90%{opacity:1}to{opacity:1}}@keyframes tail-3541fc5b{0%{opacity:0}30%{opacity:1}50%{opacity:1}90%{opacity:0}to{opacity:0}}\n")();
+const _withScopeId = (n) => (pushScopeId("data-v-3541fc5b"), n = n(), popScopeId(), n);
+const _hoisted_1$4 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("path", {
+  id: "LeftTop",
+  d: "M14.2,63.1C24.3,63.1,28,76.3,28,76.3s5,15.5,15.3,15.5c7.7,0,9.4-6.3,9.8-9.1c0-0.1,0-0.2,0-0.4s0-0.5,0.1-0.8\n              c0-0.1,0-0.1,0-0.2c0.3-2-0.8-4-2.7-4.8l0,0c-3.1-1.1-5.9-3-8-5.6c-6.4-7.4-3-17,4.5-23.6c-3.5-4-8-8.7-12-10.8\n              c-8.7-4.6-15.7,2.6-16.2,3.2L18.7,40c-0.6,0.8-1.2,1.6-1.8,2.5l-0.1,0.1c-0.6,0.9-1.2,1.8-1.8,2.7L15,45.4c-0.5,0.8-1,1.6-1.5,2.4\n              l-0.3,0.5c-1,1.8-2,3.6-3,5.5L10,54.3c-0.4,0.9-0.9,1.8-1.3,2.7l-0.1,0.1C8.2,58,7.8,59,7.4,59.9l-0.2,0.5c-0.3,0.8-0.6,1.5-0.9,2.3\n              l-0.2,0.6c-0.4,1-0.7,1.9-1,2.9L5,66.7c-0.1,0.3-0.2,0.5-0.2,0.8C7.1,64.7,10.5,63.1,14.2,63.1z"
+}, null, -1));
+const _hoisted_2$1 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("path", {
+  id: "Head",
+  d: "M36.2,33c5.3,1.8,11.4,6.8,15.7,11c0.5-0.3,1.1-0.6,1.6-0.9c2.3-1.2,4.7-2.1,7.2-2.7\n              c-2.4-4.9-5.6-12.8-4.9-18.3c1.4-11.2,13.6-12,13.6-12S58.3,12.5,59,22.9c0.3,5,4.7,12.5,7.5,16.8c7-0.1,13,2.7,15.8,8\n              c0.3,0.5,0.5,1.1,0.7,1.6l0,0c0.5,1,1.3,1.9,2.3,2.4c3.6,1.2,7.6,2.5,11.7,4.2c5.8,2.3,11.5,5,17,8.1c0.5,0.2,1,0,1.2-0.5\n              c0.1-0.3,0.1-0.7-0.2-0.9c-27.2-26.1-8-36.3-8-36.3c-9.8,14.2,6.6,24.5,25.5,35.1c16.6,9.3,28.4,19.5,41.3,12.7\n              c6.4-3.4,1.9-11-1-15.2c-2.2-2.9-4-6-5.6-9.2c-1-2.1-1.3-4.4-0.8-6.6c0.7-3.1-0.4-6.8-2.8-10.5c-1.8-2.8-5.1-5.7-7.6-7.6\n              c-1.6-1.3-3.1-2.7-4.3-4.4c-9-12.6-32.2-17.9-32.2-17.9l0,0C97.5-2.6,74.3,0.1,54,10.2l0,0c-6.9,3.5-13.5,7.7-19.4,12.7l-0.8,0.6\n              c-1.4,1.2-2.8,2.5-4.2,3.8l0,0c-0.8,0.8-1.6,1.5-2.3,2.3l0,0c-1.5,1.6-3,3.2-4.4,4.9l-0.2,0.2l-0.4,0.5C25.2,32.8,29.6,30.9,36.2,33\n              z M145.8,33.9c3.9-1.7,8.5,0.1,10.2,4c0.6,1.3,0.8,2.7,0.6,4c-2.5,1.2-5.5,0.9-7.7-0.9C146.5,39.5,145.3,36.7,145.8,33.9L145.8,33.9\n              z"
+}, null, -1));
+const _hoisted_3 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("path", {
+  id: "LeftMid",
+  d: "M53.2,106.9c-0.2-2-0.4-4-0.4-6.3c-2.3,1-4.7,1.5-7.2,1.5c-19,0-19.5-18.8-26.2-29.2\n              c-7-10.8-16.8,0.9-17.8,7.2c0,0.3-0.1,0.5-0.1,0.7c-0.1,0.6-0.2,1.3-0.3,1.9C1,83.1,1,83.4,1,83.6c-0.1,0.8-0.2,1.6-0.3,2.3\n              c0,0.3-0.1,0.5-0.1,0.8c-0.1,1-0.2,2.1-0.3,3.1c0,0.1,0,0.2,0,0.3c-0.1,0.9-0.2,1.9-0.2,2.8c0,0.3,0,0.6,0,0.9C0,94.9,0,95.8,0,96.7\n              c0,0.1,0,0.2,0,0.3s0,0.1,0,0.1s0,0.1,0,0.1c0,0.4,0,0.8,0,1.2s0,0.8,0,1.2c0,0.6,0,1.2,0.1,1.7c0,0.2,0,0.5,0,0.7\n              c1.5,30.7,17.5,58.9,43,76c-8-7.8-12.7-17.8-12.7-28.6c0-13.4,7.3-26,19.1-34.4C52,113.2,53.5,110.1,53.2,106.9z"
+}, null, -1));
+const _hoisted_4 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("path", {
+  id: "LeftBottom",
+  d: "M128.3,170c-5.8,2.4-12,3.9-18.3,4.4c-1.1,0.1-2.2,0.1-3.3,0.1c-12.3,0-28.4-4.8-40.7-25.3\n              l-1.6-2.7c-1.9,2.7-2.9,6-2.9,9.3c0,13.9,16.6,26.5,36.7,26.5c5.4,0.1,10.7-0.6,15.9-2c-4.6,2.9-13.8,5.6-21.9,5.6\n              C69.2,186,50,170.8,50,152.7c0.1-6.3,2.1-12.5,5.8-17.6c1.5-2.1,1.9-4.8,1.1-7.2l0,0c-10.5,6.1-17,15.4-17,26.6\n              c0,17.2,15.3,31.9,37,37.9c1.2,0.3,2.5,0.5,3.7,0.7c15.6,2.6,29.5-0.1,38.9-9.1C123.5,180.1,126.5,175.3,128.3,170z"
+}, null, -1));
+const _hoisted_5 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("path", {
+  id: "Tail",
+  class: "st0",
+  d: "M171,33.8c28,39.3,18.8,93.8-20.5,121.8c-2.4,1.7-4.9,3.3-7.5,4.8l-0.2,0.2c0-0.4,0-0.9,0.1-1.3\n              c0.6-3.9,2.1-7.6,4.4-10.8c7.5-10.7,12.4-27-0.3-48.1c-7-11.6-21.7-28-51.7-40.1c-4.1-1.7-8.1-3.1-11.8-4.2L82,55.6l-0.2-0.1\n              c-1.1-0.3-2.1-0.6-3.1-0.9h-0.2l-2.9-0.8h-0.1l-1.3-0.3h-0.1l-2.6-0.6h-0.1l-2.3-0.5h-0.2l-1-0.2l0,0L67,51.7h-0.2l-0.7-0.2h-0.2\n              l-0.8-0.2H65l-0.6-0.1h-0.2L63.7,51l-0.1,0.4v0.1l-0.1,0.3l0,0.2l-0.1,0.3l-0.1,0.2l-0.1,0.3l-0.1,0.2L63,53.5L63,53.7l-0.1,0.4\n              l-0.1,0.2l-0.1,0.5l-0.1,0.3l-0.1,0.6L62.3,56l-0.1,0.5l-0.1,0.3L62,57.2l-0.1,0.4L61.8,58l-0.1,0.4l-0.1,0.5l-0.1,0.4l-0.1,0.5\n              l-0.1,0.4l-0.1,0.6l-0.1,0.5L61,61.9l-0.1,0.4l-0.1,0.5l-0.1,0.5l-0.1,0.5l-0.1,0.5l-0.1,0.5l-0.1,0.5l-0.1,0.5l-0.1,0.5L60,66.9\n              l-0.1,0.5l-0.1,0.7l-0.1,0.5l-0.2,1l-0.1,0.5l-0.1,0.6l-0.1,0.5l-0.1,0.6l-0.1,0.6L59,73.1l-0.1,0.6l-0.1,0.6l-0.1,0.6l-0.1,0.7\n              l-0.1,0.6l-0.1,0.8l-0.1,0.5c-0.2,1.8-0.4,3.6-0.6,5.5V83c0,0.6-0.1,1.1-0.1,1.7l0,0c0,0.6-0.1,1.1-0.1,1.7v0.1\n              c0,0.6-0.1,1.1-0.1,1.7l0,0c-0.2,3-0.2,6.2-0.2,9.5c0.1,4.3,0.4,8.5,0.8,12.7c0,0.3,0.1,0.7,0.1,1.1c0.7,5.8,1.9,11.4,3.6,17\n              c1.5,4.5,3.2,8.9,5.2,13.2c0.9,1.7,1.8,3.4,2.8,5.1c9.2,15.3,21.5,23,36.6,23c1,0,2.1,0,3.2-0.1c7-0.6,13.9-2.5,20.2-5.6\n              c4.9-24.5-8.4-59.3-36.1-88.3C90,71.8,86,68,81.7,64.4c9.2,6.9,13.9,10.7,19.2,16.3c37.8,39.6,49.7,89.7,26.5,111.9\n              c-3.4,3.3-7.5,5.8-11.9,7.5c5.8-1.6,11.1-4.5,15.4-8.6c1.4-1.3,2.6-2.7,3.8-4.2c49.6-20.7,73-77.7,52.4-127.3\n              C183.1,50.4,177.7,41.6,171,33.8z"
+}, null, -1));
+const _hoisted_6 = [
+  _hoisted_1$4,
+  _hoisted_2$1,
+  _hoisted_3,
+  _hoisted_4,
+  _hoisted_5
+];
+const _hoisted_7 = ["innerHTML"];
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "VSpinner",
+  props: {
+    fullScreen: {
+      type: Boolean,
+      default: false
+    },
+    legend: {
+      type: String,
+      default: "Loading, please wait."
+    },
+    resize: {
+      type: Boolean,
+      default: true
+    },
+    legendStyle: {
+      type: Object,
+      default: () => ({
+        color: "#444",
+        marginTop: "30px",
+        textAlign: "center"
+      })
+    },
+    showLegend: {
+      type: Boolean,
+      default: true
+    },
+    showSpinner: {
+      type: Boolean,
+      default: true
+    },
+    spinnerPosition: {
+      type: String,
+      default: "top"
+    },
+    logoSize: {
+      type: Object,
+      default: () => ({
+        width: "50px",
+        height: "50px"
+      })
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const FULL_SCREEN_STYLE = {
+      position: "fixed",
+      width: "100vw",
+      height: "100vh",
+      top: "0px",
+      left: "0px"
+    };
+    const spinnerElement = ref();
+    const cssProperties = ref({});
+    const resizeInterval = ref();
+    onMounted(() => {
+      init();
+      if (props.resize && !props.fullScreen) {
+        checkResize();
+      }
+    });
+    onUnmounted(() => clearInterval(resizeInterval.value));
+    const init = () => {
+      var _a;
+      const domElement = (_a = spinnerElement.value) == null ? void 0 : _a.parentNode;
+      if (!domElement)
+        return;
+      Object.assign(cssProperties.value, props.fullScreen ? FULL_SCREEN_STYLE : calculateSpinnerStyle(domElement));
+    };
+    const calculateSpinnerStyle = (element) => {
+      const size = element.getBoundingClientRect();
+      const computedStyle = window.getComputedStyle(element, null);
+      const paddingLeft = parseInt(computedStyle.getPropertyValue("padding-left"), 10);
+      const paddingRight = parseInt(computedStyle.getPropertyValue("padding-right"), 10);
+      const paddingTop = parseInt(computedStyle.getPropertyValue("padding-top"), 10);
+      const paddingBottom = parseInt(computedStyle.getPropertyValue("padding-bottom"), 10);
+      return {
+        position: "absolute",
+        width: size.width - paddingLeft - paddingRight + "px",
+        height: size.height - paddingTop - paddingBottom + "px"
+      };
+    };
+    const checkResize = () => {
+      resizeInterval.value = setInterval(init, 500);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: "fade" }, {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            ref_key: "spinnerElement",
+            ref: spinnerElement,
+            class: "box-spinner mx-spinner absolute bg-white opacity-90",
+            style: normalizeStyle(cssProperties.value)
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(["tw-spinner", [`tw-spinner-${__props.spinnerPosition}`]])
+            }, [
+              __props.showSpinner ? (openBlock(), createElementBlock("svg", {
+                key: 0,
+                style: normalizeStyle([__props.logoSize, { "enable-background": "new 0 0 194.6 200" }]),
+                version: "1.1",
+                xmlns: "http://www.w3.org/2000/svg",
+                "xmlns:xlink": "http://www.w3.org/1999/xlink",
+                x: "0px",
+                y: "0px",
+                viewBox: "0 0 194.6 200",
+                "xml:space": "preserve"
+              }, _hoisted_6, 4)) : createCommentVNode("", true),
+              createElementVNode("div", {
+                style: normalizeStyle(__props.legendStyle)
+              }, [
+                __props.showLegend ? (openBlock(), createElementBlock("span", {
+                  key: 0,
+                  innerHTML: __props.legend
+                }, null, 8, _hoisted_7)) : createCommentVNode("", true),
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ], 4)
+            ], 2)
+          ], 4)
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+var VSpinner = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-3541fc5b"]]);
+const _hoisted_1$3 = /* @__PURE__ */ createTextVNode(" Interactive key ");
+const _hoisted_2 = { key: 0 };
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "TitleMatrix",
+  setup(__props) {
+    const store = useObservationMatrixStore();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("h1", null, [
+        _hoisted_1$3,
+        unref(store).getObservationMatrix ? (openBlock(), createElementBlock("span", _hoisted_2, "| " + toDisplayString(unref(store).getObservationMatrix.name), 1)) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const _hoisted_1$2 = ["title"];
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "TitleMatrixCitation",
+  setup(__props) {
+    const store = useObservationMatrixStore();
+    const citationLabel = computed(() => {
+      const citation = store.getCitation;
+      return Object.values(citation || {}).filter(Boolean).join(", ");
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", { title: unref(citationLabel) }, toDisplayString(unref(citationLabel)), 9, _hoisted_1$2);
+    };
+  }
+});
+const _hoisted_1$1 = { class: "d-flex justify-between" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "TitleKey",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        createVNode(_sfc_main$3),
+        createVNode(_sfc_main$2)
+      ]);
+    };
+  }
+});
+const _hoisted_1 = { class: "vue-interactive-keys" };
+const __default__ = {
+  name: "InteractiveKey"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__), {
+  props: {
+    observationMatrixId: { default: 1 },
+    apiConfig: null
+  },
+  setup(__props) {
+    const props = __props;
+    const settingStore = useSettingsStore();
+    const filterStore = useFilterStore();
+    useObservationMatrixStore();
+    const isLoading = computed(() => settingStore.getIsLoading);
+    const gridLayout = computed(() => settingStore.getLayout);
+    const initialize = () => {
+      const api = useAPIConfig();
+      api.updatePreferences(props.apiConfig);
+      settingStore.setObservationMatrixId(props.observationMatrixId);
+      settingStore.checkUpdate();
+    };
+    initialize();
+    filterStore.$subscribe((_) => {
+      if (settingStore.shouldUpdate) {
+        settingStore.checkUpdate();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_sfc_main$1),
+        createVNode(HeaderBar, { class: "margin-medium-bottom" }),
+        createVNode(VGrid, {
+          class: normalizeClass(["w-100", unref(gridLayout)])
+        }, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$5, { class: "panel-descriptors grid-panel" }),
+            createVNode(_sfc_main$g, { class: "panel-remaining grid-panel" }),
+            createVNode(_sfc_main$i, { class: "panel-eliminated grid-panel" })
+          ]),
+          _: 1
+        }, 8, ["class"]),
+        unref(isLoading) ? (openBlock(), createBlock(VSpinner, {
+          key: 0,
+          "full-screen": "",
+          legend: "Loading interactive key..."
+        })) : createCommentVNode("", true)
+      ]);
+    };
+  }
+}));
+var main = /* @__PURE__ */ (() => ":root{--bg-color: #f7f8fc;--bg-panel-color: #FFFFFF;--primary-color: #5D9ECE;--border-color: #CCCCCC;--link-color: #5D9ECE;--btn-medium-size: 28px}.d-block{display:block}.d-flex{display:flex}.justify-between{justify-content:space-between}.align-center{align-items:center}.w-100{height:100%}.margin-medium-bottom{margin-bottom:1em}.margin-small-right{margin-right:.5em}.p-0{padding:0}.link{color:var(--link-color);cursor:pointer}.list-none{list-style:none}body{background-color:var(--bg-color)}.vue-interactive-keys{height:calc(100vh - 160px);max-height:calc(100vh - 160px);font-family:Arial,Helvetica,sans-serif;font-size:13px}.vue-interactive-keys .grid-panel{background-color:#fff;padding:1rem;overflow-y:scroll}.vue-interactive-keys .layout-mode-1 .panel-descriptors{grid-area:1/1/2/3}.vue-interactive-keys .layout-mode-1 .panel-remaining{grid-area:2/1/3/2}.vue-interactive-keys .layout-mode-1 .panel-eliminated{grid-area:2/2/3/3}.vue-interactive-keys .layout-mode-2 .panel-descriptors{grid-area:1/1/3/2}.vue-interactive-keys .layout-mode-2 .panel-remaining{grid-area:1/2/2/3}.vue-interactive-keys .layout-mode-2 .panel-eliminated{grid-area:2/2/3/3}.vue-interactive-keys input,.vue-interactive-keys select{padding:.5em 1em;border:1px solid;border-radius:2px;border-color:var(--border-color);background-color:#fff}\n")();
+function discoverInteractiveKey(selector) {
+  const tag = selector || '[data-interactive-key="true"]';
+  const elements = document.querySelectorAll(tag);
+  const elementsList = [...elements];
+  return elementsList.map((element) => createInteractiveKey(element, parseElementOptions(element)));
+}
+function autoDiscover() {
+  discoverInteractiveKey();
+}
+function parseElementOptions(element) {
+  return {
+    observationMatrixId: Number(element.getAttribute("data-observation-matrix-id")),
+    apiConfig: {
+      baseURL: element.getAttribute("data-base-url") || "",
+      projectToken: element.getAttribute("data-project-token") || void 0,
+      projectId: Number(element.getAttribute("data-project-id")) || void 0,
+      userToken: element.getAttribute("data-user-token") || void 0,
+      csrfToken: element.getAttribute("data-csrf-token") || void 0
+    }
+  };
+}
+function createInteractiveKey(element, opt) {
+  const {
+    apiConfig,
+    observationMatrixId
+  } = opt;
+  if (!observationMatrixId) {
+    throw "Missing observation matrix ID";
+  }
+  if (!apiConfig || !apiConfig.projectToken && !apiConfig.csrfToken && !(apiConfig.projectId && apiConfig.userToken)) {
+    throw "Missing API configuration";
+  }
+  const app = createApp(_sfc_main, {
+    observationMatrixId,
+    apiConfig
+  });
+  app.use(createPinia());
+  app.mount(element);
+  return app;
+}
+window.addEventListener("DOMContentLoaded", autoDiscover);
+export { _sfc_main as VueInteractiveKey, createInteractiveKey, discoverInteractiveKey };