geonetwork-ui 2.1.0-initial

package/esm2022/libs/api/metadata-converter/src/lib/xml-utils.mjs

@@ -0,0 +1,300 @@
+import { parseXml, XmlDocument, XmlElement, XmlText, } from '@rgrove/parse-xml';
+import { fallback } from './function-utils';
+export { XmlDocument, XmlElement } from '@rgrove/parse-xml';
+export class XmlParseError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+/**
+ * Parses a XML document as string, return a document object
+ */
+export function parseXmlString(xmlString) {
+    let doc = null;
+    try {
+        doc = parseXml(xmlString);
+    }
+    catch (e) {
+        throw new XmlParseError(e instanceof Error ? e.message : e);
+    }
+    return doc;
+}
+export function createDocument(rootEl) {
+    rootEl.attributes = rootEl.attributes || {};
+    function collectNamespaceFromName(name) {
+        const namespace = extractNamespace(name);
+        if (namespace === 'xmlns' || namespace === null)
+            return;
+        if (!NAMESPACES[namespace]) {
+            throw new Error(`No known URI for namespace ${namespace}`);
+        }
+        rootEl.attributes[`xmlns:${namespace}`] = NAMESPACES[namespace];
+    }
+    function collectNamespaces(el) {
+        collectNamespaceFromName(el.name);
+        for (const attr in el.attributes) {
+            collectNamespaceFromName(attr);
+        }
+        const children = allChildrenElement(el);
+        children.forEach(collectNamespaces);
+    }
+    collectNamespaces(rootEl);
+    return new XmlDocument([rootEl]);
+}
+/**
+ * Will do nothing if no namespace present
+ */
+function stripNamespace(name) {
+    const colon = name.indexOf(':');
+    return colon > -1 ? name.substring(colon + 1) : name;
+}
+function getElementName(element) {
+    return element.name || '';
+}
+export function getRootElement(xmlDoc) {
+    return xmlDoc.children.find((el) => el instanceof XmlElement);
+}
+/**
+ * Will return all matching elements (namespace will be ignored)
+ */
+export function findChildrenElement(name, nested = true) {
+    return (el) => {
+        const strippedName = stripNamespace(name);
+        function reducer(prev, curr) {
+            if (stripNamespace(getElementName(curr)) === strippedName) {
+                prev.push(curr);
+            }
+            if (nested && Array.isArray(curr.children)) {
+                return [...prev, ...curr.children.reduce(reducer, [])];
+            }
+            else {
+                return prev;
+            }
+        }
+        return el && Array.isArray(el.children)
+            ? el.children.reduce(reducer, [])
+            : [];
+    };
+}
+export function findChildElement(name, nested = true) {
+    return (el) => findChildrenElement(name, nested)(el)[0] || null;
+}
+export function allChildrenElement(element) {
+    if (!element || !Array.isArray(element.children))
+        return [];
+    return [
+        ...element.children.filter((el) => el instanceof XmlElement),
+    ];
+}
+/**
+ * Will return all matching elements nested according to the given
+ * names (similar to a path), starting form the input element;
+ * returns an empty array if no matching element
+ */
+export function findNestedElements(...elementNames) {
+    return (el) => {
+        function lookFor(elNameIndex) {
+            const strippedName = stripNamespace(elementNames[elNameIndex]);
+            return (prev, curr) => {
+                if (stripNamespace(getElementName(curr)) !== strippedName) {
+                    return prev;
+                }
+                if (elNameIndex === elementNames.length - 1) {
+                    return [...prev, curr];
+                }
+                if (Array.isArray(curr.children)) {
+                    return [
+                        ...prev,
+                        ...curr.children.reduce(lookFor(elNameIndex + 1), []),
+                    ];
+                }
+                return prev;
+            };
+        }
+        return el && Array.isArray(el.children)
+            ? el.children.reduce(lookFor(0), [])
+            : [];
+    };
+}
+export function findNestedElement(...elementNames) {
+    return (el) => {
+        const found = findNestedElements(...elementNames)(el);
+        return found.length ? found[0] : null;
+    };
+}
+// Will look through all the parents; returns null if no matching parent found.
+export function findParent(parentName) {
+    return (el) => {
+        let parent = el.parent;
+        while (parent && parent instanceof XmlElement) {
+            if (stripNamespace(getElementName(parent)) === stripNamespace(parentName))
+                return parent;
+            parent = parent.parent;
+        }
+        return null;
+    };
+}
+export function readText() {
+    return (el) => {
+        const textNode = el && Array.isArray(el.children)
+            ? el.children.find((node) => node.type === 'text')
+            : null;
+        return textNode ? textNode.text : null;
+    };
+}
+export function readAttribute(attrName) {
+    return (el) => (el && el.attributes[attrName]) || null;
+}
+export function xmlToString(el, indentationLevel = 0) {
+    if (el instanceof XmlDocument)
+        return `<?xml version="1.0" encoding="UTF-8"?>${xmlToString(el.children[0])}`;
+    if (el instanceof XmlText) {
+        const text = el.text;
+        const isEmpty = !text || text.replace(/^\s+|\s+$/g, '') === '';
+        if (isEmpty)
+            return '';
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+    }
+    if (!(el instanceof XmlElement))
+        return `<!-- unknown -->`;
+    const padding = '    '.repeat(indentationLevel);
+    const children = Array.isArray(el.children)
+        ? el.children
+            .map((el) => xmlToString(el, indentationLevel + 1))
+            .filter((el) => el !== '')
+            .map((elString, index, array) => index < array.length - 1 ? elString.replace(/\n\s*$/g, '') : elString)
+            .join('')
+        : '';
+    const attrs = Object.keys(el.attributes).reduce((prev, curr) => prev + ` ${curr}="${el.attributes[curr]}"`, '');
+    const parentPadding = '    '.repeat(Math.max(0, indentationLevel - 1));
+    if (children === '') {
+        return `
+${padding}<${el.name}${attrs}/>
+${parentPadding}`;
+    }
+    return `
+${padding}<${el.name}${attrs}>${children}</${el.name}>
+${parentPadding}`;
+}
+/**
+ * @param name
+ * @returns namespace, null if none found
+ */
+function extractNamespace(name) {
+    const colon = name.indexOf(':');
+    return colon > -1 ? name.substring(0, colon) : null;
+}
+const NAMESPACES = {
+    gmd: 'http://www.isotc211.org/2005/gmd',
+    gco: 'http://www.isotc211.org/2005/gco',
+    gfc: 'http://www.isotc211.org/2005/gfc',
+    gml: 'http://www.opengis.net/gml/3.2',
+    xsi: 'http://www.w3.org/2001/XMLSchema-instance',
+    srv: 'http://www.isotc211.org/2005/srv',
+    gmx: 'http://www.isotc211.org/2005/gmx',
+    gts: 'http://www.isotc211.org/2005/gts',
+    gsr: 'http://www.isotc211.org/2005/gsr',
+    gmi: 'http://www.isotc211.org/2005/gmi',
+    xlink: 'http://www.w3.org/1999/xlink',
+};
+/**
+ * @param name Full name with namespace, e.g.: gmd:MD_Metadata
+ */
+export function createElement(name) {
+    return () => new XmlElement(name, {}, []);
+}
+export function addAttribute(name, value) {
+    return (element) => {
+        element.attributes[name] = value;
+        return element;
+    };
+}
+// stays on the parent element
+// if the given elements are part of a subtree, will add the root of subtree
+export function appendChildren(...childrenFns) {
+    return (element) => {
+        if (!element)
+            return null;
+        element.children.push(...childrenFns
+            .map((fn) => fn())
+            .map((el) => {
+            let root = el;
+            while (root.parent instanceof XmlElement) {
+                root = root.parent;
+            }
+            return root;
+        }));
+        element.children.forEach((el) => (el.parent = element));
+        return element;
+    };
+}
+// switches to the child element
+export function createChild(childName) {
+    return (element) => {
+        if (!element)
+            return null;
+        const child = createElement(childName)();
+        element.children.push(child);
+        child.parent = element;
+        return child;
+    };
+}
+export function findChildOrCreate(name) {
+    return fallback(findChildElement(name, false), createChild(name));
+}
+export function findNestedChildOrCreate(...elementNames) {
+    return (element) => {
+        let current = element;
+        for (const name of elementNames) {
+            current = findChildOrCreate(name)(current);
+        }
+        return current;
+    };
+}
+export function setTextContent(text) {
+    return (element) => {
+        if (!element)
+            return null;
+        const textEl = element.children.find((el) => el instanceof XmlText);
+        if (!textEl) {
+            element.children.push(new XmlText(text));
+        }
+        else {
+            textEl.text = text;
+        }
+        return element;
+    };
+}
+export function removeAllChildren() {
+    return (element) => {
+        if (!element)
+            return null;
+        element.children.forEach((el) => (el.parent = null));
+        element.children = [];
+        return element;
+    };
+}
+export function removeChildrenByName(name) {
+    return (element) => {
+        if (!element)
+            return null;
+        const strippedName = stripNamespace(name);
+        const removed = element.children.filter((child) => child instanceof XmlElement &&
+            stripNamespace(getElementName(child)) === strippedName);
+        removed.forEach((el) => (el.parent = null));
+        element.children = element.children.filter((child) => removed.indexOf(child) === -1);
+        return element;
+    };
+}
+export function removeChildren(childrenFn) {
+    return (element) => {
+        const children = childrenFn(element);
+        children.forEach((child) => (child.parent = null));
+        element.children = element.children.filter((child) => child instanceof XmlElement && children.indexOf(child) === -1);
+        return element;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xml-utils.js","sourceRoot":"","sources":["../../../../../../../libs/api/metadata-converter/src/lib/xml-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  parseXml,\n  XmlComment,\n  XmlDocument,\n  XmlElement,\n  XmlText,\n} from '@rgrove/parse-xml'\nimport { ChainableFunction, fallback } from './function-utils'\nexport { XmlDocument, XmlElement } from '@rgrove/parse-xml'\n\nexport class XmlParseError extends Error {\n  constructor(message) {\n    super(message)\n  }\n}\n\n/**\n * Parses a XML document as string, return a document object\n */\nexport function parseXmlString(xmlString: string): XmlDocument {\n  let doc = null\n  try {\n    doc = parseXml(xmlString)\n  } catch (e) {\n    throw new XmlParseError(e instanceof Error ? e.message : e)\n  }\n  return doc\n}\n\nexport function createDocument(rootEl: XmlElement): XmlDocument {\n  rootEl.attributes = rootEl.attributes || {}\n\n  function collectNamespaceFromName(name: string) {\n    const namespace = extractNamespace(name)\n    if (namespace === 'xmlns' || namespace === null) return\n    if (!NAMESPACES[namespace]) {\n      throw new Error(`No known URI for namespace ${namespace}`)\n    }\n    rootEl.attributes[`xmlns:${namespace}`] = NAMESPACES[namespace]\n  }\n\n  function collectNamespaces(el: XmlElement) {\n    collectNamespaceFromName(el.name)\n    for (const attr in el.attributes) {\n      collectNamespaceFromName(attr)\n    }\n    const children = allChildrenElement(el)\n    children.forEach(collectNamespaces)\n  }\n\n  collectNamespaces(rootEl)\n  return new XmlDocument([rootEl])\n}\n\n/**\n * Will do nothing if no namespace present\n */\nfunction stripNamespace(name: string): string {\n  const colon = name.indexOf(':')\n  return colon > -1 ? name.substring(colon + 1) : name\n}\n\nfunction getElementName(element: XmlElement): string {\n  return element.name || ''\n}\n\nexport function getRootElement(xmlDoc: XmlDocument): XmlElement {\n  return xmlDoc.children.find((el) => el instanceof XmlElement) as XmlElement\n}\n\n/**\n * Will return all matching elements (namespace will be ignored)\n */\nexport function findChildrenElement(\n  name: string,\n  nested = true\n): ChainableFunction<XmlElement, Array<XmlElement>> {\n  return (el) => {\n    const strippedName = stripNamespace(name)\n    function reducer(prev, curr) {\n      if (stripNamespace(getElementName(curr)) === strippedName) {\n        prev.push(curr)\n      }\n\n      if (nested && Array.isArray(curr.children)) {\n        return [...prev, ...curr.children.reduce(reducer, [])]\n      } else {\n        return prev\n      }\n    }\n\n    return el && Array.isArray(el.children)\n      ? el.children.reduce(reducer, [])\n      : []\n  }\n}\n\nexport function findChildElement(\n  name: string,\n  nested = true\n): ChainableFunction<XmlElement, XmlElement> {\n  return (el) => findChildrenElement(name, nested)(el)[0] || null\n}\n\nexport function allChildrenElement(element: XmlElement): Array<XmlElement> {\n  if (!element || !Array.isArray(element.children)) return []\n  return [\n    ...element.children.filter((el) => el instanceof XmlElement),\n  ] as Array<XmlElement>\n}\n\n/**\n * Will return all matching elements nested according to the given\n * names (similar to a path), starting form the input element;\n * returns an empty array if no matching element\n */\nexport function findNestedElements(\n  ...elementNames\n): ChainableFunction<XmlElement, Array<XmlElement>> {\n  return (el) => {\n    function lookFor(elNameIndex: number) {\n      const strippedName = stripNamespace(elementNames[elNameIndex])\n      return (prev, curr) => {\n        if (stripNamespace(getElementName(curr)) !== strippedName) {\n          return prev\n        }\n        if (elNameIndex === elementNames.length - 1) {\n          return [...prev, curr]\n        }\n        if (Array.isArray(curr.children)) {\n          return [\n            ...prev,\n            ...curr.children.reduce(lookFor(elNameIndex + 1), []),\n          ]\n        }\n        return prev\n      }\n    }\n\n    return el && Array.isArray(el.children)\n      ? el.children.reduce(lookFor(0), [])\n      : []\n  }\n}\n\nexport function findNestedElement(\n  ...elementNames: string[]\n): ChainableFunction<XmlElement, XmlElement> {\n  return (el) => {\n    const found = findNestedElements(...elementNames)(el)\n    return found.length ? found[0] : null\n  }\n}\n\n// Will look through all the parents; returns null if no matching parent found.\nexport function findParent(\n  parentName: string\n): ChainableFunction<XmlElement, XmlElement> {\n  return (el) => {\n    let parent: XmlElement | XmlDocument = el.parent as XmlElement\n    while (parent && parent instanceof XmlElement) {\n      if (stripNamespace(getElementName(parent)) === stripNamespace(parentName))\n        return parent\n      parent = parent.parent\n    }\n    return null\n  }\n}\n\nexport function readText(): ChainableFunction<XmlElement, string> {\n  return (el) => {\n    const textNode =\n      el && Array.isArray(el.children)\n        ? (el.children.find((node) => node.type === 'text') as XmlText)\n        : null\n    return textNode ? textNode.text : null\n  }\n}\n\nexport function readAttribute(\n  attrName: string\n): ChainableFunction<XmlElement, string> {\n  return (el) => (el && el.attributes[attrName]) || null\n}\n\nexport function xmlToString(\n  el: XmlElement | XmlText | XmlComment | XmlDocument,\n  indentationLevel = 0\n) {\n  if (el instanceof XmlDocument)\n    return `<?xml version=\"1.0\" encoding=\"UTF-8\"?>${xmlToString(\n      el.children[0]\n    )}`\n  if (el instanceof XmlText) {\n    const text = el.text\n    const isEmpty = !text || text.replace(/^\\s+|\\s+$/g, '') === ''\n    if (isEmpty) return ''\n    return text\n      .replace(/&/g, '&amp;')\n      .replace(/</g, '&lt;')\n      .replace(/>/g, '&gt;')\n  }\n  if (!(el instanceof XmlElement)) return `<!-- unknown -->`\n\n  const padding = '    '.repeat(indentationLevel)\n  const children = Array.isArray(el.children)\n    ? el.children\n        .map((el) => xmlToString(el, indentationLevel + 1))\n        .filter((el) => el !== '')\n        .map((elString, index, array) =>\n          index < array.length - 1 ? elString.replace(/\\n\\s*$/g, '') : elString\n        )\n        .join('')\n    : ''\n  const attrs = Object.keys(el.attributes).reduce(\n    (prev, curr) => prev + ` ${curr}=\"${el.attributes[curr]}\"`,\n    ''\n  )\n  const parentPadding = '    '.repeat(Math.max(0, indentationLevel - 1))\n  if (children === '') {\n    return `\n${padding}<${el.name}${attrs}/>\n${parentPadding}`\n  }\n  return `\n${padding}<${el.name}${attrs}>${children}</${el.name}>\n${parentPadding}`\n}\n\n/**\n * @param name\n * @returns namespace, null if none found\n */\nfunction extractNamespace(name: string): string | null {\n  const colon = name.indexOf(':')\n  return colon > -1 ? name.substring(0, colon) : null\n}\n\nconst NAMESPACES = {\n  gmd: 'http://www.isotc211.org/2005/gmd',\n  gco: 'http://www.isotc211.org/2005/gco',\n  gfc: 'http://www.isotc211.org/2005/gfc',\n  gml: 'http://www.opengis.net/gml/3.2',\n  xsi: 'http://www.w3.org/2001/XMLSchema-instance',\n  srv: 'http://www.isotc211.org/2005/srv',\n  gmx: 'http://www.isotc211.org/2005/gmx',\n  gts: 'http://www.isotc211.org/2005/gts',\n  gsr: 'http://www.isotc211.org/2005/gsr',\n  gmi: 'http://www.isotc211.org/2005/gmi',\n  xlink: 'http://www.w3.org/1999/xlink',\n}\n\n/**\n * @param name Full name with namespace, e.g.: gmd:MD_Metadata\n */\nexport function createElement(\n  name: string\n): ChainableFunction<void, XmlElement> {\n  return () => new XmlElement(name, {}, [])\n}\n\nexport function addAttribute(\n  name: string,\n  value: string\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    element.attributes[name] = value\n    return element\n  }\n}\n\n// stays on the parent element\n// if the given elements are part of a subtree, will add the root of subtree\nexport function appendChildren(\n  ...childrenFns: Array<ChainableFunction<void, XmlElement>>\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    if (!element) return null\n    element.children.push(\n      ...childrenFns\n        .map((fn) => fn())\n        .map((el) => {\n          let root = el\n          while (root.parent instanceof XmlElement) {\n            root = root.parent\n          }\n          return root\n        })\n    )\n    element.children.forEach((el) => (el.parent = element))\n    return element\n  }\n}\n\n// switches to the child element\nexport function createChild(\n  childName: string\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    if (!element) return null\n    const child = createElement(childName)()\n    element.children.push(child)\n    child.parent = element\n    return child\n  }\n}\n\nexport function findChildOrCreate(\n  name: string\n): ChainableFunction<XmlElement, XmlElement> {\n  return fallback(findChildElement(name, false), createChild(name))\n}\n\nexport function findNestedChildOrCreate(\n  ...elementNames: string[]\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    let current = element\n    for (const name of elementNames) {\n      current = findChildOrCreate(name)(current)\n    }\n    return current\n  }\n}\n\nexport function setTextContent(\n  text: string\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    if (!element) return null\n    const textEl = element.children.find(\n      (el) => el instanceof XmlText\n    ) as XmlText\n    if (!textEl) {\n      element.children.push(new XmlText(text))\n    } else {\n      textEl.text = text\n    }\n    return element\n  }\n}\n\nexport function removeAllChildren(): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    if (!element) return null\n    element.children.forEach((el) => (el.parent = null))\n    element.children = []\n    return element\n  }\n}\n\nexport function removeChildrenByName(\n  name: string\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    if (!element) return null\n    const strippedName = stripNamespace(name)\n    const removed = element.children.filter(\n      (child) =>\n        child instanceof XmlElement &&\n        stripNamespace(getElementName(child)) === strippedName\n    )\n    removed.forEach((el) => (el.parent = null))\n    element.children = element.children.filter(\n      (child) => removed.indexOf(child) === -1\n    )\n    return element\n  }\n}\n\nexport function removeChildren(\n  childrenFn: ChainableFunction<XmlElement, Array<XmlElement>>\n): ChainableFunction<XmlElement, XmlElement> {\n  return (element) => {\n    const children = childrenFn(element)\n    children.forEach((child) => (child.parent = null))\n    element.children = element.children.filter(\n      (child) => child instanceof XmlElement && children.indexOf(child) === -1\n    )\n    return element\n  }\n}\n"]}

package/esm2022/libs/api/repository/src/index.mjs

@@ -0,0 +1,3 @@
+export * from './lib/metadata-language';
+export * from './lib/repository-url';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FwaS9yZXBvc2l0b3J5L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFBO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9tZXRhZGF0YS1sYW5ndWFnZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlcG9zaXRvcnktdXJsJ1xuIl19

package/esm2022/libs/api/repository/src/lib/gn4/auth/auth.service.mjs

@@ -0,0 +1,63 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { MeApiService, } from '../../../../../../../libs/data-access/gn4/src';
+import { LANG_2_TO_3_MAPPER } from '../../../../../../../libs/util/i18n/src';
+import { TranslateService } from '@ngx-translate/core';
+import { map, shareReplay } from 'rxjs/operators';
+import { AvatarServiceInterface } from './avatar.service.interface';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../../../libs/data-access/gn4/src";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "./avatar.service.interface";
+export const DEFAULT_GN4_LOGIN_URL = `/geonetwork/srv/\${lang3}/catalog.signin?redirect=\${current_url}`;
+export const LOGIN_URL = new InjectionToken('loginUrl');
+export class AuthService {
+    get loginUrl() {
+        let baseUrl = this.baseLoginUrl;
+        const locationHasQueryParams = !!window.location.search;
+        // this is specific to georchestra login URL based on a ?login query param
+        if (baseUrl.startsWith('${current_url}?') && locationHasQueryParams) {
+            baseUrl = baseUrl.replace('?', '&');
+        }
+        return baseUrl
+            .replace('${current_url}', window.location.toString())
+            .replace('${lang2}', this.translateService.currentLang)
+            .replace('${lang3}', LANG_2_TO_3_MAPPER[this.translateService.currentLang]);
+    }
+    constructor(baseLoginUrlToken, meApi, translateService, avatarService) {
+        this.baseLoginUrlToken = baseLoginUrlToken;
+        this.meApi = meApi;
+        this.translateService = translateService;
+        this.avatarService = avatarService;
+        this.isAnonymous$ = this.authReady().pipe(map((user) => !user || !('id' in user)));
+        this.baseLoginUrl = this.baseLoginUrlToken || DEFAULT_GN4_LOGIN_URL;
+        this.user$ = this.meApi.getMe().pipe(map((apiUser) => this.mapToUserModel(apiUser)), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    // TODO: refactor authReady
+    authReady() {
+        if (!this.authReady$) {
+            this.authReady$ = this.meApi.getMe().pipe(map((apiUser) => this.mapToUserModel(apiUser)), shareReplay({ bufferSize: 1, refCount: true }));
+        }
+        return this.authReady$;
+    }
+    mapToUserModel(apiUser) {
+        if (!apiUser)
+            return null;
+        const { hash, groupsWithRegisteredUser, groupsWithEditor, groupsWithReviewer, groupsWithUserAdmin, admin, ...user } = apiUser;
+        const icon = this.avatarService.getProfileIcon(apiUser.hash);
+        return { ...user, profileIcon: icon };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: AuthService, deps: [{ token: LOGIN_URL, optional: true }, { token: i1.MeApiService }, { token: i2.TranslateService }, { token: i3.AvatarServiceInterface }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LOGIN_URL]
+                }] }, { type: i1.MeApiService }, { type: i2.TranslateService }, { type: i3.AvatarServiceInterface }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hcGkvcmVwb3NpdG9yeS9zcmMvbGliL2duNC9hdXRoL2F1dGguc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxjQUFjLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBQzVFLE9BQU8sRUFDTCxZQUFZLEdBRWIsTUFBTSwrQ0FBK0MsQ0FBQTtBQUN0RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQTtBQUU1RSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQTtBQUV0RCxPQUFPLEVBQUUsR0FBRyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBQ2pELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDRCQUE0QixDQUFBOzs7OztBQUVuRSxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxtRUFBbUUsQ0FBQTtBQUN4RyxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsSUFBSSxjQUFjLENBQVMsVUFBVSxDQUFDLENBQUE7QUFLL0QsTUFBTSxPQUFPLFdBQVc7SUFNdEIsSUFBSSxRQUFRO1FBQ1YsSUFBSSxPQUFPLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQTtRQUMvQixNQUFNLHNCQUFzQixHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQTtRQUN2RCwwRUFBMEU7UUFDMUUsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLGlCQUFpQixDQUFDLElBQUksc0JBQXNCLEVBQUU7WUFDbkUsT0FBTyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFBO1NBQ3BDO1FBQ0QsT0FBTyxPQUFPO2FBQ1gsT0FBTyxDQUFDLGdCQUFnQixFQUFFLE1BQU0sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7YUFDckQsT0FBTyxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsV0FBVyxDQUFDO2FBQ3RELE9BQU8sQ0FDTixVQUFVLEVBQ1Ysa0JBQWtCLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFdBQVcsQ0FBQyxDQUN0RCxDQUFBO0lBQ0wsQ0FBQztJQUNELFlBR1UsaUJBQXlCLEVBQ3pCLEtBQW1CLEVBQ25CLGdCQUFrQyxFQUNsQyxhQUFxQztRQUhyQyxzQkFBaUIsR0FBakIsaUJBQWlCLENBQVE7UUFDekIsVUFBSyxHQUFMLEtBQUssQ0FBYztRQUNuQixxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQWtCO1FBQ2xDLGtCQUFhLEdBQWIsYUFBYSxDQUF3QjtRQXhCL0MsaUJBQVksR0FBRyxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLElBQUksSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFFN0UsaUJBQVksR0FBRyxJQUFJLENBQUMsaUJBQWlCLElBQUkscUJBQXFCLENBQUE7UUF3QjVELElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQyxJQUFJLENBQ2xDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUM5QyxXQUFXLENBQUMsRUFBRSxVQUFVLEVBQUUsQ0FBQyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUMvQyxDQUFBO0lBQ0gsQ0FBQztJQUVELDJCQUEyQjtJQUMzQixTQUFTO1FBQ1AsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDcEIsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDLElBQUksQ0FDdkMsR0FBRyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQzlDLFdBQVcsQ0FBQyxFQUFFLFVBQVUsRUFBRSxDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDLENBQy9DLENBQUE7U0FDRjtRQUNELE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQTtJQUN4QixDQUFDO0lBRU8sY0FBYyxDQUFDLE9BQTJCO1FBQ2hELElBQUksQ0FBQyxPQUFPO1lBQUUsT0FBTyxJQUFJLENBQUE7UUFDekIsTUFBTSxFQUNKLElBQUksRUFDSix3QkFBd0IsRUFDeEIsZ0JBQWdCLEVBQ2hCLGtCQUFrQixFQUNsQixtQkFBbUIsRUFDbkIsS0FBSyxFQUNMLEdBQUcsSUFBSSxFQUNSLEdBQUcsT0FBTyxDQUFBO1FBQ1gsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQzVELE9BQU8sRUFBRSxHQUFHLElBQUksRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFlLENBQUE7SUFDcEQsQ0FBQzs4R0EzRFUsV0FBVyxrQkF1QlosU0FBUztrSEF2QlIsV0FBVyxjQUZWLE1BQU07OzJGQUVQLFdBQVc7a0JBSHZCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25COzswQkF1QkksUUFBUTs7MEJBQ1IsTUFBTTsyQkFBQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0LCBJbmplY3RhYmxlLCBJbmplY3Rpb25Ub2tlbiwgT3B0aW9uYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHtcbiAgTWVBcGlTZXJ2aWNlLFxuICBNZVJlc3BvbnNlQXBpTW9kZWwsXG59IGZyb20gJy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3MvZ240L3NyYydcbmltcG9ydCB7IExBTkdfMl9UT18zX01BUFBFUiB9IGZyb20gJy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdXRpbC9pMThuL3NyYydcbmltcG9ydCB7IFVzZXJNb2RlbCB9IGZyb20gJy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL2RvbWFpbi9zcmMvbGliL3VzZXIubW9kZWwnXG5pbXBvcnQgeyBUcmFuc2xhdGVTZXJ2aWNlIH0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSdcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJ1xuaW1wb3J0IHsgbWFwLCBzaGFyZVJlcGxheSB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJ1xuaW1wb3J0IHsgQXZhdGFyU2VydmljZUludGVyZmFjZSB9IGZyb20gJy4vYXZhdGFyLnNlcnZpY2UuaW50ZXJmYWNlJ1xuXG5leHBvcnQgY29uc3QgREVGQVVMVF9HTjRfTE9HSU5fVVJMID0gYC9nZW9uZXR3b3JrL3Nydi9cXCR7bGFuZzN9L2NhdGFsb2cuc2lnbmluP3JlZGlyZWN0PVxcJHtjdXJyZW50X3VybH1gXG5leHBvcnQgY29uc3QgTE9HSU5fVVJMID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oJ2xvZ2luVXJsJylcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIEF1dGhTZXJ2aWNlIHtcbiAgYXV0aFJlYWR5JDogT2JzZXJ2YWJsZTxVc2VyTW9kZWw+XG4gIHVzZXIkOiBPYnNlcnZhYmxlPFVzZXJNb2RlbD5cbiAgaXNBbm9ueW1vdXMkID0gdGhpcy5hdXRoUmVhZHkoKS5waXBlKG1hcCgodXNlcikgPT4gIXVzZXIgfHwgISgnaWQnIGluIHVzZXIpKSlcblxuICBiYXNlTG9naW5VcmwgPSB0aGlzLmJhc2VMb2dpblVybFRva2VuIHx8IERFRkFVTFRfR040X0xPR0lOX1VSTFxuICBnZXQgbG9naW5VcmwoKSB7XG4gICAgbGV0IGJhc2VVcmwgPSB0aGlzLmJhc2VMb2dpblVybFxuICAgIGNvbnN0IGxvY2F0aW9uSGFzUXVlcnlQYXJhbXMgPSAhIXdpbmRvdy5sb2NhdGlvbi5zZWFyY2hcbiAgICAvLyB0aGlzIGlzIHNwZWNpZmljIHRvIGdlb3JjaGVzdHJhIGxvZ2luIFVSTCBiYXNlZCBvbiBhID9sb2dpbiBxdWVyeSBwYXJhbVxuICAgIGlmIChiYXNlVXJsLnN0YXJ0c1dpdGgoJyR7Y3VycmVudF91cmx9PycpICYmIGxvY2F0aW9uSGFzUXVlcnlQYXJhbXMpIHtcbiAgICAgIGJhc2VVcmwgPSBiYXNlVXJsLnJlcGxhY2UoJz8nLCAnJicpXG4gICAgfVxuICAgIHJldHVybiBiYXNlVXJsXG4gICAgICAucmVwbGFjZSgnJHtjdXJyZW50X3VybH0nLCB3aW5kb3cubG9jYXRpb24udG9TdHJpbmcoKSlcbiAgICAgIC5yZXBsYWNlKCcke2xhbmcyfScsIHRoaXMudHJhbnNsYXRlU2VydmljZS5jdXJyZW50TGFuZylcbiAgICAgIC5yZXBsYWNlKFxuICAgICAgICAnJHtsYW5nM30nLFxuICAgICAgICBMQU5HXzJfVE9fM19NQVBQRVJbdGhpcy50cmFuc2xhdGVTZXJ2aWNlLmN1cnJlbnRMYW5nXVxuICAgICAgKVxuICB9XG4gIGNvbnN0cnVjdG9yKFxuICAgIEBPcHRpb25hbCgpXG4gICAgQEluamVjdChMT0dJTl9VUkwpXG4gICAgcHJpdmF0ZSBiYXNlTG9naW5VcmxUb2tlbjogc3RyaW5nLFxuICAgIHByaXZhdGUgbWVBcGk6IE1lQXBpU2VydmljZSxcbiAgICBwcml2YXRlIHRyYW5zbGF0ZVNlcnZpY2U6IFRyYW5zbGF0ZVNlcnZpY2UsXG4gICAgcHJpdmF0ZSBhdmF0YXJTZXJ2aWNlOiBBdmF0YXJTZXJ2aWNlSW50ZXJmYWNlXG4gICkge1xuICAgIHRoaXMudXNlciQgPSB0aGlzLm1lQXBpLmdldE1lKCkucGlwZShcbiAgICAgIG1hcCgoYXBpVXNlcikgPT4gdGhpcy5tYXBUb1VzZXJNb2RlbChhcGlVc2VyKSksXG4gICAgICBzaGFyZVJlcGxheSh7IGJ1ZmZlclNpemU6IDEsIHJlZkNvdW50OiB0cnVlIH0pXG4gICAgKVxuICB9XG5cbiAgLy8gVE9ETzogcmVmYWN0b3IgYXV0aFJlYWR5XG4gIGF1dGhSZWFkeSgpOiBPYnNlcnZhYmxlPFVzZXJNb2RlbD4ge1xuICAgIGlmICghdGhpcy5hdXRoUmVhZHkkKSB7XG4gICAgICB0aGlzLmF1dGhSZWFkeSQgPSB0aGlzLm1lQXBpLmdldE1lKCkucGlwZShcbiAgICAgICAgbWFwKChhcGlVc2VyKSA9PiB0aGlzLm1hcFRvVXNlck1vZGVsKGFwaVVzZXIpKSxcbiAgICAgICAgc2hhcmVSZXBsYXkoeyBidWZmZXJTaXplOiAxLCByZWZDb3VudDogdHJ1ZSB9KVxuICAgICAgKVxuICAgIH1cbiAgICByZXR1cm4gdGhpcy5hdXRoUmVhZHkkXG4gIH1cblxuICBwcml2YXRlIG1hcFRvVXNlck1vZGVsKGFwaVVzZXI6IE1lUmVzcG9uc2VBcGlNb2RlbCk6IFVzZXJNb2RlbCB7XG4gICAgaWYgKCFhcGlVc2VyKSByZXR1cm4gbnVsbFxuICAgIGNvbnN0IHtcbiAgICAgIGhhc2gsXG4gICAgICBncm91cHNXaXRoUmVnaXN0ZXJlZFVzZXIsXG4gICAgICBncm91cHNXaXRoRWRpdG9yLFxuICAgICAgZ3JvdXBzV2l0aFJldmlld2VyLFxuICAgICAgZ3JvdXBzV2l0aFVzZXJBZG1pbixcbiAgICAgIGFkbWluLFxuICAgICAgLi4udXNlclxuICAgIH0gPSBhcGlVc2VyXG4gICAgY29uc3QgaWNvbiA9IHRoaXMuYXZhdGFyU2VydmljZS5nZXRQcm9maWxlSWNvbihhcGlVc2VyLmhhc2gpXG4gICAgcmV0dXJuIHsgLi4udXNlciwgcHJvZmlsZUljb246IGljb24gfSBhcyBVc2VyTW9kZWxcbiAgfVxufVxuIl19

package/esm2022/libs/api/repository/src/lib/gn4/auth/avatar.service.interface.mjs

@@ -0,0 +1,3 @@
+export class AvatarServiceInterface {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhdGFyLnNlcnZpY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hcGkvcmVwb3NpdG9yeS9zcmMvbGliL2duNC9hdXRoL2F2YXRhci5zZXJ2aWNlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQWdCLHNCQUFzQjtDQUczQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBdmF0YXJTZXJ2aWNlSW50ZXJmYWNlIHtcbiAgcHVibGljIGFic3RyYWN0IHBsYWNlaG9sZGVyOiBzdHJpbmdcbiAgcHVibGljIGFic3RyYWN0IGdldFByb2ZpbGVJY29uKC4uLmFyZ3MpOiBzdHJpbmdcbn1cbiJdfQ==

package/esm2022/libs/api/repository/src/lib/gn4/auth/gravatar.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { Gn4SettingsService } from '../settings/gn4-settings.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../settings/gn4-settings.service";
+export class GravatarService {
+    constructor(gn4SettingsService) {
+        this.gn4SettingsService = gn4SettingsService;
+        this.GRAVATAR_URL = 'https://www.gravatar.com/avatar/';
+        this.GRAVATAR_IDENTICON = 'mp';
+        this.placeholder = this.getProfileIcon('');
+        this.gn4SettingsService.identicon$.subscribe((identicon) => (this.GRAVATAR_IDENTICON = identicon.replace('gravatar:', '')));
+    }
+    getProfileIcon(hash) {
+        return `${this.GRAVATAR_URL}${hash}?d=${this.GRAVATAR_IDENTICON}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: GravatarService, deps: [{ token: i1.Gn4SettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: GravatarService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: GravatarService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Gn4SettingsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/api/repository/src/lib/gn4/auth/index.mjs

@@ -0,0 +1,4 @@
+export * from './auth.service';
+export * from './avatar.service.interface';
+export * from './gravatar.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FwaS9yZXBvc2l0b3J5L3NyYy9saWIvZ240L2F1dGgvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQTtBQUM5QixjQUFjLDRCQUE0QixDQUFBO0FBQzFDLGNBQWMsb0JBQW9CLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1dGguc2VydmljZSdcbmV4cG9ydCAqIGZyb20gJy4vYXZhdGFyLnNlcnZpY2UuaW50ZXJmYWNlJ1xuZXhwb3J0ICogZnJvbSAnLi9ncmF2YXRhci5zZXJ2aWNlJ1xuIl19

package/esm2022/libs/api/repository/src/lib/gn4/elasticsearch/constant.mjs

@@ -0,0 +1,31 @@
+export const ES_SOURCE_SUMMARY = [
+    'uuid',
+    'id',
+    'title',
+    'resource*',
+    'resourceTitleObject',
+    'resourceAbstractObject',
+    'overview',
+    'logo',
+    'codelist_status_text',
+    'linkProtocol',
+    'contactForResource.organisation',
+    'contact.organisation',
+    'contact.email',
+    'userSavedCount',
+    'updateFrequency',
+    'cl_topic',
+    'cl_maintenanceAndUpdateFrequency',
+    'tag',
+    'MD_LegalConstraintsUseLimitationObject',
+    'qualityScore',
+];
+export const ES_QUERY_FIELDS_PRIORITY = {
+    'resourceTitleObject.${searchLang}': 5,
+    'tag.${searchLang}': 4,
+    'resourceAbstractObject.${searchLang}': 3,
+    'lineageObject.${searchLang}': 2,
+    'any.${searchLang}': 1,
+    uuid: 1,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FwaS9yZXBvc2l0b3J5L3NyYy9saWIvZ240L2VsYXN0aWNzZWFyY2gvY29uc3RhbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUc7SUFDL0IsTUFBTTtJQUNOLElBQUk7SUFDSixPQUFPO0lBQ1AsV0FBVztJQUNYLHFCQUFxQjtJQUNyQix3QkFBd0I7SUFDeEIsVUFBVTtJQUNWLE1BQU07SUFDTixzQkFBc0I7SUFDdEIsY0FBYztJQUNkLGlDQUFpQztJQUNqQyxzQkFBc0I7SUFDdEIsZUFBZTtJQUNmLGdCQUFnQjtJQUNoQixpQkFBaUI7SUFDakIsVUFBVTtJQUNWLGtDQUFrQztJQUNsQyxLQUFLO0lBQ0wsd0NBQXdDO0lBQ3hDLGNBQWM7Q0FDZixDQUFBO0FBR0QsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUc7SUFDdEMsbUNBQW1DLEVBQUUsQ0FBQztJQUN0QyxtQkFBbUIsRUFBRSxDQUFDO0lBQ3RCLHNDQUFzQyxFQUFFLENBQUM7SUFDekMsNkJBQTZCLEVBQUUsQ0FBQztJQUNoQyxtQkFBbUIsRUFBRSxDQUFDO0lBQ3RCLElBQUksRUFBRSxDQUFDO0NBQ1IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBFU19TT1VSQ0VfU1VNTUFSWSA9IFtcbiAgJ3V1aWQnLFxuICAnaWQnLFxuICAndGl0bGUnLFxuICAncmVzb3VyY2UqJyxcbiAgJ3Jlc291cmNlVGl0bGVPYmplY3QnLFxuICAncmVzb3VyY2VBYnN0cmFjdE9iamVjdCcsXG4gICdvdmVydmlldycsXG4gICdsb2dvJyxcbiAgJ2NvZGVsaXN0X3N0YXR1c190ZXh0JyxcbiAgJ2xpbmtQcm90b2NvbCcsXG4gICdjb250YWN0Rm9yUmVzb3VyY2Uub3JnYW5pc2F0aW9uJyxcbiAgJ2NvbnRhY3Qub3JnYW5pc2F0aW9uJyxcbiAgJ2NvbnRhY3QuZW1haWwnLFxuICAndXNlclNhdmVkQ291bnQnLFxuICAndXBkYXRlRnJlcXVlbmN5JyxcbiAgJ2NsX3RvcGljJyxcbiAgJ2NsX21haW50ZW5hbmNlQW5kVXBkYXRlRnJlcXVlbmN5JyxcbiAgJ3RhZycsXG4gICdNRF9MZWdhbENvbnN0cmFpbnRzVXNlTGltaXRhdGlvbk9iamVjdCcsXG4gICdxdWFsaXR5U2NvcmUnLFxuXVxuXG5leHBvcnQgdHlwZSBFc1F1ZXJ5RmllbGRzUHJpb3JpdHlUeXBlID0gUmVjb3JkPHN0cmluZywgbnVtYmVyPlxuZXhwb3J0IGNvbnN0IEVTX1FVRVJZX0ZJRUxEU19QUklPUklUWSA9IHtcbiAgJ3Jlc291cmNlVGl0bGVPYmplY3QuJHtzZWFyY2hMYW5nfSc6IDUsXG4gICd0YWcuJHtzZWFyY2hMYW5nfSc6IDQsXG4gICdyZXNvdXJjZUFic3RyYWN0T2JqZWN0LiR7c2VhcmNoTGFuZ30nOiAzLFxuICAnbGluZWFnZU9iamVjdC4ke3NlYXJjaExhbmd9JzogMixcbiAgJ2FueS4ke3NlYXJjaExhbmd9JzogMSxcbiAgdXVpZDogMSxcbn1cbiJdfQ==