@cccsaurora/clue-ui 1.2.0-dev.254 → 1.2.0

package/utils/classificationParser.js

@@ -1,553 +1,290 @@
-const defaultParts = {
+const E = {
   lvlIdx: 0,
   lvl: "",
   req: [],
   groups: [],
   subgroups: []
-};
-const defaultDisabled = {
+}, N = {
   groups: [],
   levels: []
 };
-class InvalidClassification extends Error {
+class O extends Error {
 }
-const getLevelText = (lvl, c12nDef, format, isMobile) => {
-  let text = null;
-  if (c12nDef != null && lvl != null) {
-    text = c12nDef.levels_map[lvl.toString()];
-  }
-  if (text === void 0 || text == null) {
-    console.error(
-      `[classificationParser] Classification level number '${lvl}' was not found in your classification definition.`
-    );
-    return "INVALID";
-  }
-  if (format === "long" && !isMobile) {
-    return c12nDef.levels_map_stl[text];
-  }
-  return text;
-};
-const getLevelIndex = (c12n, c12nDef) => {
-  let retIndex = null;
-  const [level, unused, _x] = (c12n == null ? void 0 : c12n.split(/\/\/(.*)/)) ?? [null, null, null];
-  const c12nLvl = level == null ? void 0 : level.toUpperCase();
-  if (c12nDef.levels_map[c12nLvl] !== void 0) {
-    retIndex = c12nDef.levels_map[c12nLvl];
-  } else if (c12nDef.levels_map_lts[c12nLvl] !== void 0) {
-    retIndex = c12nDef.levels_map[c12nDef.levels_map_lts[c12nLvl]];
-  } else if (c12nDef.levels_aliases[c12nLvl] !== void 0) {
-    retIndex = c12nDef.levels_map[c12nDef.levels_aliases[c12nLvl]];
-  } else {
-    retIndex = -1;
-    console.error(
-      `[classificationParser] Classification level '${level}' was not found in your classification definition.`
-    );
-  }
-  if (typeof retIndex !== "number") {
-    retIndex = parseInt(retIndex);
-  }
-  return [retIndex, unused];
-};
-const getRequired = (c12n, c12nDef, format, isMobile) => {
-  const returnSet = [];
-  const unused = [];
-  if (!c12n) {
-    return [returnSet.sort(), unused];
-  }
-  const partSet = c12n.toUpperCase().split("/");
-  for (const p of partSet) {
-    if (p in c12nDef.access_req_map_lts) {
-      returnSet.push(c12nDef.access_req_map_lts[p]);
-    } else if (p in c12nDef.access_req_map_stl) {
-      returnSet.push(p);
-    } else if (p in c12nDef.access_req_aliases) {
-      for (const a of c12nDef.access_req_aliases[p]) {
-        returnSet.push(a);
-      }
-    } else {
-      unused.push(p);
-    }
-  }
-  if (format === "long" && !isMobile) {
-    const out = [];
-    for (const r of returnSet) {
-      out.push(c12nDef.access_req_map_stl[r]);
-    }
-    return [out.sort(), unused];
-  }
-  return [returnSet.sort(), unused];
-};
-const getGroups = (groupParts, c12nDef, format, isMobile, autoSelect = false) => {
-  var _a, _b, _c, _d;
-  let g1Set = /* @__PURE__ */ new Set();
-  let g2Set = /* @__PURE__ */ new Set();
-  let others = /* @__PURE__ */ new Set();
-  const groups = [];
-  const subgroups = [];
-  for (const grpPart of groupParts) {
-    if (!grpPart) {
+const I = (i, s, o, p) => {
+  let u = null;
+  return s != null && i != null && (u = s.levels_map[i.toString()]), u === void 0 || u == null ? (console.error(
+    `[classificationParser] Classification level number '${i}' was not found in your classification definition.`
+  ), "INVALID") : o === "long" && !p ? s.levels_map_stl[u] : u;
+}, T = (i, s) => {
+  let o = null;
+  const [p, u, r] = (i == null ? void 0 : i.split(/\/\/(.*)/)) ?? [null, null, null], a = p == null ? void 0 : p.toUpperCase();
+  return s.levels_map[a] !== void 0 ? o = s.levels_map[a] : s.levels_map_lts[a] !== void 0 ? o = s.levels_map[s.levels_map_lts[a]] : s.levels_aliases[a] !== void 0 ? o = s.levels_map[s.levels_aliases[a]] : (o = -1, console.error(
+    `[classificationParser] Classification level '${p}' was not found in your classification definition.`
+  )), typeof o != "number" && (o = parseInt(o)), [o, u];
+}, $ = (i, s, o, p) => {
+  const u = [], r = [];
+  if (!i)
+    return [u.sort(), r];
+  const a = i.toUpperCase().split("/");
+  for (const m of a)
+    if (m in s.access_req_map_lts)
+      u.push(s.access_req_map_lts[m]);
+    else if (m in s.access_req_map_stl)
+      u.push(m);
+    else if (m in s.access_req_aliases)
+      for (const d of s.access_req_aliases[m])
+        u.push(d);
+    else
+      r.push(m);
+  if (o === "long" && !p) {
+    const m = [];
+    for (const d of u)
+      m.push(s.access_req_map_stl[d]);
+    return [m.sort(), r];
+  }
+  return [u.sort(), r];
+}, U = (i, s, o, p, u = !1) => {
+  var l, h, e, S;
+  let r = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Set();
+  const d = [], _ = [];
+  for (const t of i) {
+    if (!t)
       continue;
-    }
-    const gp = grpPart.toUpperCase();
-    if (gp.startsWith("REL ")) {
-      const tempGroups = new Set(gp.replace("REL TO ", "").replace("REL ", "").split(","));
-      for (let tg of tempGroups) {
-        tg = tg.trim();
-        for (let tsg of tg.split("/")) {
-          tsg = tsg.trim();
-          groups.push(tsg);
-        }
-      }
-    } else {
-      subgroups.push(gp);
-    }
-  }
-  for (const g of groups) {
-    if (g in c12nDef.groups_map_lts) {
-      g1Set.add(c12nDef.groups_map_lts[g]);
-    } else if (g in c12nDef.groups_map_stl) {
-      g1Set.add(g);
-    } else if (g in c12nDef.groups_aliases) {
-      for (const a of c12nDef.groups_aliases[g]) {
-        g1Set.add(a);
-      }
-    } else {
-      others.add(g);
-    }
-  }
-  for (const g of subgroups) {
-    if (g in c12nDef.subgroups_map_lts) {
-      g2Set.add(c12nDef.subgroups_map_lts[g]);
-    } else if (g in c12nDef.subgroups_map_stl) {
-      g2Set.add(g);
-    } else if (g in c12nDef.subgroups_aliases) {
-      for (const sa of c12nDef.subgroups_aliases[g]) {
-        g2Set.add(sa);
-      }
-    } else if (g in c12nDef.groups_aliases) {
-      const grps = c12nDef.groups_aliases[g];
-      if (grps.length > 1) {
-        console.error(`[classificationParser] Unclear use of alias ${g}`);
-      }
-      g1Set.add(grps[0]);
-    } else {
-      g1Set.add(g);
-      console.error(`[classificationParser] Unknown component ${g}`);
-    }
-  }
-  if (c12nDef.dynamic_groups) {
-    for (const o of others) {
-      g1Set.add(o);
-    }
-    others = /* @__PURE__ */ new Set();
-  }
-  for (const subgroup of g2Set) {
-    const required = (_b = (_a = c12nDef.params_map) == null ? void 0 : _a[subgroup]) == null ? void 0 : _b.require_group;
-    if (!!required) {
-      g1Set.add(required);
-    }
-  }
-  for (const subgroup of g2Set) {
-    const limitedToGroup = (_d = (_c = c12nDef.params_map) == null ? void 0 : _c[subgroup]) == null ? void 0 : _d.limited_to_group;
-    if (limitedToGroup !== null && limitedToGroup !== void 0) {
-      if (g1Set.size > 1 || g1Set.size === 1 && !g1Set.has(limitedToGroup)) {
-        console.error(
-          `[classificationParser] Subgroup ${subgroup} is limited to group ${limitedToGroup} (found: ${Array.from(
-            g1Set
-          ).toString()})`
-        );
+    const f = t.toUpperCase();
+    if (f.startsWith("REL ")) {
+      const g = new Set(f.replace("REL TO ", "").replace("REL ", "").split(","));
+      for (let c of g) {
+        c = c.trim();
+        for (let v of c.split("/"))
+          v = v.trim(), d.push(v);
       }
-    }
-  }
-  if (!!autoSelect && !!g1Set) {
-    g1Set = /* @__PURE__ */ new Set([...g1Set, ...c12nDef.groups_auto_select_short]);
-  }
-  if (!!autoSelect && !!g2Set) {
-    g2Set = /* @__PURE__ */ new Set([...g2Set, ...c12nDef.subgroups_auto_select_short]);
-  }
-  if (format === "long" && !isMobile) {
-    const g1Out = [];
-    for (const gr of g1Set) {
-      g1Out.push(gr in c12nDef.groups_map_stl ? c12nDef.groups_map_stl[gr] : gr);
-    }
-    const g2Out = [];
-    for (const sgr of g2Set) {
-      g2Out.push(c12nDef.subgroups_map_stl[sgr]);
-    }
-    return { groups: g1Out.sort(), subgroups: g2Out.sort(), others: Array.from(others).sort() };
-  }
-  return { groups: Array.from(g1Set).sort(), subgroups: Array.from(g2Set).sort(), others: Array.from(others).sort() };
-};
-const getParts = (c12n, c12nDef, format, isMobile) => {
-  const [lvlIdx, unused] = getLevelIndex(c12n, c12nDef);
-  const [req, unusedParts] = getRequired(unused, c12nDef, format, isMobile);
-  const { groups, subgroups, others } = getGroups(unusedParts, c12nDef, format, isMobile);
-  if (others.length > 0) {
-    console.error(`[classificationParser] Unparsable classification parts: ${others.join(",")}`);
+    } else
+      _.push(f);
+  }
+  for (const t of d)
+    if (t in s.groups_map_lts)
+      r.add(s.groups_map_lts[t]);
+    else if (t in s.groups_map_stl)
+      r.add(t);
+    else if (t in s.groups_aliases)
+      for (const f of s.groups_aliases[t])
+        r.add(f);
+    else
+      m.add(t);
+  for (const t of _)
+    if (t in s.subgroups_map_lts)
+      a.add(s.subgroups_map_lts[t]);
+    else if (t in s.subgroups_map_stl)
+      a.add(t);
+    else if (t in s.subgroups_aliases)
+      for (const f of s.subgroups_aliases[t])
+        a.add(f);
+    else if (t in s.groups_aliases) {
+      const f = s.groups_aliases[t];
+      f.length > 1 && console.error(`[classificationParser] Unclear use of alias ${t}`), r.add(f[0]);
+    } else
+      r.add(t), console.error(`[classificationParser] Unknown component ${t}`);
+  if (s.dynamic_groups) {
+    for (const t of m)
+      r.add(t);
+    m = /* @__PURE__ */ new Set();
+  }
+  for (const t of a) {
+    const f = (h = (l = s.params_map) == null ? void 0 : l[t]) == null ? void 0 : h.require_group;
+    f && r.add(f);
+  }
+  for (const t of a) {
+    const f = (S = (e = s.params_map) == null ? void 0 : e[t]) == null ? void 0 : S.limited_to_group;
+    f != null && (r.size > 1 || r.size === 1 && !r.has(f)) && console.error(
+      `[classificationParser] Subgroup ${t} is limited to group ${f} (found: ${Array.from(
+        r
+      ).toString()})`
+    );
   }
-  return {
-    lvlIdx,
-    lvl: getLevelText(lvlIdx, c12nDef, format, isMobile),
-    req,
-    groups,
-    subgroups
+  if (u && r && (r = /* @__PURE__ */ new Set([...r, ...s.groups_auto_select_short])), u && a && (a = /* @__PURE__ */ new Set([...a, ...s.subgroups_auto_select_short])), o === "long" && !p) {
+    const t = [];
+    for (const g of r)
+      t.push(g in s.groups_map_stl ? s.groups_map_stl[g] : g);
+    const f = [];
+    for (const g of a)
+      f.push(s.subgroups_map_stl[g]);
+    return { groups: t.sort(), subgroups: f.sort(), others: Array.from(m).sort() };
+  }
+  return { groups: Array.from(r).sort(), subgroups: Array.from(a).sort(), others: Array.from(m).sort() };
+}, b = (i, s, o, p) => {
+  const [u, r] = T(i, s), [a, m] = $(r, s, o, p), { groups: d, subgroups: _, others: l } = U(m, s, o, p);
+  return l.length > 0 && console.error(`[classificationParser] Unparsable classification parts: ${l.join(",")}`), {
+    lvlIdx: u,
+    lvl: I(u, s, o, p),
+    req: a,
+    groups: d,
+    subgroups: _
   };
-};
-const canSeeRequired = (user_req, req) => {
-  if (req.length <= 0) return true;
-  const userSet = new Set(user_req);
-  const reqSet = new Set(req);
-  for (const elem of reqSet) {
-    if (!userSet.has(elem)) {
-      return false;
-    }
-  }
-  return true;
-};
-const canSeeGroups = (user_groups, groups) => {
-  if (groups.length === 0) return true;
-  const groupSet = new Set(groups);
-  const userSet = new Set(user_groups);
-  for (const elem of groupSet) {
-    if (userSet.has(elem)) {
-      return true;
-    }
-  }
-  return false;
-};
-const normalizedClassification = (parts, c12nDef, format, isMobile, skipAutoSelect = false) => {
-  var _a, _b, _c, _d, _e, _f;
-  if (!c12nDef.enforce || !!c12nDef.invalid_mode) return c12nDef.UNRESTRICTED;
-  const longFormat = format === "short" || !!isMobile ? false : true;
-  const groupDelim = !!longFormat ? "REL TO " : "REL ";
-  const { lvlIdx, lvl } = parts;
-  let { groups, subgroups, req } = parts;
-  req = req.map((r) => {
-    if (!!longFormat) {
-      return c12nDef.access_req_map_stl[r] || r;
-    }
-    return c12nDef.access_req_map_lts[r] || r;
-  });
-  groups = groups.map((g) => {
-    if (!!longFormat) {
-      return c12nDef.groups_map_stl[g] || g;
-    }
-    return c12nDef.groups_map_lts[g] || g;
-  });
-  subgroups = subgroups.map((g) => {
-    if (!!longFormat) {
-      return c12nDef.subgroups_map_stl[g] || g;
-    }
-    return c12nDef.subgroups_map_lts[g] || g;
-  });
-  let out = lvl;
-  let requiredLvlIdx = 0;
-  for (const r of req) {
-    const rl = !!((_b = (_a = c12nDef.params_map) == null ? void 0 : _a[r]) == null ? void 0 : _b.require_lvl) ? c12nDef.params_map[r].require_lvl : 0;
-    requiredLvlIdx = Math.max(requiredLvlIdx, rl);
-  }
-  out = getLevelText(Math.max(lvlIdx, requiredLvlIdx), c12nDef, format, isMobile);
-  const reqGrp = /* @__PURE__ */ new Set();
-  for (const r of req) {
-    if (!!((_c = c12nDef.params_map[r]) == null ? void 0 : _c.is_required_group)) {
-      reqGrp.add(r);
-    }
-  }
-  const tempReq = Array.from(new Set([...req].filter((x) => !reqGrp.has(x))));
-  if (tempReq.length > 0) {
-    out += "//" + tempReq.sort().join("/");
-  }
-  if (reqGrp.size > 0) {
-    out += "//" + Array.from(reqGrp).sort().join("/");
-  }
-  let tempSubGroups = [...subgroups];
-  if (!!longFormat) {
-    if (subgroups.length > 0 && c12nDef.subgroups_auto_select.length > 0 && !skipAutoSelect) {
-      tempSubGroups = Array.from(/* @__PURE__ */ new Set([...subgroups, ...c12nDef.subgroups_auto_select])).sort();
-    }
-  } else {
-    if (subgroups.length > 0 && c12nDef.subgroups_auto_select_short.length > 0 && !skipAutoSelect) {
-      tempSubGroups = Array.from(/* @__PURE__ */ new Set([...subgroups, ...c12nDef.subgroups_auto_select_short])).sort();
-    }
-  }
-  let tempGroups = [];
-  for (const sg of tempSubGroups) {
-    const rGrp = (_d = c12nDef.params_map[sg]) == null ? void 0 : _d.require_group;
-    if (!!rGrp) {
-      tempGroups.push(rGrp);
-    }
-    const limToGrp = (_e = c12nDef.params_map[sg]) == null ? void 0 : _e.limited_to_group;
-    if (!!limToGrp) {
-      if (limToGrp in tempGroups) {
-        tempGroups = [limToGrp];
-      } else {
-        tempGroups = [];
-      }
-    }
-  }
-  for (const g of tempGroups) {
-    if (!!longFormat) {
-      groups.push(c12nDef.groups_map_stl[g] || g);
-    } else {
-      groups.push(c12nDef.groups_map_lts[g] || g);
-    }
-  }
-  groups = Array.from(new Set(groups));
-  if (!!longFormat) {
-    if (groups.length > 0 && c12nDef.groups_auto_select.length > 0 && !skipAutoSelect) {
-      groups = Array.from(/* @__PURE__ */ new Set([...groups, ...c12nDef.groups_auto_select])).sort();
-    }
-  } else {
-    if (groups.length > 0 && c12nDef.groups_auto_select_short.length > 0 && !skipAutoSelect) {
-      groups = Array.from(/* @__PURE__ */ new Set([...groups, ...c12nDef.groups_auto_select_short])).sort();
-    }
-  }
-  if (groups.length > 0) {
-    groups = groups.sort();
-    out += reqGrp.size > 0 ? "/" : "//";
-    if (groups.length === 1) {
-      const grp = groups[0];
-      const displayName = ((_f = c12nDef.params_map[grp]) == null ? void 0 : _f.solitary_display_name) || grp;
-      out += displayName !== grp ? displayName : groupDelim + grp;
-    } else {
-      if (!longFormat) {
-        for (const [alias, values] of Object.entries(c12nDef.groups_aliases)) {
-          if (values.length > 1) {
-            if (JSON.stringify(values.sort()) === JSON.stringify(groups)) {
-              groups = [alias];
-            }
-          }
-        }
-      }
-      out += groupDelim + groups.sort().join(", ");
-    }
-  }
-  if (tempSubGroups.length > 0) {
-    if (groups.length > 0 || reqGrp.size > 0) {
-      out += "/";
+}, z = (i, s) => {
+  if (s.length <= 0) return !0;
+  const o = new Set(i), p = new Set(s);
+  for (const u of p)
+    if (!o.has(u))
+      return !1;
+  return !0;
+}, R = (i, s) => {
+  if (s.length === 0) return !0;
+  const o = new Set(s), p = new Set(i);
+  for (const u of o)
+    if (p.has(u))
+      return !0;
+  return !1;
+}, x = (i, s, o, p, u = !1) => {
+  var v, w, y, L, A, C;
+  if (!s.enforce || s.invalid_mode) return s.UNRESTRICTED;
+  const r = !(o === "short" || p), a = r ? "REL TO " : "REL ", { lvlIdx: m, lvl: d } = i;
+  let { groups: _, subgroups: l, req: h } = i;
+  h = h.map((n) => r ? s.access_req_map_stl[n] || n : s.access_req_map_lts[n] || n), _ = _.map((n) => r ? s.groups_map_stl[n] || n : s.groups_map_lts[n] || n), l = l.map((n) => r ? s.subgroups_map_stl[n] || n : s.subgroups_map_lts[n] || n);
+  let e = d, S = 0;
+  for (const n of h) {
+    const q = (w = (v = s.params_map) == null ? void 0 : v[n]) != null && w.require_lvl ? s.params_map[n].require_lvl : 0;
+    S = Math.max(S, q);
+  }
+  e = I(Math.max(m, S), s, o, p);
+  const t = /* @__PURE__ */ new Set();
+  for (const n of h)
+    (y = s.params_map[n]) != null && y.is_required_group && t.add(n);
+  const f = Array.from(new Set([...h].filter((n) => !t.has(n))));
+  f.length > 0 && (e += "//" + f.sort().join("/")), t.size > 0 && (e += "//" + Array.from(t).sort().join("/"));
+  let g = [...l];
+  r ? l.length > 0 && s.subgroups_auto_select.length > 0 && !u && (g = Array.from(/* @__PURE__ */ new Set([...l, ...s.subgroups_auto_select])).sort()) : l.length > 0 && s.subgroups_auto_select_short.length > 0 && !u && (g = Array.from(/* @__PURE__ */ new Set([...l, ...s.subgroups_auto_select_short])).sort());
+  let c = [];
+  for (const n of g) {
+    const q = (L = s.params_map[n]) == null ? void 0 : L.require_group;
+    q && c.push(q);
+    const P = (A = s.params_map[n]) == null ? void 0 : A.limited_to_group;
+    P && (P in c ? c = [P] : c = []);
+  }
+  for (const n of c)
+    r ? _.push(s.groups_map_stl[n] || n) : _.push(s.groups_map_lts[n] || n);
+  if (_ = Array.from(new Set(_)), r ? _.length > 0 && s.groups_auto_select.length > 0 && !u && (_ = Array.from(/* @__PURE__ */ new Set([..._, ...s.groups_auto_select])).sort()) : _.length > 0 && s.groups_auto_select_short.length > 0 && !u && (_ = Array.from(/* @__PURE__ */ new Set([..._, ...s.groups_auto_select_short])).sort()), _.length > 0)
+    if (_ = _.sort(), e += t.size > 0 ? "/" : "//", _.length === 1) {
+      const n = _[0], q = ((C = s.params_map[n]) == null ? void 0 : C.solitary_display_name) || n;
+      e += q !== n ? q : a + n;
     } else {
-      out += "//";
-    }
-    out += tempSubGroups.sort().join("/");
-  }
-  return out;
-};
-const levelList = (c12nDef) => {
-  const out = [];
-  for (const i in c12nDef.levels_map) {
-    if (!isNaN(parseInt(i))) {
-      out.push(c12nDef.levels_map[i]);
-    }
-  }
-  return out;
-};
-const defaultClassificationValidator = {
-  disabled: defaultDisabled,
-  parts: defaultParts
-};
-const applyClassificationRules = (parts, c12nDef, format, isMobile, userClassification = false) => {
-  const longFormat = format === "short" || !!isMobile ? false : true;
-  const requireLvl = {};
-  const limitedToGroup = {};
-  const requireGroup = {};
-  const partsToCheck = ["req", "groups", "subgroups"];
-  const retParts = { ...parts };
-  const disabledList = {
+      if (!r)
+        for (const [n, q] of Object.entries(s.groups_aliases))
+          q.length > 1 && JSON.stringify(q.sort()) === JSON.stringify(_) && (_ = [n]);
+      e += a + _.sort().join(", ");
+    }
+  return g.length > 0 && (_.length > 0 || t.size > 0 ? e += "/" : e += "//", e += g.sort().join("/")), e;
+}, j = (i) => {
+  const s = [];
+  for (const o in i.levels_map)
+    isNaN(parseInt(o)) || s.push(i.levels_map[o]);
+  return s;
+}, F = {
+  disabled: N,
+  parts: E
+}, J = (i, s, o, p, u = !1) => {
+  const r = !(o === "short" || p), a = {}, m = {}, d = {}, _ = ["req", "groups", "subgroups"], l = { ...i }, h = {
     levels: [],
     groups: []
   };
-  for (const item in c12nDef.params_map) {
-    if ({}.hasOwnProperty.call(c12nDef.params_map, item)) {
-      const data = c12nDef.params_map[item];
-      if ("require_lvl" in data) {
-        requireLvl[item] = data.require_lvl;
-      }
-      if ("limited_to_group" in data) {
-        limitedToGroup[item] = data.limited_to_group;
-      }
-      if ("require_group" in data) {
-        requireGroup[item] = data.require_group;
-      }
-    }
-  }
-  for (const partName in partsToCheck) {
-    if ({}.hasOwnProperty.call(partsToCheck, partName)) {
-      const part = retParts[partsToCheck[partName]];
-      for (const value of part) {
-        let triggerAutoSelect = false;
-        if (value) {
-          if (value in requireLvl) {
-            if (retParts.lvlIdx < requireLvl[value]) {
-              retParts.lvlIdx = requireLvl[value];
-              retParts.lvl = getLevelText(requireLvl[value], c12nDef, format, isMobile);
-            }
-            const levels = levelList(c12nDef);
-            for (const l of levels) {
-              if (c12nDef.levels_map[l] < requireLvl[value]) {
-                disabledList.levels.push(l);
-              }
-            }
+  for (const e in s.params_map)
+    if ({}.hasOwnProperty.call(s.params_map, e)) {
+      const S = s.params_map[e];
+      "require_lvl" in S && (a[e] = S.require_lvl), "limited_to_group" in S && (m[e] = S.limited_to_group), "require_group" in S && (d[e] = S.require_group);
+    }
+  for (const e in _)
+    if ({}.hasOwnProperty.call(_, e)) {
+      const S = l[_[e]];
+      for (const t of S) {
+        let f = !1;
+        if (t) {
+          if (t in a) {
+            l.lvlIdx < a[t] && (l.lvlIdx = a[t], l.lvl = I(a[t], s, o, p));
+            const g = j(s);
+            for (const c of g)
+              s.levels_map[c] < a[t] && h.levels.push(c);
           }
-          if (value in requireGroup) {
-            const valueLong = c12nDef.groups_map_stl[requireGroup[value]] || requireGroup[value];
-            const valueShort = c12nDef.groups_map_lts[requireGroup[value]] || requireGroup[value];
-            if (!retParts.groups.includes(valueLong) && !retParts.groups.includes(valueShort)) {
-              retParts.groups.push(valueShort);
-              for (const group of c12nDef.groups_auto_select) {
-                const gLong = c12nDef.groups_map_stl[group] || group;
-                const gShort = c12nDef.groups_map_lts[group] || group;
-                if (!retParts.groups.includes(gShort) && !retParts.groups.includes(gLong)) {
-                  retParts.groups.push(group);
-                }
+          if (t in d) {
+            const g = s.groups_map_stl[d[t]] || d[t], c = s.groups_map_lts[d[t]] || d[t];
+            if (!l.groups.includes(g) && !l.groups.includes(c)) {
+              l.groups.push(c);
+              for (const v of s.groups_auto_select) {
+                const w = s.groups_map_stl[v] || v, y = s.groups_map_lts[v] || v;
+                !l.groups.includes(y) && !l.groups.includes(w) && l.groups.push(v);
               }
             }
           }
-          if (value in limitedToGroup) {
-            for (const gShort in c12nDef.groups_map_stl) {
-              const lgShort = c12nDef.groups_map_lts[limitedToGroup[value]] || limitedToGroup[value];
-              if (gShort !== lgShort) {
-                const gLong = c12nDef.groups_map_stl[gShort];
-                disabledList.groups.push(gShort);
-                if (retParts.groups.includes(gShort)) {
-                  retParts.groups.splice(retParts.groups.indexOf(gShort), 1);
-                } else if (retParts.groups.includes(gLong)) {
-                  retParts.groups.splice(retParts.groups.indexOf(gLong), 1);
-                }
+          if (t in m)
+            for (const g in s.groups_map_stl) {
+              const c = s.groups_map_lts[m[t]] || m[t];
+              if (g !== c) {
+                const v = s.groups_map_stl[g];
+                h.groups.push(g), l.groups.includes(g) ? l.groups.splice(l.groups.indexOf(g), 1) : l.groups.includes(v) && l.groups.splice(l.groups.indexOf(v), 1);
               }
             }
-          }
-          if (!userClassification && partsToCheck[partName] === "groups") {
-            triggerAutoSelect = true;
-          }
+          !u && _[e] === "groups" && (f = !0);
         }
-        if (triggerAutoSelect) {
-          for (const group of c12nDef.groups_auto_select) {
-            const gLong = c12nDef.groups_map_stl[group] || group;
-            const gShort = c12nDef.groups_map_lts[group] || group;
-            if (!retParts.groups.includes(gLong) && !retParts.groups.includes(gShort)) {
-              retParts.groups.push(group);
-            }
+        if (f)
+          for (const g of s.groups_auto_select) {
+            const c = s.groups_map_stl[g] || g, v = s.groups_map_lts[g] || g;
+            !l.groups.includes(c) && !l.groups.includes(v) && l.groups.push(g);
           }
-        }
       }
     }
-  }
-  retParts.req = retParts.req.sort().map((r) => {
-    if (!!longFormat) {
-      return c12nDef.access_req_map_stl[r] || r;
-    }
-    return c12nDef.access_req_map_lts[r] || r;
-  });
-  retParts.groups = retParts.groups.sort().map((g) => {
-    if (!!longFormat) {
-      return c12nDef.groups_map_stl[g] || g;
-    }
-    return c12nDef.groups_map_lts[g] || g;
-  });
-  retParts.subgroups = retParts.subgroups.sort().map((sg) => {
-    if (!!longFormat) {
-      return c12nDef.subgroups_map_stl[sg] || sg;
-    }
-    return c12nDef.subgroups_map_lts[sg] || sg;
-  });
-  disabledList.groups = disabledList.groups.sort().map((g) => {
-    if (!!longFormat) {
-      return c12nDef.groups_map_stl[g] || g;
-    }
-    return c12nDef.groups_map_lts[g] || g;
-  });
-  disabledList.levels = disabledList.levels.sort().map((l) => {
-    if (!!longFormat) {
-      return c12nDef.levels_map_stl[l] || l;
-    }
-    return c12nDef.levels_map_lts[l] || l;
-  });
-  if (!!longFormat) {
-    retParts.lvl = c12nDef.levels_map_stl[retParts.lvl] || retParts.lvl;
-  } else {
-    retParts.lvl = c12nDef.levels_map_lts[retParts.lvl] || retParts.lvl;
-  }
-  return {
-    disabled: disabledList,
-    parts: retParts
+  return l.req = l.req.sort().map((e) => r ? s.access_req_map_stl[e] || e : s.access_req_map_lts[e] || e), l.groups = l.groups.sort().map((e) => r ? s.groups_map_stl[e] || e : s.groups_map_lts[e] || e), l.subgroups = l.subgroups.sort().map((e) => r ? s.subgroups_map_stl[e] || e : s.subgroups_map_lts[e] || e), h.groups = h.groups.sort().map((e) => r ? s.groups_map_stl[e] || e : s.groups_map_lts[e] || e), h.levels = h.levels.sort().map((e) => r ? s.levels_map_stl[e] || e : s.levels_map_lts[e] || e), r ? l.lvl = s.levels_map_stl[l.lvl] || l.lvl : l.lvl = s.levels_map_lts[l.lvl] || l.lvl, {
+    disabled: h,
+    parts: l
   };
-};
-const getMaxGroups = (grps1, grps2) => {
-  let groups = /* @__PURE__ */ new Set();
-  if (grps1.length > 0 && grps2.length > 0) {
-    const g2 = new Set(grps2);
-    groups = new Set([...grps1].filter((x) => g2.has(x)));
-  } else {
-    groups = /* @__PURE__ */ new Set([...grps1, ...grps2]);
-  }
-  if (grps1.length > 0 && grps2.length > 0 && groups.size <= 0) {
-    groups = /* @__PURE__ */ new Set([...grps1, ...grps2]);
-    console.error(
-      `[classificationParser] Could not find any intersection between the groups. ${grps1.toString()} & ${grps2.toString()}`
-    );
-  }
-  return Array.from(groups);
-};
-const getMaxClassification = (c12n_1, c12n_2, c12nDef, format, isMobile) => {
-  if (!c12nDef.enforce || !!c12nDef.invalid_mode) {
-    const noEnforceParts = getParts(c12nDef.UNRESTRICTED, c12nDef, format, isMobile);
-    return normalizedClassification(noEnforceParts, c12nDef, format, isMobile);
-  }
-  const c12n1Parts = getParts(c12n_1, c12nDef, format, isMobile);
-  const c12n2Parts = getParts(c12n_2, c12nDef, format, isMobile);
-  if (!c12n_1) {
-    return normalizedClassification(c12n2Parts, c12nDef, format, isMobile);
-  }
-  if (!c12n_2) {
-    return normalizedClassification(c12n1Parts, c12nDef, format, isMobile);
-  }
-  const req = Array.from(/* @__PURE__ */ new Set([...c12n1Parts.req, ...c12n2Parts.req]));
-  const groups = getMaxGroups(c12n1Parts.groups, c12n2Parts.groups);
-  const subgroups = getMaxGroups(c12n1Parts.subgroups, c12n2Parts.subgroups);
-  const lvlIdx = Math.max(c12n1Parts.lvlIdx, c12n2Parts.lvlIdx);
-  const out = {
-    lvlIdx,
-    lvl: getLevelText(lvlIdx, c12nDef, format, isMobile),
-    req,
-    groups,
-    subgroups
+}, G = (i, s) => {
+  let o = /* @__PURE__ */ new Set();
+  if (i.length > 0 && s.length > 0) {
+    const p = new Set(s);
+    o = new Set([...i].filter((u) => p.has(u)));
+  } else
+    o = /* @__PURE__ */ new Set([...i, ...s]);
+  return i.length > 0 && s.length > 0 && o.size <= 0 && (o = /* @__PURE__ */ new Set([...i, ...s]), console.error(
+    `[classificationParser] Could not find any intersection between the groups. ${i.toString()} & ${s.toString()}`
+  )), Array.from(o);
+}, V = (i, s, o, p, u) => {
+  if (!o.enforce || o.invalid_mode) {
+    const e = b(o.UNRESTRICTED, o, p, u);
+    return x(e, o, p, u);
+  }
+  const r = b(i, o, p, u), a = b(s, o, p, u);
+  if (!i)
+    return x(a, o, p, u);
+  if (!s)
+    return x(r, o, p, u);
+  const m = Array.from(/* @__PURE__ */ new Set([...r.req, ...a.req])), d = G(r.groups, a.groups), _ = G(r.subgroups, a.subgroups), l = Math.max(r.lvlIdx, a.lvlIdx), h = {
+    lvlIdx: l,
+    lvl: I(l, o, p, u),
+    req: m,
+    groups: d,
+    subgroups: _
   };
-  return normalizedClassification(out, c12nDef, format, isMobile);
-};
-const isAccessible = (user_c12n, c12n, c12nDef, enforce = false, ignoreInvalid = true) => {
-  if (!!c12nDef.invalid_mode) return false;
-  if (!enforce) return true;
-  if (!c12n) return true;
+  return x(h, o, p, u);
+}, W = (i, s, o, p = !1, u = !0) => {
+  if (o.invalid_mode) return !1;
+  if (!p || !s) return !0;
   try {
-    const userParts = getParts(user_c12n, c12nDef, "long", false);
-    const parts = getParts(c12n, c12nDef, "long", false);
-    if (Number(userParts.lvlIdx) >= Number(parts.lvlIdx)) {
-      if (!canSeeRequired(userParts.req, parts.req)) return false;
-      if (!canSeeGroups(userParts.groups, parts.groups)) return false;
-      if (!canSeeGroups(userParts.subgroups, parts.subgroups)) return false;
-      return true;
-    }
-    return false;
-  } catch (e) {
-    if (e instanceof InvalidClassification) {
-      if (!!ignoreInvalid) {
-        return false;
-      }
-    }
-    throw e;
+    const r = b(i, o, "long", !1), a = b(s, o, "long", !1);
+    return Number(r.lvlIdx) >= Number(a.lvlIdx) ? !(!z(r.req, a.req) || !R(r.groups, a.groups) || !R(r.subgroups, a.subgroups)) : !1;
+  } catch (r) {
+    if (r instanceof O && u)
+      return !1;
+    throw r;
   }
 };
 export {
-  InvalidClassification,
-  applyClassificationRules,
-  canSeeGroups,
-  canSeeRequired,
-  defaultClassificationValidator,
-  defaultDisabled,
-  defaultParts,
-  getLevelText,
-  getMaxClassification,
-  getParts,
-  isAccessible,
-  normalizedClassification
+  O as InvalidClassification,
+  J as applyClassificationRules,
+  R as canSeeGroups,
+  z as canSeeRequired,
+  F as defaultClassificationValidator,
+  N as defaultDisabled,
+  E as defaultParts,
+  I as getLevelText,
+  V as getMaxClassification,
+  b as getParts,
+  W as isAccessible,
+  x as normalizedClassification
 };