@cccsaurora/clue-ui 1.2.3 → 1.2.4-dev.278

package/utils/classificationParser.js

@@ -1,290 +1,553 @@
-const E = {
+const defaultParts = {
   lvlIdx: 0,
   lvl: "",
   req: [],
   groups: [],
   subgroups: []
-}, N = {
+};
+const defaultDisabled = {
   groups: [],
   levels: []
 };
-class O extends Error {
+class InvalidClassification extends Error {
 }
-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)
+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) {
       continue;
-    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);
+    }
+    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
-      _.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()})`
-    );
+    } 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()})`
+        );
+      }
+    }
+  }
+  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(",")}`);
   }
-  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: _
+  return {
+    lvlIdx,
+    lvl: getLevelText(lvlIdx, c12nDef, format, isMobile),
+    req,
+    groups,
+    subgroups
   };
-}, 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;
+};
+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 += "/";
     } else {
-      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 = {
+      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 = {
     levels: [],
     groups: []
   };
-  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);
+  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);
+              }
+            }
           }
-          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 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 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 (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);
+                }
               }
             }
-          !u && _[e] === "groups" && (f = !0);
+          }
+          if (!userClassification && partsToCheck[partName] === "groups") {
+            triggerAutoSelect = true;
+          }
         }
-        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);
+        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);
+            }
           }
+        }
       }
     }
-  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
+  }
+  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
   };
-}, 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: _
+};
+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
   };
-  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;
+  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;
   try {
-    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;
+    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;
   }
 };
 export {
-  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
+  InvalidClassification,
+  applyClassificationRules,
+  canSeeGroups,
+  canSeeRequired,
+  defaultClassificationValidator,
+  defaultDisabled,
+  defaultParts,
+  getLevelText,
+  getMaxClassification,
+  getParts,
+  isAccessible,
+  normalizedClassification
 };