@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/core/utils/resources.mjs

@@ -0,0 +1,66 @@
+export const RESOURCE_MAC_TYPES = ['cpu', 'memory'];
+export const RESOURCE_REQUIREMENT_KEYS = ['requests', 'limits'];
+export function getResourceViewModel(data, type, preferEmptyOrC) {
+    // 对于 '2' 的cpu大小，视图上展示为 '2c'
+    if (type === 'cpu' && !isNaN(+data)) {
+        data = `${data}c`;
+    }
+    if (type === 'memory' && !isNaN(+data)) {
+        data = `${data}Bytes`;
+    }
+    const reg = /^(\d?\.?\d+)([A-Za-z]+)$/;
+    const res = {
+        value: '',
+        unit: '',
+    };
+    if (!isNaN(parseFloat(data))) {
+        const _res = reg.exec(data) || [];
+        res.value = _res[1] || '';
+        const unit = _res[2];
+        switch (type) {
+            case 'cpu': {
+                res.unit = preferEmptyOrC && unit === 'c' ? '' : unit || 'm';
+                break;
+            }
+            case 'memory': {
+                res.unit = unit || '';
+                break;
+            }
+        }
+    }
+    return res;
+}
+export const resourceUnits = {
+    cpu: [
+        {
+            value: 'm',
+            label: 'm',
+        },
+        {
+            value: 'c',
+            label: 'core',
+        },
+    ],
+    memory: ['Mi', 'Gi'],
+};
+export function getResourceValue(data) {
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (data.value) {
+        return !data.unit || data.unit === 'c' || data.unit === 'Bytes'
+            ? data.value
+            : `${data.value}${data.unit}`;
+    }
+    return '';
+}
+export function transferResource(resource) {
+    return Object.keys(resource).reduce((item, type) => {
+        const value = getResourceValue(resource[type]);
+        if (value) {
+            item[type] = value;
+        }
+        return item;
+    }, {});
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/utils/sort-fn.mjs

@@ -0,0 +1,7 @@
+export function sortByCreationTimestamp(list) {
+    if (list) {
+        return [...list].sort((a, b) => +new Date(b.metadata.creationTimestamp) -
+            +new Date(a.metadata.creationTimestamp));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1mbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL3V0aWxzL3NvcnQtZm4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLHVCQUF1QixDQUNyQyxJQUFTO0lBRVQsSUFBSSxJQUFJLEVBQUU7UUFDUixPQUFPLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQ25CLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQ1AsQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDO1lBQ3ZDLENBQUMsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUMxQyxDQUFDO0tBQ0g7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgS3ViZXJuZXRlc1Jlc291cmNlIH0gZnJvbSAnLi4vdHlwZXMvazhzL2NvcmUnO1xuXG5leHBvcnQgZnVuY3Rpb24gc29ydEJ5Q3JlYXRpb25UaW1lc3RhbXA8VCBleHRlbmRzIEt1YmVybmV0ZXNSZXNvdXJjZT4oXG4gIGxpc3Q6IFRbXSxcbik6IFRbXSB7XG4gIGlmIChsaXN0KSB7XG4gICAgcmV0dXJuIFsuLi5saXN0XS5zb3J0KFxuICAgICAgKGEsIGIpID0+XG4gICAgICAgICtuZXcgRGF0ZShiLm1ldGFkYXRhLmNyZWF0aW9uVGltZXN0YW1wKSAtXG4gICAgICAgICtuZXcgRGF0ZShhLm1ldGFkYXRhLmNyZWF0aW9uVGltZXN0YW1wKSxcbiAgICApO1xuICB9XG59XG4iXX0=

package/esm2022/core/utils/tree.mjs

@@ -0,0 +1,79 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+// reduceTree :: String -> (a -> Tree -> [Tree] -> [Number] -> a) -> a -> [Tree] -> a
+export const reduceTrees = (subtreeKey) => (fn) => (seed) => (trees) => {
+    const reducer = (nodes, parents, path, acc) => nodes.reduce((prev, curr, index) => {
+        const result = fn(prev, curr, parents, [...path, index]);
+        return curr[subtreeKey]
+            ? reducer(curr[subtreeKey], [...parents, curr], [...path, index], result)
+            : result;
+    }, acc);
+    return reducer(trees, [], [], seed);
+};
+// mapTree :: String -> (Tree -> [Tree] -> [Number] -> Tree) -> [Tree] -> [Tree]
+export const mapTrees = (subtreeKey) => (fn) => (trees) => {
+    const mapper = (acc, curr, parents, path) => {
+        const mapped = fn(curr, parents, path);
+        return setNode(subtreeKey, path, acc, mapped);
+    };
+    return reduceTrees(subtreeKey)(mapper)([])(trees);
+};
+export const filterTrees = (subtreeKey) => (fn) => (trees) => {
+    const filter = (nodes, parents, path) => nodes
+        ?.filter(node => fn(node, parents, path))
+        .map((node, index) => node[subtreeKey]
+        ? {
+            ...node,
+            [subtreeKey]: filter(node[subtreeKey], [...parents, node], [...path, index]),
+        }
+        : node);
+    return filter(trees, [], []);
+};
+export const findPath = (subtreeKey) => (fn) => (trees) => {
+    const endPoint = [];
+    const finder = (nodes, parents, path) => {
+        const result = nodes.find((node, index) => {
+            if (fn(node, parents, path)) {
+                return true;
+            }
+            if (node[subtreeKey]) {
+                return finder(node[subtreeKey], [...parents, node], [...path, index]);
+            }
+            return false;
+        });
+        if (result) {
+            endPoint.unshift(result);
+        }
+        return !!result;
+    };
+    finder(trees, [], []);
+    return endPoint;
+};
+export const firstPath = (subtreeKey) => (trees) => {
+    const head = trees[0];
+    if (head) {
+        return head.children
+            ? [head, ...firstPath(subtreeKey)(head[subtreeKey])]
+            : [head];
+    }
+    return [];
+};
+export function setNode(subtreeKey, path, source, target) {
+    const iterator = ([head, ...tail], trees) => {
+        if (tail.length > 0) {
+            const point = trees[head] || {};
+            const tree = {
+                ...point,
+                [subtreeKey]: iterator(tail, (point[subtreeKey] || [])),
+            };
+            trees[head] = tree;
+            return trees;
+        }
+        trees[head] = target;
+        return trees;
+    };
+    return iterator(path, source);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/utils/tree.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\n// reduceTree :: String -> (a -> Tree -> [Tree] -> [Number] -> a) -> a -> [Tree] -> a\nexport const reduceTrees =\n  (subtreeKey: string) =>\n  <T extends Tree, R>(fn: TreeReducer<T, R>) =>\n  (seed: R) =>\n  (trees: T[]) => {\n    const reducer = (nodes: T[], parents: T[], path: number[], acc: R): R =>\n      nodes.reduce((prev, curr, index) => {\n        const result = fn(prev, curr, parents, [...path, index]);\n        return curr[subtreeKey]\n          ? reducer(\n              curr[subtreeKey] as T[],\n              [...parents, curr],\n              [...path, index],\n              result,\n            )\n          : result;\n      }, acc);\n    return reducer(trees, [], [], seed);\n  };\n\n// mapTree :: String -> (Tree -> [Tree] -> [Number] -> Tree) -> [Tree] -> [Tree]\nexport const mapTrees =\n  (subtreeKey: string) =>\n  <T extends Tree, R extends Tree>(fn: TreeMapper<T, R>) =>\n  (trees: T[]) => {\n    const mapper = (acc: R[], curr: T, parents: T[], path: number[]) => {\n      const mapped = fn(curr, parents, path);\n      return setNode<R>(subtreeKey, path, acc, mapped);\n    };\n    return reduceTrees(subtreeKey)<T, R[]>(mapper)([])(trees);\n  };\n\nexport const filterTrees =\n  (subtreeKey: string) =>\n  <T extends Tree>(fn: TreeFilter<T>) =>\n  (trees: T[]) => {\n    const filter = (nodes: T[], parents: T[], path: number[]): T[] =>\n      nodes\n        ?.filter(node => fn(node, parents, path))\n        .map((node, index) =>\n          node[subtreeKey]\n            ? {\n                ...node,\n                [subtreeKey]: filter(\n                  node[subtreeKey] as T[],\n                  [...parents, node],\n                  [...path, index],\n                ),\n              }\n            : node,\n        );\n    return filter(trees, [], []);\n  };\n\nexport const findPath =\n  (subtreeKey: string) =>\n  <T extends Tree>(fn: TreeFilter<T>) =>\n  (trees: T[]) => {\n    const endPoint: T[] = [];\n    const finder = (nodes: T[], parents: T[], path: number[]): boolean => {\n      const result = nodes.find((node, index) => {\n        if (fn(node, parents, path)) {\n          return true;\n        }\n        if (node[subtreeKey]) {\n          return finder(\n            node[subtreeKey] as T[],\n            [...parents, node],\n            [...path, index],\n          );\n        }\n        return false;\n      });\n      if (result) {\n        endPoint.unshift(result);\n      }\n      return !!result;\n    };\n\n    finder(trees, [], []);\n    return endPoint;\n  };\n\nexport const firstPath =\n  (subtreeKey: string) =>\n  <T extends Tree>(trees: T[]): T[] => {\n    const head = trees[0];\n    if (head) {\n      return head.children\n        ? [head, ...firstPath(subtreeKey)<T>(head[subtreeKey] as T[])]\n        : [head];\n    }\n    return [];\n  };\n\nexport function setNode<T extends Tree>(\n  subtreeKey: string,\n  path: number[],\n  source: T[],\n  target: T,\n) {\n  const iterator = ([head, ...tail]: number[], trees: T[]) => {\n    if (tail.length > 0) {\n      const point = trees[head] || ({} as T);\n      const tree = {\n        ...point,\n        [subtreeKey]: iterator(tail, (point[subtreeKey] || []) as T[]),\n      };\n      trees[head] = tree;\n      return trees;\n    }\n    trees[head] = target;\n    return trees;\n  };\n  return iterator(path, source);\n}\n\nexport interface Tree {\n  [key: string]: Tree[];\n}\n\nexport type TreeReducer<T extends Tree, R> = (\n  acc: R,\n  currentNode: T,\n  parents: T[],\n  path: number[],\n) => R;\n\nexport type TreeMapper<T extends Tree, R extends Tree> = (\n  tree: T,\n  parents: T[],\n  path: number[],\n) => R;\n\nexport type TreeFilter<T extends Tree> = (\n  tree: T,\n  parents: T[],\n  path: number[],\n) => boolean;\n"]}

package/esm2022/core/utils/unit.mjs

@@ -0,0 +1,187 @@
+import { isBlank, numToStr } from './common';
+const COMMON_UNITS = ['M', 'G', 'T', 'P', 'E'];
+export const CORE_UNITS = ['m', '', 'k', ...COMMON_UNITS];
+export const CORE_UNIT_REG = new RegExp(`[${CORE_UNITS.join('')}]$`);
+const toUnitNumBase = (coreStr, isUnitM = false) => {
+    if (typeof coreStr === 'number') {
+        return numToStr(coreStr * Math.pow(1000, +isUnitM));
+    }
+    if (isBlank(coreStr)) {
+        return '';
+    }
+    coreStr = coreStr.trim();
+    const num = +coreStr.replace(CORE_UNIT_REG, '');
+    if (Number.isNaN(num)) {
+        return '';
+    }
+    if (num <= 0) {
+        return '0';
+    }
+    const lastChar = coreStr.at(-1);
+    let unitIndex = CORE_UNITS.indexOf(lastChar);
+    unitIndex = (unitIndex === -1 ? 0 : unitIndex - 1) + +isUnitM;
+    return numToStr(num * Math.pow(1000, unitIndex));
+};
+export const toUnitNumM = (coreStr) => toUnitNumBase(coreStr, true);
+export const toUnitNum = (coreStr) => toUnitNumBase(coreStr);
+export const UNITS = ['', 'K', ...COMMON_UNITS];
+export const UNIT_REG = new RegExp(`[${UNITS.join('')}]i?$`);
+// TODO: UNITS 临时被其他地方当成了枚举项使用，先临时添加MEMORY_UNITS来处理 toUnitI 中兼容 k、Ki 的问题
+const MEMORY_UNITS = ['', ['k', 'K'], ...COMMON_UNITS];
+const MEMORY_UNIT_REG = new RegExp(`[${MEMORY_UNITS.join('')}]i?$`);
+export const toUnitI = (str, negative = false) => {
+    if (typeof str === 'number') {
+        if (str <= 0 && !negative) {
+            return '0';
+        }
+        return numToStr(str);
+    }
+    if (isBlank(str)) {
+        return '';
+    }
+    str = str.trim();
+    const num = +str.replace(MEMORY_UNIT_REG, '');
+    if (Number.isNaN(num)) {
+        return '';
+    }
+    if (num <= 0 && !negative) {
+        return '0';
+    }
+    let base = 1000;
+    if (str.endsWith('i')) {
+        base = 1024;
+        str = str.replace(/i$/, '');
+    }
+    const lastChar = str.at(-1);
+    const unitIndex = MEMORY_UNITS.findIndex(unit => Array.isArray(unit) ? unit.includes(lastChar) : unit === lastChar);
+    return numToStr(num * Math.pow(base, unitIndex === -1 ? 0 : unitIndex));
+};
+export const toUnitMi = (str, negative) => {
+    const unitI = toUnitI(str, negative);
+    if (!unitI) {
+        return '';
+    }
+    return numToStr(+unitI / 1024 / 1024);
+};
+export const toUnitGi = (str, negative) => {
+    const unitI = toUnitI(str, negative);
+    if (!unitI) {
+        return '';
+    }
+    return numToStr(+unitI / 1024 / 1024 / 1024);
+};
+export const addUnitCoreM = (coreStr) => {
+    if (isBlank(coreStr)) {
+        return null;
+    }
+    return numToStr(+coreStr) + 'm';
+};
+export const addUnitMi = (miStr) => {
+    if (isBlank(miStr)) {
+        return null;
+    }
+    return numToStr(+miStr) + 'Mi';
+};
+export const addUnitGi = (giStr) => {
+    if (isBlank(giStr)) {
+        return null;
+    }
+    return numToStr(+giStr) + 'Gi';
+};
+const POWER_MEMORY_UNITS = ['Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei'];
+export function getAppropriateMemory(base) {
+    let unit = -1;
+    while (base >= 800 || unit >= POWER_MEMORY_UNITS.length - 1) {
+        base /= 1024;
+        unit++;
+    }
+    return {
+        value: base,
+        unit: POWER_MEMORY_UNITS[unit],
+    };
+}
+const reg = /^(\d?\.?\d+)(\w+)*$/;
+export function formatMemory(mem) {
+    const base = parseFloat(mem);
+    const res = reg.exec(mem);
+    const unit = res?.[2];
+    return unit ? getMemory(base, unit) : base;
+}
+export function getMemory(base, unit) {
+    switch (unit) {
+        case 'm': {
+            return base * 1e-3;
+        }
+        case 'K': {
+            return base * 1e3;
+        }
+        case 'Ki': {
+            return base * 1024;
+        }
+        case 'M': {
+            return base * 1e6;
+        }
+        case 'Mi': {
+            return base * 1024 ** 2;
+        }
+        case 'G': {
+            return base * 1e9;
+        }
+        case 'Gi': {
+            return base * 1024 ** 3;
+        }
+        case 'T': {
+            return base * 1e12;
+        }
+        case 'Ti': {
+            return base * 1024 ** 4;
+        }
+        case 'P': {
+            return base * 1e15;
+        }
+        case 'Pi': {
+            return base * 1024 ** 5;
+        }
+        case 'E': {
+            return base * 1e18;
+        }
+        case 'Ei': {
+            return base * 1024 ** 6;
+        }
+        default: {
+            return base;
+        }
+    }
+}
+export function getCpu(base, unit) {
+    switch (unit) {
+        case 'm': {
+            return base;
+        }
+        case 'c': {
+            return base * 1e3;
+        }
+        case 'k': {
+            return base * 1e6;
+        }
+        case 'M': {
+            return base * 1e9;
+        }
+        case 'G': {
+            return base * 1e12;
+        }
+        case 'T': {
+            return base * 1e15;
+        }
+        default: {
+            return base * 1e3;
+        }
+    }
+}
+export function formatCPU(cpu) {
+    const base = parseFloat(cpu);
+    const res = reg.exec(cpu);
+    const unit = res?.[2];
+    return getCpu(base, unit);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unit.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/utils/unit.ts"],"names":[],"mappings":"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","sourcesContent":["import { isBlank, numToStr } from './common';\n\nconst COMMON_UNITS = ['M', 'G', 'T', 'P', 'E'];\n\nexport const CORE_UNITS = ['m', '', 'k', ...COMMON_UNITS];\n\nexport const CORE_UNIT_REG = new RegExp(`[${CORE_UNITS.join('')}]$`);\n\nconst toUnitNumBase = (coreStr?: string | number, isUnitM = false) => {\n  if (typeof coreStr === 'number') {\n    return numToStr(coreStr * Math.pow(1000, +isUnitM));\n  }\n\n  if (isBlank(coreStr)) {\n    return '';\n  }\n  coreStr = coreStr.trim();\n  const num = +coreStr.replace(CORE_UNIT_REG, '');\n  if (Number.isNaN(num)) {\n    return '';\n  }\n  if (num <= 0) {\n    return '0';\n  }\n  const lastChar = coreStr.at(-1);\n  let unitIndex = CORE_UNITS.indexOf(lastChar);\n  unitIndex = (unitIndex === -1 ? 0 : unitIndex - 1) + +isUnitM;\n  return numToStr(num * Math.pow(1000, unitIndex));\n};\n\nexport const toUnitNumM = (coreStr?: string | number) =>\n  toUnitNumBase(coreStr, true);\n\nexport const toUnitNum = (coreStr?: string | number) => toUnitNumBase(coreStr);\n\nexport const UNITS = ['', 'K', ...COMMON_UNITS];\nexport const UNIT_REG = new RegExp(`[${UNITS.join('')}]i?$`);\n\n// TODO: UNITS 临时被其他地方当成了枚举项使用，先临时添加MEMORY_UNITS来处理 toUnitI 中兼容 k、Ki 的问题\nconst MEMORY_UNITS = ['', ['k', 'K'], ...COMMON_UNITS];\nconst MEMORY_UNIT_REG = new RegExp(`[${MEMORY_UNITS.join('')}]i?$`);\n\nexport const toUnitI = (str?: string | number, negative = false) => {\n  if (typeof str === 'number') {\n    if (str <= 0 && !negative) {\n      return '0';\n    }\n    return numToStr(str);\n  }\n\n  if (isBlank(str)) {\n    return '';\n  }\n  str = str.trim();\n  const num = +str.replace(MEMORY_UNIT_REG, '');\n  if (Number.isNaN(num)) {\n    return '';\n  }\n  if (num <= 0 && !negative) {\n    return '0';\n  }\n\n  let base = 1000;\n\n  if (str.endsWith('i')) {\n    base = 1024;\n    str = str.replace(/i$/, '');\n  }\n\n  const lastChar = str.at(-1);\n  const unitIndex = MEMORY_UNITS.findIndex(unit =>\n    Array.isArray(unit) ? unit.includes(lastChar) : unit === lastChar,\n  );\n  return numToStr(num * Math.pow(base, unitIndex === -1 ? 0 : unitIndex));\n};\n\nexport const toUnitMi = (str?: string | number, negative?: boolean) => {\n  const unitI = toUnitI(str, negative);\n  if (!unitI) {\n    return '';\n  }\n  return numToStr(+unitI / 1024 / 1024);\n};\n\nexport const toUnitGi = (str?: string | number, negative?: boolean) => {\n  const unitI = toUnitI(str, negative);\n  if (!unitI) {\n    return '';\n  }\n  return numToStr(+unitI / 1024 / 1024 / 1024);\n};\n\nexport const addUnitCoreM = (coreStr?: string | number) => {\n  if (isBlank(coreStr)) {\n    return null;\n  }\n  return numToStr(+coreStr) + 'm';\n};\n\nexport const addUnitMi = (miStr?: string | number) => {\n  if (isBlank(miStr)) {\n    return null;\n  }\n  return numToStr(+miStr) + 'Mi';\n};\n\nexport const addUnitGi = (giStr?: string | number) => {\n  if (isBlank(giStr)) {\n    return null;\n  }\n  return numToStr(+giStr) + 'Gi';\n};\n\nconst POWER_MEMORY_UNITS = ['Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei'];\n\nexport function getAppropriateMemory(base: number) {\n  let unit = -1;\n  while (base >= 800 || unit >= POWER_MEMORY_UNITS.length - 1) {\n    base /= 1024;\n    unit++;\n  }\n  return {\n    value: base,\n    unit: POWER_MEMORY_UNITS[unit],\n  };\n}\n\nconst reg = /^(\\d?\\.?\\d+)(\\w+)*$/;\n\nexport function formatMemory(mem: string) {\n  const base = parseFloat(mem);\n  const res = reg.exec(mem);\n  const unit = res?.[2];\n  return unit ? getMemory(base, unit) : base;\n}\n\nexport function getMemory(base: number, unit: string) {\n  switch (unit) {\n    case 'm': {\n      return base * 1e-3;\n    }\n    case 'K': {\n      return base * 1e3;\n    }\n    case 'Ki': {\n      return base * 1024;\n    }\n    case 'M': {\n      return base * 1e6;\n    }\n    case 'Mi': {\n      return base * 1024 ** 2;\n    }\n    case 'G': {\n      return base * 1e9;\n    }\n    case 'Gi': {\n      return base * 1024 ** 3;\n    }\n    case 'T': {\n      return base * 1e12;\n    }\n    case 'Ti': {\n      return base * 1024 ** 4;\n    }\n    case 'P': {\n      return base * 1e15;\n    }\n    case 'Pi': {\n      return base * 1024 ** 5;\n    }\n    case 'E': {\n      return base * 1e18;\n    }\n    case 'Ei': {\n      return base * 1024 ** 6;\n    }\n    default: {\n      return base;\n    }\n  }\n}\n\nexport function getCpu(base: number, unit: string) {\n  switch (unit) {\n    case 'm': {\n      return base;\n    }\n    case 'c': {\n      return base * 1e3;\n    }\n    case 'k': {\n      return base * 1e6;\n    }\n    case 'M': {\n      return base * 1e9;\n    }\n    case 'G': {\n      return base * 1e12;\n    }\n    case 'T': {\n      return base * 1e15;\n    }\n    default: {\n      return base * 1e3;\n    }\n  }\n}\n\nexport function formatCPU(cpu: string) {\n  const base = parseFloat(cpu);\n  const res = reg.exec(cpu);\n  const unit = res?.[2];\n  return getCpu(base, unit);\n}\n"]}

package/esm2022/core/utils/version.mjs

@@ -0,0 +1,76 @@
+/**
+ * 基于相对严格的版本号规则，规范可以参考https://semver.org/
+ * 但在比较版本号时使用相对宽松的规则，具体可以查看compare-versions库的实现
+ * 自测用例：https://stackblitz.com/edit/typescript-jqszbj
+ */
+import { compare } from 'compare-versions';
+export { compareVersions as compareVersionToNum, satisfies as satisfiesVersion, } from 'compare-versions';
+export const versionRegex = /^(\d+)\.(\d+)\.(\d+)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?$/;
+const removeFirstV = (version) => {
+    version = version.trim();
+    if (/^v\d/.test(version)) {
+        version = version.slice(1);
+    }
+    return version;
+};
+/**
+ * 获取有效的版本号，如果符合规范则返回，否则返回null
+ * eg: getValidVersion('v1.2.3') // '1.2.3'
+ */
+export const getValidVersion = (version) => {
+    version = removeFirstV(version);
+    return versionRegex.test(version) ? version : null;
+};
+/**
+ * 解析版本号，如果符合规范则返回一个包含版本信息的对象
+ */
+export const parseVersion = (version) => {
+    version = removeFirstV(version);
+    const match = version.match(versionRegex);
+    if (match?.length) {
+        return {
+            version: match[0],
+            major: +match[1],
+            minor: +match[2],
+            patch: +match[3],
+            prerelease: match[4]?.split('.').map(str => {
+                if (/^\d*$/.test(str)) {
+                    return +str;
+                }
+                return str;
+            }) || [],
+        };
+    }
+};
+const _getCompare = (operator) => (v1, v2) => compare(v1, v2, operator);
+/**
+ * 使用给定规则比较两个版本
+ * lt: v1小于v2;  gt: v1大于v2;  lte: v1小于等于v2;  gte: v1大于等于v2;
+ * eg: compareVersion.lt('1.2.3', '9.8.7') // true
+ *     compareVersion.cmp('1.2.3', '9.8.7', '<') // true
+ */
+export const compareVersion = {
+    lt: _getCompare('<'),
+    gt: _getCompare('>'),
+    eq: _getCompare('='),
+    lte: _getCompare('<='),
+    gte: _getCompare('>='),
+    cmp: compare,
+};
+// 允许使用宽松的版本号进行 minor 版本比较
+export const compareMinorVersion = (v1, v2) => {
+    const v1Arr = v1.split('.').map(v => parseInt(v));
+    const v2Arr = v2.split('.').map(v => parseInt(v));
+    for (let i = 0; i < 2; i++) {
+        const v1Part = v1Arr[i] || 0;
+        const v2Part = v2Arr[i] || 0;
+        if (v1Part > v2Part) {
+            return 1;
+        }
+        if (v1Part < v2Part) {
+            return -1;
+        }
+    }
+    return 0;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/utils/with-load-state.mjs

@@ -0,0 +1,21 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { of, catchError, map, startWith } from 'rxjs';
+export function withLoadState(input, defaultValue = null) {
+    return input.pipe(map(data => ({
+        loading: false,
+        data,
+        error: null,
+    })), startWith({
+        loading: true,
+        data: defaultValue,
+        error: null,
+    }), catchError(error => of({
+        loading: false,
+        data: defaultValue,
+        error,
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1sb2FkLXN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvdXRpbHMvd2l0aC1sb2FkLXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sRUFBYyxFQUFFLEVBQUUsVUFBVSxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFRbEUsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsS0FBb0IsRUFDcEIsZUFBa0IsSUFBSTtJQUV0QixPQUFPLEtBQUssQ0FBQyxJQUFJLENBQ2YsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNYLE9BQU8sRUFBRSxLQUFLO1FBQ2QsSUFBSTtRQUNKLEtBQUssRUFBRSxJQUFJO0tBQ1osQ0FBQyxDQUFDLEVBQ0gsU0FBUyxDQUFDO1FBQ1IsT0FBTyxFQUFFLElBQUk7UUFDYixJQUFJLEVBQUUsWUFBWTtRQUNsQixLQUFLLEVBQUUsSUFBSTtLQUNaLENBQUMsRUFDRixVQUFVLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FDakIsRUFBRSxDQUFDO1FBQ0QsT0FBTyxFQUFFLEtBQUs7UUFDZCxJQUFJLEVBQUUsWUFBWTtRQUNsQixLQUFLO0tBQ04sQ0FBQyxDQUNILENBQ0YsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSB1dGlsc1xuICovXG5cbmltcG9ydCB7IE9ic2VydmFibGUsIG9mLCBjYXRjaEVycm9yLCBtYXAsIHN0YXJ0V2l0aCB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFdpdGhMb2FkU3RhdGU8VCwgRSA9IHVua25vd24+IHtcbiAgbG9hZGluZzogYm9vbGVhbjtcbiAgZGF0YTogVDtcbiAgZXJyb3I6IEU7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiB3aXRoTG9hZFN0YXRlPFQ+KFxuICBpbnB1dDogT2JzZXJ2YWJsZTxUPixcbiAgZGVmYXVsdFZhbHVlOiBUID0gbnVsbCxcbik6IE9ic2VydmFibGU8V2l0aExvYWRTdGF0ZTxUPj4ge1xuICByZXR1cm4gaW5wdXQucGlwZShcbiAgICBtYXAoZGF0YSA9PiAoe1xuICAgICAgbG9hZGluZzogZmFsc2UsXG4gICAgICBkYXRhLFxuICAgICAgZXJyb3I6IG51bGwsXG4gICAgfSkpLFxuICAgIHN0YXJ0V2l0aCh7XG4gICAgICBsb2FkaW5nOiB0cnVlLFxuICAgICAgZGF0YTogZGVmYXVsdFZhbHVlLFxuICAgICAgZXJyb3I6IG51bGwsXG4gICAgfSksXG4gICAgY2F0Y2hFcnJvcihlcnJvciA9PlxuICAgICAgb2Yoe1xuICAgICAgICBsb2FkaW5nOiBmYWxzZSxcbiAgICAgICAgZGF0YTogZGVmYXVsdFZhbHVlLFxuICAgICAgICBlcnJvcixcbiAgICAgIH0pLFxuICAgICksXG4gICk7XG59XG4iXX0=

package/esm2022/core/utils/workspace.mjs

@@ -0,0 +1,59 @@
+import { ActivatedRoute, } from '@angular/router';
+export function parseWorkspace(workspace) {
+    if (!workspace) {
+        return null;
+    }
+    const [project, cluster, namespace] = workspace.split('~');
+    const workspaceObj = { project, cluster, namespace };
+    return isValidWorkspace(workspaceObj) ? workspaceObj : null;
+}
+export function stringifyWorkspace(workspace, strict = true) {
+    if (!strict && !workspace.project) {
+        Object.assign(workspace, { project: 'default' });
+    }
+    return isValidWorkspace(workspace)
+        ? `${workspace.project}~${workspace.cluster}~${workspace.namespace}`
+        : '';
+}
+export function isValidWorkspace(obj) {
+    return !!(obj?.project && obj?.cluster && obj?.namespace);
+}
+export function parseRID(rid) {
+    if (!rid) {
+        return null;
+    }
+    const [project, cluster, namespace, name] = rid.split('~');
+    const ridObj = { project, cluster, namespace, name };
+    return isValidRID(ridObj) ? ridObj : null;
+}
+export function stringifyRID(p1, p2) {
+    return isValidWorkspace(p1) && p2
+        ? `${p1.project}~${p1.cluster}~${p1.namespace}~${p2}`
+        : isValidRID(p1)
+            ? `${p1.project}~${p1.cluster}~${p1.namespace}~${p1.name}`
+            : '';
+}
+export function isValidRID(obj) {
+    return !!(obj?.project && obj?.cluster && obj?.namespace && obj?.name);
+}
+export function extractWorkspace(params) {
+    return params.get && params.get instanceof Function
+        ? parseWorkspace(params.get('workspace'))
+        : parseWorkspace(params.workspace);
+}
+export function extractWorkspaceFromRoute(route) {
+    const snapshot = route instanceof ActivatedRoute ? route.snapshot : route;
+    return parseWorkspace(snapshot.paramMap.get('workspace'));
+}
+// owner: ait
+export const workspaceToPath = (workspace) => {
+    if (!workspace) {
+        return '';
+    }
+    const { project, namespace, cluster } = workspace;
+    const p = project ? `/projects/${project}` : '';
+    const c = cluster ? `/clusters/${cluster}` : '';
+    const n = namespace ? `/namespaces/${namespace}` : '';
+    return `${p}${c}${n}`;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/utils/yaml.mjs

@@ -0,0 +1,54 @@
+import { cloneDeep, get, has, unset } from 'lodash-es';
+import { dissocPath } from 'ramda';
+import { parse as parseYaml, parseAllDocuments, } from 'yaml';
+export { stringify } from 'yaml';
+export const parse = (yaml, options) => parseYaml(yaml, options);
+export const safeParseYaml = (yaml, defaultValue = null, options) => {
+    try {
+        return parse(yaml, options);
+    }
+    catch {
+        return defaultValue;
+    }
+};
+export const parseAll = (yaml) => {
+    const docs = parseAllDocuments(yaml);
+    return docs.map(doc => doc.toJS());
+};
+export function yamlFilterField(resource, filterList, deepClone = true) {
+    let cloneResource = deepClone ? cloneDeep(resource) : resource;
+    filterList.forEach(pathOrFunction => {
+        if (typeof pathOrFunction === 'string') {
+            if (has(cloneResource, pathOrFunction)) {
+                unset(cloneResource, pathOrFunction);
+            }
+        }
+        else {
+            const list = pathOrFunction(cloneResource);
+            cloneResource = yamlFilterField(cloneResource, list, false);
+        }
+    });
+    return cloneResource;
+}
+export const removeDirtyFieldsBeforeUpdate = dissocPath(['metadata', 'managedFields']);
+export function prefixFilterRuleFactory(prefix, path, includeOrStartsWith = 'includes') {
+    return (resource) => {
+        if (!has(resource, path)) {
+            return [];
+        }
+        const obj = get(resource, path);
+        return Object.keys(obj)
+            .filter(item => item[includeOrStartsWith](prefix))
+            .map(item => [...path, `['${item}']`].join('.'));
+    };
+}
+export function emptyObjectRemoveRuleFactory(path) {
+    return (resource) => {
+        if (!has(resource, path)) {
+            return [];
+        }
+        const obj = get(resource, path);
+        return Object.keys(obj).length ? [] : [path.join('.')];
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFtbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL3V0aWxzL3lhbWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUN2RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sT0FBTyxDQUFDO0FBQ25DLE9BQU8sRUFFTCxLQUFLLElBQUksU0FBUyxFQUNsQixpQkFBaUIsR0FJbEIsTUFBTSxNQUFNLENBQUM7QUFJZCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRWpDLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxDQUNuQixJQUFZLEVBQ1osT0FBc0UsRUFDbkUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFFakMsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQzNCLElBQVksRUFDWixlQUFrQixJQUFJLEVBQ3RCLE9BQXNFLEVBQ3RFLEVBQUU7SUFDRixJQUFJO1FBQ0YsT0FBTyxLQUFLLENBQUksSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0tBQ2hDO0lBQUMsTUFBTTtRQUNOLE9BQU8sWUFBWSxDQUFDO0tBQ3JCO0FBQ0gsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLENBQUksSUFBWSxFQUFPLEVBQUU7SUFDL0MsTUFBTSxJQUFJLEdBQUcsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDckMsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7QUFDckMsQ0FBQyxDQUFDO0FBTUYsTUFBTSxVQUFVLGVBQWUsQ0FDN0IsUUFBVyxFQUNYLFVBQTRCLEVBQzVCLFNBQVMsR0FBRyxJQUFJO0lBRWhCLElBQUksYUFBYSxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUM7SUFDL0QsVUFBVSxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsRUFBRTtRQUNsQyxJQUFJLE9BQU8sY0FBYyxLQUFLLFFBQVEsRUFBRTtZQUN0QyxJQUFJLEdBQUcsQ0FBQyxhQUFhLEVBQUUsY0FBYyxDQUFDLEVBQUU7Z0JBQ3RDLEtBQUssQ0FBQyxhQUFhLEVBQUUsY0FBYyxDQUFDLENBQUM7YUFDdEM7U0FDRjthQUFNO1lBQ0wsTUFBTSxJQUFJLEdBQUcsY0FBYyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBQzNDLGFBQWEsR0FBRyxlQUFlLENBQUMsYUFBYSxFQUFFLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztTQUM3RDtJQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0gsT0FBTyxhQUFhLENBQUM7QUFDdkIsQ0FBQztBQUVELE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUVqQyxVQUFVLENBQUMsQ0FBQyxVQUFVLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztBQUVuRCxNQUFNLFVBQVUsdUJBQXVCLENBQ3JDLE1BQWMsRUFDZCxJQUFjLEVBQ2Qsc0JBR0ksVUFBVTtJQUVkLE9BQU8sQ0FBK0IsUUFBVyxFQUFFLEVBQUU7UUFDbkQsSUFBSSxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLEVBQUU7WUFDeEIsT0FBTyxFQUFFLENBQUM7U0FDWDtRQUNELE1BQU0sR0FBRyxHQUFHLEdBQUcsQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDaEMsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQzthQUNwQixNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQzthQUNqRCxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsSUFBSSxFQUFFLEtBQUssSUFBSSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNyRCxDQUFDLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLDRCQUE0QixDQUFDLElBQWM7SUFDekQsT0FBTyxDQUErQixRQUFXLEVBQUUsRUFBRTtRQUNuRCxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsRUFBRTtZQUN4QixPQUFPLEVBQUUsQ0FBQztTQUNYO1FBQ0QsTUFBTSxHQUFHLEdBQUcsR0FBRyxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNoQyxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ3pELENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjbG9uZURlZXAsIGdldCwgaGFzLCB1bnNldCB9IGZyb20gJ2xvZGFzaC1lcyc7XG5pbXBvcnQgeyBkaXNzb2NQYXRoIH0gZnJvbSAncmFtZGEnO1xuaW1wb3J0IHtcbiAgRG9jdW1lbnRPcHRpb25zLFxuICBwYXJzZSBhcyBwYXJzZVlhbWwsXG4gIHBhcnNlQWxsRG9jdW1lbnRzLFxuICBQYXJzZU9wdGlvbnMsXG4gIFNjaGVtYU9wdGlvbnMsXG4gIFRvSlNPcHRpb25zLFxufSBmcm9tICd5YW1sJztcblxuaW1wb3J0IHsgS3ViZXJuZXRlc1Jlc291cmNlIH0gZnJvbSAnLi4vdHlwZXMvcHVibGljLWFwaSc7XG5cbmV4cG9ydCB7IHN0cmluZ2lmeSB9IGZyb20gJ3lhbWwnO1xuXG5leHBvcnQgY29uc3QgcGFyc2UgPSA8VD4oXG4gIHlhbWw6IHN0cmluZyxcbiAgb3B0aW9ucz86IFBhcnNlT3B0aW9ucyAmIERvY3VtZW50T3B0aW9ucyAmIFNjaGVtYU9wdGlvbnMgJiBUb0pTT3B0aW9ucyxcbik6IFQgPT4gcGFyc2VZYW1sKHlhbWwsIG9wdGlvbnMpO1xuXG5leHBvcnQgY29uc3Qgc2FmZVBhcnNlWWFtbCA9IDxUPihcbiAgeWFtbDogc3RyaW5nLFxuICBkZWZhdWx0VmFsdWU6IFQgPSBudWxsLFxuICBvcHRpb25zPzogUGFyc2VPcHRpb25zICYgRG9jdW1lbnRPcHRpb25zICYgU2NoZW1hT3B0aW9ucyAmIFRvSlNPcHRpb25zLFxuKSA9PiB7XG4gIHRyeSB7XG4gICAgcmV0dXJuIHBhcnNlPFQ+KHlhbWwsIG9wdGlvbnMpO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gZGVmYXVsdFZhbHVlO1xuICB9XG59O1xuXG5leHBvcnQgY29uc3QgcGFyc2VBbGwgPSA8VD4oeWFtbDogc3RyaW5nKTogVFtdID0+IHtcbiAgY29uc3QgZG9jcyA9IHBhcnNlQWxsRG9jdW1lbnRzKHlhbWwpO1xuICByZXR1cm4gZG9jcy5tYXAoZG9jID0+IGRvYy50b0pTKCkpO1xufTtcblxuZXhwb3J0IHR5cGUgWWFtbEZpbHRlckl0ZW0gPVxuICB8IHN0cmluZ1xuICB8ICgocmVzb3VyY2U6IEt1YmVybmV0ZXNSZXNvdXJjZSkgPT4gc3RyaW5nW10pO1xuXG5leHBvcnQgZnVuY3Rpb24geWFtbEZpbHRlckZpZWxkPFQgZXh0ZW5kcyBLdWJlcm5ldGVzUmVzb3VyY2U+KFxuICByZXNvdXJjZTogVCxcbiAgZmlsdGVyTGlzdDogWWFtbEZpbHRlckl0ZW1bXSxcbiAgZGVlcENsb25lID0gdHJ1ZSxcbikge1xuICBsZXQgY2xvbmVSZXNvdXJjZSA9IGRlZXBDbG9uZSA/IGNsb25lRGVlcChyZXNvdXJjZSkgOiByZXNvdXJjZTtcbiAgZmlsdGVyTGlzdC5mb3JFYWNoKHBhdGhPckZ1bmN0aW9uID0+IHtcbiAgICBpZiAodHlwZW9mIHBhdGhPckZ1bmN0aW9uID09PSAnc3RyaW5nJykge1xuICAgICAgaWYgKGhhcyhjbG9uZVJlc291cmNlLCBwYXRoT3JGdW5jdGlvbikpIHtcbiAgICAgICAgdW5zZXQoY2xvbmVSZXNvdXJjZSwgcGF0aE9yRnVuY3Rpb24pO1xuICAgICAgfVxuICAgIH0gZWxzZSB7XG4gICAgICBjb25zdCBsaXN0ID0gcGF0aE9yRnVuY3Rpb24oY2xvbmVSZXNvdXJjZSk7XG4gICAgICBjbG9uZVJlc291cmNlID0geWFtbEZpbHRlckZpZWxkKGNsb25lUmVzb3VyY2UsIGxpc3QsIGZhbHNlKTtcbiAgICB9XG4gIH0pO1xuICByZXR1cm4gY2xvbmVSZXNvdXJjZTtcbn1cblxuZXhwb3J0IGNvbnN0IHJlbW92ZURpcnR5RmllbGRzQmVmb3JlVXBkYXRlOiA8VCBleHRlbmRzIEt1YmVybmV0ZXNSZXNvdXJjZT4oXG4gIHJlc291cmNlOiBULFxuKSA9PiBUID0gZGlzc29jUGF0aChbJ21ldGFkYXRhJywgJ21hbmFnZWRGaWVsZHMnXSk7XG5cbmV4cG9ydCBmdW5jdGlvbiBwcmVmaXhGaWx0ZXJSdWxlRmFjdG9yeShcbiAgcHJlZml4OiBzdHJpbmcsXG4gIHBhdGg6IHN0cmluZ1tdLFxuICBpbmNsdWRlT3JTdGFydHNXaXRoOiBFeHRyYWN0PFxuICAgIGtleW9mIHN0cmluZyxcbiAgICAnaW5jbHVkZXMnIHwgJ3N0YXJ0c1dpdGgnXG4gID4gPSAnaW5jbHVkZXMnLFxuKSB7XG4gIHJldHVybiA8VCBleHRlbmRzIEt1YmVybmV0ZXNSZXNvdXJjZT4ocmVzb3VyY2U6IFQpID0+IHtcbiAgICBpZiAoIWhhcyhyZXNvdXJjZSwgcGF0aCkpIHtcbiAgICAgIHJldHVybiBbXTtcbiAgICB9XG4gICAgY29uc3Qgb2JqID0gZ2V0KHJlc291cmNlLCBwYXRoKTtcbiAgICByZXR1cm4gT2JqZWN0LmtleXMob2JqKVxuICAgICAgLmZpbHRlcihpdGVtID0+IGl0ZW1baW5jbHVkZU9yU3RhcnRzV2l0aF0ocHJlZml4KSlcbiAgICAgIC5tYXAoaXRlbSA9PiBbLi4ucGF0aCwgYFsnJHtpdGVtfSddYF0uam9pbignLicpKTtcbiAgfTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVtcHR5T2JqZWN0UmVtb3ZlUnVsZUZhY3RvcnkocGF0aDogc3RyaW5nW10pIHtcbiAgcmV0dXJuIDxUIGV4dGVuZHMgS3ViZXJuZXRlc1Jlc291cmNlPihyZXNvdXJjZTogVCkgPT4ge1xuICAgIGlmICghaGFzKHJlc291cmNlLCBwYXRoKSkge1xuICAgICAgcmV0dXJuIFtdO1xuICAgIH1cbiAgICBjb25zdCBvYmogPSBnZXQocmVzb3VyY2UsIHBhdGgpO1xuICAgIHJldHVybiBPYmplY3Qua2V5cyhvYmopLmxlbmd0aCA/IFtdIDogW3BhdGguam9pbignLicpXTtcbiAgfTtcbn1cbiJdfQ==