@vltpkg/cli-js 1.0.0-rc.33 → 1.0.0-rc.34

package/{chunk-VGWEB64T.js → chunk-E5YE7UTZ.js}

@@ -5636,12 +5636,13 @@ var unescapeDots = (query) => query.replaceAll("\\.", ".");
 var pseudoCleanUpNeeded = /* @__PURE__ */ new Set([
   ":published",
   ":score",
-  ":malware",
   ":severity",
   ":sev",
   ":squat",
   ":semver",
-  ":v"
+  ":v",
+  ":vuln",
+  ":vulnerable"
 ]);
 var hasParamsToEscape = (node) => pseudoCleanUpNeeded.has(node.value);
 var parse2 = (query) => {
@@ -6661,155 +6662,21 @@ var link = async (state) => {
 };
 
 // ../../src/query/src/pseudo/malware.ts
-var kindsMap2 = /* @__PURE__ */ new Map([
-  ["critical", "malware"],
-  ["high", "gptMalware"],
-  ["medium", "gptSecurity"],
-  ["low", "gptAnomaly"],
-  ["0", "malware"],
-  ["1", "gptMalware"],
-  ["2", "gptSecurity"],
-  ["3", "gptAnomaly"]
-]);
-var kindLevelMap = /* @__PURE__ */ new Map([
-  ["critical", 0],
-  ["high", 1],
-  ["medium", 2],
-  ["low", 3],
-  ["0", 0],
-  ["1", 1],
-  ["2", 2],
-  ["3", 3]
-]);
-var kinds2 = new Set(kindsMap2.keys());
-var isMalwareKind = (value) => kinds2.has(value);
-var asMalwareKind = (value) => {
-  if (!isMalwareKind(value)) {
-    throw error("Expected a valid malware kind", {
-      found: value,
-      validOptions: Array.from(kinds2)
-    });
-  }
-  return value;
-};
-var parseInternals7 = (nodes) => {
-  if (!nodes[0]) {
-    return { kind: void 0, comparator: void 0 };
-  }
-  const selectorNode = asPostcssNodeWithChildren(nodes[0]);
-  if (!selectorNode.nodes[0]) {
-    return { kind: void 0, comparator: void 0 };
-  }
-  let kindValue = "";
-  let comparator = void 0;
-  let kind;
-  if (isStringNode(selectorNode.nodes[0])) {
-    kindValue = removeQuotes(
-      asStringNode(selectorNode.nodes[0]).value
-    );
-  } else if (isTagNode(selectorNode.nodes[0])) {
-    kindValue = asTagNode(selectorNode.nodes[0]).value;
-  }
-  if (kindValue.startsWith(">=")) {
-    comparator = ">=";
-    kindValue = kindValue.substring(2);
-  } else if (kindValue.startsWith("<=")) {
-    comparator = "<=";
-    kindValue = kindValue.substring(2);
-  } else if (kindValue.startsWith(">")) {
-    comparator = ">";
-    kindValue = kindValue.substring(1);
-  } else if (kindValue.startsWith("<")) {
-    comparator = "<";
-    kindValue = kindValue.substring(1);
-  }
-  if (!comparator) {
-    kind = asMalwareKind(kindValue);
-  } else {
-    if (isMalwareKind(kindValue)) {
-      kind = kindValue;
-    } else {
-      throw error(
-        "Expected a valid malware kind or number between 0-3",
-        {
-          found: kindValue
-        }
-      );
-    }
-  }
-  return { kind, comparator };
-};
+var malwareAlertTypes = /* @__PURE__ */ new Set(["malware", "gptMalware"]);
 var malware = async (state) => {
   assertSecurityArchive(state, "malware");
-  let internals;
-  try {
-    internals = parseInternals7(
-      asPostcssNodeWithChildren(state.current).nodes
+  const currentNode = asPostcssNodeWithChildren(state.current);
+  if (currentNode.nodes.length > 0) {
+    throw error(
+      ":malware selector does not accept parameters. Use :vuln(<severity>) for severity-based filtering."
     );
-  } catch (err) {
-    throw error("Failed to parse :malware selector", { cause: err });
-  }
-  const { kind, comparator } = internals;
-  const alertName = comparator ? void 0 : kindsMap2.get(kind);
-  for (const node of state.partial.nodes) {
-    const report = state.securityArchive.get(node.id);
-    if (!report?.alerts || report.alerts.length === 0) {
-      removeNode(state, node);
-    }
   }
   for (const node of state.partial.nodes) {
     const report = state.securityArchive.get(node.id);
-    let exclude = true;
-    if (report) {
-      if (kind === void 0 && comparator === void 0) {
-        exclude = !report.alerts.some(
-          (alert) => alert.type === "malware" || alert.type === "gptMalware" || alert.type === "gptSecurity"
-        );
-      } else if (comparator) {
-        const kindLevel = kindLevelMap.get(kind);
-        if (kindLevel == null) break;
-        for (const alert of report.alerts) {
-          const alertType = alert.type;
-          const currentAlertLevelKey = [...kindsMap2.entries()].find(
-            ([_, alertValue]) => alertValue === alertType
-          )?.[0];
-          if (currentAlertLevelKey) {
-            const currentAlertLevel = kindLevelMap.get(
-              currentAlertLevelKey
-            );
-            if (currentAlertLevel == null) continue;
-            switch (comparator) {
-              case ">":
-                if (currentAlertLevel > kindLevel) {
-                  exclude = false;
-                }
-                break;
-              case "<":
-                if (currentAlertLevel < kindLevel) {
-                  exclude = false;
-                }
-                break;
-              case ">=":
-                if (currentAlertLevel >= kindLevel) {
-                  exclude = false;
-                }
-                break;
-              case "<=":
-                if (currentAlertLevel <= kindLevel) {
-                  exclude = false;
-                }
-                break;
-            }
-            if (!exclude) break;
-          }
-        }
-      } else {
-        exclude = !report.alerts.some(
-          (alert) => alert.type === alertName
-        );
-      }
-    }
-    if (exclude) {
+    const hasMalware = report?.alerts.some(
+      (alert) => malwareAlertTypes.has(alert.type)
+    );
+    if (!hasMalware) {
       removeNode(state, node);
     }
   }
@@ -6864,7 +6731,7 @@ var optional = async (state) => {
 };
 
 // ../../src/query/src/pseudo/outdated.ts
-var kinds3 = /* @__PURE__ */ new Set([
+var kinds2 = /* @__PURE__ */ new Set([
   "any",
   "major",
   "minor",
@@ -6872,12 +6739,12 @@ var kinds3 = /* @__PURE__ */ new Set([
   "in-range",
   "out-of-range"
 ]);
-var isOutdatedKind = (value) => kinds3.has(value);
+var isOutdatedKind = (value) => kinds2.has(value);
 var asOutdatedKind = (value) => {
   if (!isOutdatedKind(value)) {
     throw error("Expected a valid outdated kind", {
       found: value,
-      validOptions: Array.from(kinds3)
+      validOptions: Array.from(kinds2)
     });
   }
   return value;
@@ -6908,7 +6775,7 @@ var retrieveRemoteVersions = async (node, signal) => {
   const packument = await response.json();
   return Object.keys(packument.versions).sort(compare);
 };
-var parseInternals8 = (nodes) => {
+var parseInternals7 = (nodes) => {
   let kind = "any";
   if (isStringNode(asPostcssNodeWithChildren(nodes[0]).nodes[0])) {
     kind = asOutdatedKind(
@@ -7002,7 +6869,7 @@ var queueNode2 = async (state, node, kind) => {
 var outdated = async (state) => {
   let internals;
   try {
-    internals = parseInternals8(
+    internals = parseInternals7(
       asPostcssNodeWithChildren(state.current).nodes
     );
   } catch (err) {
@@ -7185,7 +7052,7 @@ var retrieveRemoteDate = async (node, signal) => {
   const res = packument.time?.[node.version];
   return res;
 };
-var parseInternals9 = (nodes) => {
+var parseInternals8 = (nodes) => {
   let value = "";
   if (isStringNode(asPostcssNodeWithChildren(nodes[0]).nodes[0])) {
     value = removeQuotes(
@@ -7259,7 +7126,7 @@ var queueNode3 = async (state, node, relativeDate, comparator) => {
 var published = async (state) => {
   let internals;
   try {
-    internals = parseInternals9(
+    internals = parseInternals8(
       asPostcssNodeWithChildren(state.current).nodes
     );
   } catch (err) {
@@ -7364,7 +7231,7 @@ var scanned = async (state) => {
 };
 
 // ../../src/query/src/pseudo/score.ts
-var kinds4 = /* @__PURE__ */ new Set([
+var kinds3 = /* @__PURE__ */ new Set([
   "overall",
   "license",
   "maintenance",
@@ -7373,17 +7240,17 @@ var kinds4 = /* @__PURE__ */ new Set([
   "vulnerability",
   void 0
 ]);
-var isScoreKind = (value) => kinds4.has(value);
+var isScoreKind = (value) => kinds3.has(value);
 var asScoreKind = (value) => {
   if (!isScoreKind(value)) {
     throw error("Expected a valid score kind", {
       found: value,
-      validOptions: Array.from(kinds4)
+      validOptions: Array.from(kinds3)
     });
   }
   return value;
 };
-var parseInternals10 = (nodes) => {
+var parseInternals9 = (nodes) => {
   let rateStr = "";
   let comparator = "=";
   let kind = "overall";
@@ -7438,7 +7305,7 @@ var score = async (state) => {
   assertSecurityArchive(state, "score");
   let internals;
   try {
-    internals = parseInternals10(
+    internals = parseInternals9(
       asPostcssNodeWithChildren(state.current).nodes
     );
   } catch (err) {
@@ -7552,7 +7419,7 @@ var semverRangeFunctions = /* @__PURE__ */ new Map([
   ["intersects", intersects],
   ["subset", subset]
 ]);
-var parseInternals11 = (nodes, loose) => {
+var parseInternals10 = (nodes, loose) => {
   let semverValue = "";
   try {
     semverValue = removeQuotes(
@@ -7635,7 +7502,7 @@ var parseInternals11 = (nodes, loose) => {
 var semverParser = async (state) => {
   let internals;
   try {
-    internals = parseInternals11(
+    internals = parseInternals10(
       asPostcssNodeWithChildren(state.current).nodes,
       !!state.loose
     );
@@ -7702,7 +7569,7 @@ var semverParser = async (state) => {
 };
 
 // ../../src/query/src/pseudo/severity.ts
-var kindsMap3 = /* @__PURE__ */ new Map([
+var kindsMap2 = /* @__PURE__ */ new Map([
   ["critical", "criticalCVE"],
   ["high", "cve"],
   ["medium", "potentialVulnerability"],
@@ -7712,7 +7579,7 @@ var kindsMap3 = /* @__PURE__ */ new Map([
   ["2", "potentialVulnerability"],
   ["3", "mildCVE"]
 ]);
-var kindLevelMap2 = /* @__PURE__ */ new Map([
+var kindLevelMap = /* @__PURE__ */ new Map([
   ["critical", 0],
   ["high", 1],
   ["medium", 2],
@@ -7722,9 +7589,9 @@ var kindLevelMap2 = /* @__PURE__ */ new Map([
   ["2", 2],
   ["3", 3]
 ]);
-var kinds5 = new Set(kindsMap3.keys());
-var isSeverityKind = (value) => kinds5.has(value);
-var parseInternals12 = (nodes) => {
+var kinds4 = new Set(kindsMap2.keys());
+var isSeverityKind = (value) => kinds4.has(value);
+var parseInternals11 = (nodes) => {
   let kind;
   let comparator;
   if (nodes.length === 0) {
@@ -7771,7 +7638,7 @@ var severity = async (state) => {
   assertSecurityArchive(state, "severity");
   let internals;
   try {
-    internals = parseInternals12(
+    internals = parseInternals11(
       asPostcssNodeWithChildren(state.current).nodes
     );
   } catch (err) {
@@ -7789,15 +7656,15 @@ var severity = async (state) => {
     let exclude = true;
     if (report) {
       if (comparator) {
-        const kindLevel = kindLevelMap2.get(kind);
+        const kindLevel = kindLevelMap.get(kind);
         if (!kindLevel) break;
         for (const alert of report.alerts) {
           const alertType = alert.type;
-          const currentAlertLevelKey = [...kindsMap3.entries()].find(
+          const currentAlertLevelKey = [...kindsMap2.entries()].find(
             ([_, alertValue]) => alertValue === alertType
           )?.[0];
           if (currentAlertLevelKey) {
-            const currentAlertLevel = kindLevelMap2.get(
+            const currentAlertLevel = kindLevelMap.get(
               currentAlertLevelKey
             );
             if (currentAlertLevel == null) continue;
@@ -7826,7 +7693,7 @@ var severity = async (state) => {
           }
         }
       } else {
-        const alertName = kindsMap3.get(kind);
+        const alertName = kindsMap2.get(kind);
         exclude = !report.alerts.some(
           (alert) => alert.type === alertName
         );
@@ -7847,22 +7714,22 @@ var shrinkwrap = createSecuritySelectorFilter(
 );
 
 // ../../src/query/src/pseudo/squat.ts
-var kindsMap4 = /* @__PURE__ */ new Map([
+var kindsMap3 = /* @__PURE__ */ new Map([
   ["critical", "didYouMean"],
   ["medium", "gptDidYouMean"],
   ["0", "didYouMean"],
   ["2", "gptDidYouMean"],
   [void 0, void 0]
 ]);
-var kindLevelMap3 = /* @__PURE__ */ new Map([
+var kindLevelMap2 = /* @__PURE__ */ new Map([
   ["critical", 0],
   ["medium", 2],
   ["0", 0],
   ["2", 2]
 ]);
-var kinds6 = new Set(kindsMap4.keys());
-var isSquatKind = (value) => kinds6.has(value);
-var parseInternals13 = (nodes) => {
+var kinds5 = new Set(kindsMap3.keys());
+var isSquatKind = (value) => kinds5.has(value);
+var parseInternals12 = (nodes) => {
   let kind;
   let comparator;
   let kindValue = "";
@@ -7894,7 +7761,7 @@ var parseInternals13 = (nodes) => {
     } else {
       throw error("Expected a valid squat kind for comparison", {
         found: kindValue,
-        validOptions: Array.from(kinds6)
+        validOptions: Array.from(kinds5)
       });
     }
   }
@@ -7904,7 +7771,7 @@ var squat = async (state) => {
   assertSecurityArchive(state, "squat");
   let internals;
   try {
-    internals = parseInternals13(
+    internals = parseInternals12(
       asPostcssNodeWithChildren(state.current).nodes
     );
   } catch (err) {
@@ -7927,21 +7794,21 @@ var squat = async (state) => {
     let exclude = true;
     if (kind === void 0 && comparator === void 0) {
       exclude = !report.alerts.some(
-        (alert) => [...kindsMap4.values()].includes(
+        (alert) => [...kindsMap3.values()].includes(
           alert.type
         )
       );
     } else if (comparator) {
-      const kindLevel = kindLevelMap3.get(kind);
+      const kindLevel = kindLevelMap2.get(kind);
       if (kindLevel === void 0) break;
       let matchesComparison = false;
       for (const alert of report.alerts) {
         const alertType = alert.type;
-        const alertLevelKey = [...kindsMap4.entries()].find(
+        const alertLevelKey = [...kindsMap3.entries()].find(
           ([_, value]) => value === alertType
         )?.[0];
         if (alertLevelKey) {
-          const alertLevel = kindLevelMap3.get(alertLevelKey);
+          const alertLevel = kindLevelMap2.get(alertLevelKey);
           if (alertLevel === void 0) continue;
           switch (comparator) {
             case ">":
@@ -7970,7 +7837,7 @@ var squat = async (state) => {
       }
       exclude = !matchesComparison;
     } else {
-      const alertName = kindsMap4.get(kind);
+      const alertName = kindsMap3.get(kind);
       exclude = !report.alerts.some((alert) => alert.type === alertName);
     }
     if (exclude) {
@@ -8044,13 +7911,171 @@ var unstable = createSecuritySelectorFilter(
   "unstableOwnership"
 );
 
-// ../../src/query/src/pseudo/vulnerable.ts
-var vulnerable = async (state) => {
-  assertSecurityArchive(state, "vulnerable");
+// ../../src/query/src/pseudo/vuln.ts
+var kinds6 = /* @__PURE__ */ new Set([
+  "critical",
+  "high",
+  "medium",
+  "low",
+  "0",
+  "1",
+  "2",
+  "3"
+]);
+var kindLevelMap3 = /* @__PURE__ */ new Map([
+  ["critical", 0],
+  ["high", 1],
+  ["medium", 2],
+  ["low", 3],
+  ["0", 0],
+  ["1", 1],
+  ["2", 2],
+  ["3", 3]
+]);
+var alertLevelMap = /* @__PURE__ */ new Map([
+  ["criticalCVE", 0],
+  ["cve", 1],
+  ["potentialVulnerability", 2],
+  ["gptSecurity", 2],
+  ["mildCVE", 3],
+  ["gptAnomaly", 3]
+]);
+var severityLevelMap = /* @__PURE__ */ new Map([
+  ["critical", 0],
+  ["high", 1],
+  ["medium", 2],
+  ["low", 3]
+]);
+var getAlertLevel = (alert) => {
+  const level = alertLevelMap.get(alert.type);
+  if (level != null) return level;
+  if (alert.props?.cveId && alert.severity) {
+    return severityLevelMap.get(alert.severity);
+  }
+  return void 0;
+};
+var isVulnKind = (value) => kinds6.has(value);
+var asVulnKind = (value) => {
+  if (!isVulnKind(value)) {
+    throw error("Expected a valid vuln kind", {
+      found: value,
+      validOptions: Array.from(kinds6)
+    });
+  }
+  return value;
+};
+var parseInternals13 = (nodes) => {
+  if (!nodes[0]) {
+    return { kind: void 0, comparator: void 0 };
+  }
+  const selectorNode = asPostcssNodeWithChildren(nodes[0]);
+  if (!selectorNode.nodes[0]) {
+    return { kind: void 0, comparator: void 0 };
+  }
+  let kindValue = "";
+  let comparator = void 0;
+  let kind;
+  if (isStringNode(selectorNode.nodes[0])) {
+    kindValue = removeQuotes(
+      asStringNode(selectorNode.nodes[0]).value
+    );
+  } else if (isTagNode(selectorNode.nodes[0])) {
+    kindValue = asTagNode(selectorNode.nodes[0]).value;
+  }
+  if (kindValue.startsWith(">=")) {
+    comparator = ">=";
+    kindValue = kindValue.substring(2);
+  } else if (kindValue.startsWith("<=")) {
+    comparator = "<=";
+    kindValue = kindValue.substring(2);
+  } else if (kindValue.startsWith(">")) {
+    comparator = ">";
+    kindValue = kindValue.substring(1);
+  } else if (kindValue.startsWith("<")) {
+    comparator = "<";
+    kindValue = kindValue.substring(1);
+  }
+  if (!comparator) {
+    kind = asVulnKind(kindValue);
+  } else {
+    if (isVulnKind(kindValue)) {
+      kind = kindValue;
+    } else {
+      throw error(
+        "Expected a valid vuln kind or number between 0-3",
+        {
+          found: kindValue
+        }
+      );
+    }
+  }
+  return { kind, comparator };
+};
+var vuln = async (state) => {
+  assertSecurityArchive(state, "vuln");
+  let internals;
+  try {
+    internals = parseInternals13(
+      asPostcssNodeWithChildren(state.current).nodes
+    );
+  } catch (err) {
+    throw error("Failed to parse :vuln selector", { cause: err });
+  }
+  const { kind, comparator } = internals;
   for (const node of state.partial.nodes) {
     const report = state.securityArchive.get(node.id);
-    const hasCve = report?.alerts.some((alert) => alert.props?.cveId);
-    if (!hasCve) {
+    if (!report?.alerts || report.alerts.length === 0) {
+      removeNode(state, node);
+    }
+  }
+  for (const node of state.partial.nodes) {
+    const report = state.securityArchive.get(node.id);
+    let exclude = true;
+    if (report) {
+      if (kind === void 0 && comparator === void 0) {
+        exclude = !report.alerts.some((alert) => {
+          const level = getAlertLevel(alert);
+          return level != null && level <= 2;
+        });
+      } else if (comparator) {
+        const kindLevel = kindLevelMap3.get(kind);
+        if (kindLevel == null) break;
+        for (const alert of report.alerts) {
+          const currentAlertLevel = getAlertLevel(alert);
+          if (currentAlertLevel == null) continue;
+          switch (comparator) {
+            case ">":
+              if (currentAlertLevel > kindLevel) {
+                exclude = false;
+              }
+              break;
+            case "<":
+              if (currentAlertLevel < kindLevel) {
+                exclude = false;
+              }
+              break;
+            case ">=":
+              if (currentAlertLevel >= kindLevel) {
+                exclude = false;
+              }
+              break;
+            case "<=":
+              if (currentAlertLevel <= kindLevel) {
+                exclude = false;
+              }
+              break;
+          }
+          if (!exclude) break;
+        }
+      } else {
+        const targetLevel = kindLevelMap3.get(kind);
+        exclude = !report.alerts.some((alert) => {
+          const level = getAlertLevel(alert);
+          return level != null && level === targetLevel;
+        });
+      }
+    }
+    if (exclude) {
       removeNode(state, node);
     }
   }
@@ -8320,8 +8345,8 @@ var pseudoSelectors = new Map(
     unpopular,
     unstable,
     v: semverParser,
-    vuln: vulnerable,
-    vulnerable,
+    vuln,
+    vulnerable: vuln,
     workspace
   })
 );
@@ -8463,7 +8488,9 @@ var securitySelectors = /* @__PURE__ */ new Set([
   ":unknown",
   ":unmaintained",
   ":unpopular",
-  ":unstable"
+  ":unstable",
+  ":vuln",
+  ":vulnerable"
 ]);
 var setMethodToJSON = (node) => {
   const { toJSON } = node;
@@ -8606,20 +8633,9 @@ var Query = class {
             (i) => i.type === "licenseException"
           )
         },
-        malware: {
-          low: securityArchiveEntry.alerts.some(
-            (i) => i.type === "gptAnomaly"
-          ),
-          medium: securityArchiveEntry.alerts.some(
-            (i) => i.type === "gptSecurity"
-          ),
-          high: securityArchiveEntry.alerts.some(
-            (i) => i.type === "gptMalware"
-          ),
-          critical: securityArchiveEntry.alerts.some(
-            (i) => i.type === "malware"
-          )
-        },
+        malware: securityArchiveEntry.alerts.some(
+          (i) => i.type === "malware" || i.type === "gptMalware"
+        ),
         minified: securityArchiveEntry.alerts.some(
           (i) => i.type === "minifiedFile"
         ),
@@ -8686,7 +8702,21 @@ var Query = class {
         ),
         unstable: securityArchiveEntry.alerts.some(
           (i) => i.type === "unstableOwnership"
-        )
+        ),
+        vuln: {
+          low: securityArchiveEntry.alerts.some(
+            (i) => i.type === "mildCVE" || i.type === "gptAnomaly"
+          ),
+          medium: securityArchiveEntry.alerts.some(
+            (i) => i.type === "potentialVulnerability" || i.type === "gptSecurity"
+          ),
+          high: securityArchiveEntry.alerts.some(
+            (i) => i.type === "cve"
+          ),
+          critical: securityArchiveEntry.alerts.some(
+            (i) => i.type === "criticalCVE"
+          )
+        }
       };
       setMethodToJSON(node);
     }

package/{chunk-7KI6XHXZ.js → chunk-EHEVBLDB.js}

@@ -17,7 +17,7 @@ import {
 import {
   generateDefaultHelp,
   generateFullHelp
-} from "./chunk-SSN4CYZF.js";
+} from "./chunk-Y7CQIZ7Y.js";
 import {
   isViewClass
 } from "./chunk-RXNA2XCX.js";
@@ -34,7 +34,7 @@ import {
 } from "./chunk-FAG776ZD.js";
 import {
   defaultView
-} from "./chunk-PMCAQG5J.js";
+} from "./chunk-WP6CYBPM.js";
 import {
   emitter
 } from "./chunk-UBLFPJHV.js";