@vltpkg/query 1.0.0-rc.8 → 1.0.1

package/dist/{esm/pseudo → pseudo}/semver.js

@@ -1,10 +1,10 @@
-import { satisfies, gt, gte, lt, lte, eq, neq, parse, parseRange, } from '@vltpkg/semver';
+import { satisfies, gt, gte, lt, lte, eq, neq, intersects, subset, parse, parseRange, } from '@vltpkg/semver';
 import { error } from '@vltpkg/error-cause';
 import { asError } from '@vltpkg/types';
 import { parseInternals as parseAttrInternals } from "./attr.js";
 import { getManifestPropertyValues } from "../attribute.js";
 import { asAttributeNode, asPostcssNodeWithChildren, asPseudoNode, asStringNode, asTagNode, isAttributeNode, isPseudoNode, isStringNode, isTagNode, } from '@vltpkg/dss-parser';
-import { removeNode, removeQuotes } from "./helpers.js";
+import { removeEdge, removeNode, removeQuotes, removeUnlinkedNodes, } from "./helpers.js";
 const semverFunctionNames = new Set([
     'satisfies',
     'gt',
@@ -13,6 +13,8 @@ const semverFunctionNames = new Set([
     'lte',
     'eq',
     'neq',
+    'intersects',
+    'subset',
 ]);
 export const isSemverFunctionName = (name) => semverFunctionNames.has(name);
 export const asSemverFunctionName = (name) => {
@@ -33,6 +35,10 @@ const semverFunctions = new Map([
     ['eq', eq],
     ['neq', neq],
 ]);
+const semverRangeFunctions = new Map([
+    ['intersects', intersects],
+    ['subset', subset],
+]);
 export const parseInternals = (nodes, loose) => {
     // tries to parse the first param as a string node, otherwise defaults
     // to reading all postcss nodes as just strings, since it just means
@@ -82,13 +88,17 @@ export const parseInternals = (nodes, loose) => {
         }
     }
     const semverFunction = semverFunctions.get(fnName);
+    const semverRangeFunction = semverRangeFunctions.get(fnName);
     // the following should never happen as long as the semver function names
     // type and Set are correctly mirroring each other values
     /* c8 ignore start */
-    if (!semverFunction) {
+    if (!semverFunction && !semverRangeFunction) {
         throw error('Invalid semver function name', {
             found: fnName,
-            validOptions: Array.from(semverFunctions.keys()),
+            validOptions: [
+                ...Array.from(semverFunctions.keys()),
+                ...Array.from(semverRangeFunctions.keys()),
+            ],
         });
     }
     /* c8 ignore stop */
@@ -117,7 +127,8 @@ export const parseInternals = (nodes, loose) => {
     }
     return {
         semverValue,
-        semverFunction,
+        semverFunction: semverFunction ?? satisfies,
+        semverRangeFunction,
         compareAttribute,
     };
 };
@@ -131,7 +142,33 @@ export const semverParser = async (state) => {
             cause: err,
         });
     }
-    const { semverValue, semverFunction, compareAttribute } = internals;
+    const { semverValue, semverFunction, semverRangeFunction, compareAttribute, } = internals;
+    // Range-vs-range functions (subset, intersects) operate on edges by default
+    if (semverRangeFunction) {
+        if (compareAttribute) {
+            // Compare the semverValue against a manifest property value as ranges
+            for (const node of state.partial.nodes) {
+                const compareValues = getManifestPropertyValues(node, compareAttribute.properties, compareAttribute.attribute);
+                const compareValue = compareValues?.[0];
+                if (!compareValue ||
+                    !semverRangeFunction(compareValue, semverValue)) {
+                    removeNode(state, node);
+                }
+            }
+        }
+        else {
+            // Default: operate on edges using bareSpec
+            for (const edge of state.partial.edges) {
+                const edgeRange = edge.spec.semver ?? edge.spec.bareSpec;
+                if (!edgeRange ||
+                    !semverRangeFunction(edgeRange, semverValue)) {
+                    removeEdge(state, edge);
+                }
+            }
+            removeUnlinkedNodes(state);
+        }
+        return state;
+    }
     for (const node of state.partial.nodes) {
         if (compareAttribute) {
             const compareValues = getManifestPropertyValues(node, compareAttribute.properties, compareAttribute.attribute);
@@ -164,4 +201,3 @@ export const semverParser = async (state) => {
     }
     return state;
 };
-//# sourceMappingURL=semver.js.map

package/dist/{esm/pseudo → pseudo}/severity.d.ts

@@ -12,4 +12,3 @@ export declare const parseInternals: (nodes: PostcssNode[]) => {
 export declare const severity: (state: ParserState) => Promise<ParserState & {
     securityArchive: NonNullable<ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=severity.d.ts.map

package/dist/{esm/pseudo → pseudo}/severity.js

@@ -157,4 +157,3 @@ export const severity = async (state) => {
     removeDanglingEdges(state);
     return state;
 };
-//# sourceMappingURL=severity.js.map

package/dist/{esm/pseudo → pseudo}/shell.d.ts

@@ -4,4 +4,3 @@
 export declare const shell: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=shell.d.ts.map

package/dist/{esm/pseudo → pseudo}/shell.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **shellAccess** report alert.
  */
 export const shell = createSecuritySelectorFilter('shell', 'shellAccess');
-//# sourceMappingURL=shell.js.map

package/dist/{esm/pseudo → pseudo}/shrinkwrap.d.ts

@@ -4,4 +4,3 @@
 export declare const shrinkwrap: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=shrinkwrap.d.ts.map

package/dist/{esm/pseudo → pseudo}/shrinkwrap.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **shrinkwrap** report alert.
  */
 export const shrinkwrap = createSecuritySelectorFilter('shrinkwrap', 'shrinkwrap');
-//# sourceMappingURL=shrinkwrap.js.map

package/dist/{esm/pseudo → pseudo}/spec.d.ts

@@ -14,4 +14,3 @@ export declare const parseInternals: (nodes: PostcssNode[]) => SpecInternals;
  * - :spec("workspace:dev") matches edges with a package specifier equal to "workspace:dev"
  */
 export declare const spec: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=spec.d.ts.map

package/dist/{esm/pseudo → pseudo}/spec.js

@@ -99,4 +99,3 @@ export const spec = async (state) => {
     removeUnlinkedNodes(state);
     return state;
 };
-//# sourceMappingURL=spec.js.map

package/dist/{esm/pseudo → pseudo}/squat.d.ts

@@ -12,4 +12,3 @@ export declare const parseInternals: (nodes: PostcssNode[]) => {
 export declare const squat: (state: ParserState) => Promise<ParserState & {
     securityArchive: NonNullable<ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=squat.d.ts.map

package/dist/{esm/pseudo → pseudo}/squat.js

@@ -169,4 +169,3 @@ export const squat = async (state) => {
     removeDanglingEdges(state);
     return state;
 };
-//# sourceMappingURL=squat.js.map

package/dist/{esm/pseudo → pseudo}/suspicious.d.ts

@@ -4,4 +4,3 @@
 export declare const suspicious: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=suspicious.d.ts.map

package/dist/{esm/pseudo → pseudo}/suspicious.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **suspiciousStarActivity** report alert.
  */
 export const suspicious = createSecuritySelectorFilter('suspicious', 'suspiciousStarActivity');
-//# sourceMappingURL=suspicious.js.map

package/dist/{esm/pseudo → pseudo}/tracker.d.ts

@@ -4,4 +4,3 @@
 export declare const tracker: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=tracker.d.ts.map

package/dist/{esm/pseudo → pseudo}/tracker.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **telemetry** report alert.
  */
 export const tracker = createSecuritySelectorFilter('tracker', 'telemetry');
-//# sourceMappingURL=tracker.js.map

package/dist/{esm/pseudo → pseudo}/trivial.d.ts

@@ -4,4 +4,3 @@
 export declare const trivial: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=trivial.d.ts.map

package/dist/{esm/pseudo → pseudo}/trivial.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **trivialPackage** report alert.
  */
 export const trivial = createSecuritySelectorFilter('trivial', 'trivialPackage');
-//# sourceMappingURL=trivial.js.map

package/dist/{esm/pseudo → pseudo}/type.d.ts

@@ -5,4 +5,3 @@ import type { ParserState } from '../types.ts';
  * first part of the dependency ID.
  */
 export declare const type: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=type.d.ts.map

package/dist/{esm/pseudo → pseudo}/type.js

@@ -19,4 +19,3 @@ export const type = async (state) => {
     removeDanglingEdges(state);
     return state;
 };
-//# sourceMappingURL=type.js.map

package/dist/{esm/pseudo → pseudo}/undesirable.d.ts

@@ -4,4 +4,3 @@
 export declare const undesirable: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=undesirable.d.ts.map

package/dist/{esm/pseudo → pseudo}/undesirable.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **troll** report alert.
  */
 export const undesirable = createSecuritySelectorFilter('undesirable', 'troll');
-//# sourceMappingURL=undesirable.js.map

package/dist/{esm/pseudo → pseudo}/unknown.d.ts

@@ -4,4 +4,3 @@
 export declare const unknown: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=unknown.d.ts.map

package/dist/{esm/pseudo → pseudo}/unknown.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **newAuthor** report alert.
  */
 export const unknown = createSecuritySelectorFilter('unknown', 'newAuthor');
-//# sourceMappingURL=unknown.js.map

package/dist/{esm/pseudo → pseudo}/unmaintained.d.ts

@@ -4,4 +4,3 @@
 export declare const unmaintained: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=unmaintained.d.ts.map

package/dist/{esm/pseudo → pseudo}/unmaintained.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **unmaintained** report alert.
  */
 export const unmaintained = createSecuritySelectorFilter('unmaintained', 'unmaintained');
-//# sourceMappingURL=unmaintained.js.map

package/dist/{esm/pseudo → pseudo}/unpopular.d.ts

@@ -4,4 +4,3 @@
 export declare const unpopular: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=unpopular.d.ts.map

package/dist/{esm/pseudo → pseudo}/unpopular.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **unpopularPackage** report alert.
  */
 export const unpopular = createSecuritySelectorFilter('unpopular', 'unpopularPackage');
-//# sourceMappingURL=unpopular.js.map

package/dist/{esm/pseudo → pseudo}/unstable.d.ts

@@ -4,4 +4,3 @@
 export declare const unstable: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
     securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=unstable.d.ts.map

package/dist/{esm/pseudo → pseudo}/unstable.js

@@ -3,4 +3,3 @@ import { createSecuritySelectorFilter } from "./helpers.js";
  * Filters out any node that does not have a **unstableOwnership** report alert.
  */
 export const unstable = createSecuritySelectorFilter('unstable', 'unstableOwnership');
-//# sourceMappingURL=unstable.js.map

package/dist/pseudo/vuln.d.ts

@@ -0,0 +1,22 @@
+import type { ParserState } from '../types.ts';
+import type { PostcssNode } from '@vltpkg/dss-parser';
+export type VulnKinds = '0' | '1' | '2' | '3' | 'critical' | 'high' | 'medium' | 'low' | undefined;
+export type VulnComparator = '>' | '<' | '>=' | '<=' | undefined;
+export declare const isVulnKind: (value?: string) => value is VulnKinds;
+export declare const asVulnKind: (value?: string) => VulnKinds;
+export declare const parseInternals: (nodes: PostcssNode[]) => {
+    kind: VulnKinds;
+    comparator: VulnComparator;
+};
+/**
+ * :vuln / :vulnerable Pseudo-Selector, matches nodes with vulnerability alerts.
+ *
+ * Usage:
+ * - :vuln - matches vulnerabilities with severity >= medium (critical, high, medium but not low)
+ * - :vuln(critical) - matches specific vulnerability kind
+ * - :vuln(>1) - matches vulnerabilities with severity greater than 1
+ * - :vuln(">=medium") - matches vulnerabilities with severity >= medium
+ */
+export declare const vuln: (state: ParserState) => Promise<ParserState & {
+    securityArchive: NonNullable<ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/vuln.js

@@ -0,0 +1,220 @@
+import { error } from '@vltpkg/error-cause';
+import { asPostcssNodeWithChildren, asStringNode, asTagNode, isStringNode, isTagNode, } from '@vltpkg/dss-parser';
+import { assertSecurityArchive, removeDanglingEdges, removeNode, removeQuotes, } from "./helpers.js";
+// Valid vulnerability kind names
+const kinds = new Set([
+    'critical',
+    'high',
+    'medium',
+    'low',
+    '0',
+    '1',
+    '2',
+    '3',
+]);
+// Map numerical values to their respective kinds for comparison operations
+const kindLevelMap = new Map([
+    ['critical', 0],
+    ['high', 1],
+    ['medium', 2],
+    ['low', 3],
+    ['0', 0],
+    ['1', 1],
+    ['2', 2],
+    ['3', 3],
+]);
+// Maps alert types to their severity level for comparison operations.
+// gptSecurity maps to medium (2), gptAnomaly maps to low (3).
+const alertLevelMap = new Map([
+    ['criticalCVE', 0],
+    ['cve', 1],
+    ['potentialVulnerability', 2],
+    ['gptSecurity', 2],
+    ['mildCVE', 3],
+    ['gptAnomaly', 3],
+]);
+// Maps alert.severity strings to numeric levels for cveId-bearing alerts
+// whose type may not be in alertLevelMap.
+const severityLevelMap = new Map([
+    ['critical', 0],
+    ['high', 1],
+    ['medium', 2],
+    ['low', 3],
+]);
+/**
+ * Returns the severity level for an alert, considering both its type
+ * (via alertLevelMap) and its cveId + severity fields. Alerts with a
+ * cveId are treated as vulnerability alerts even if their type is not
+ * in the closed set.
+ */
+const getAlertLevel = (alert) => {
+    const level = alertLevelMap.get(alert.type);
+    if (level != null)
+        return level;
+    // Fall back to severity field for alerts carrying a CVE id
+    if (alert.props?.cveId && alert.severity) {
+        return severityLevelMap.get(alert.severity);
+    }
+    return undefined;
+};
+export const isVulnKind = (value) => kinds.has(value);
+export const asVulnKind = (value) => {
+    if (!isVulnKind(value)) {
+        throw error('Expected a valid vuln kind', {
+            found: value,
+            validOptions: Array.from(kinds),
+        });
+    }
+    return value;
+};
+export const parseInternals = (nodes) => {
+    // Handle case where no parameters are provided (parameterless :vuln)
+    if (!nodes[0]) {
+        return { kind: undefined, comparator: undefined };
+    }
+    const selectorNode = asPostcssNodeWithChildren(nodes[0]);
+    if (!selectorNode.nodes[0]) {
+        return { kind: undefined, comparator: undefined };
+    }
+    let kindValue = '';
+    let comparator = undefined;
+    let kind;
+    // Parse the parameter (kind with optional comparator)
+    if (isStringNode(selectorNode.nodes[0])) {
+        kindValue = removeQuotes(asStringNode(selectorNode.nodes[0]).value);
+    }
+    else if (isTagNode(selectorNode.nodes[0])) {
+        kindValue = asTagNode(selectorNode.nodes[0]).value;
+    }
+    // Extract comparator if present
+    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);
+    }
+    // Validate the kind without comparator
+    if (!comparator) {
+        kind = asVulnKind(kindValue);
+    }
+    else {
+        // For comparisons, just make sure it's a valid numeric value or a valid kind
+        if (isVulnKind(kindValue)) {
+            kind = kindValue;
+        }
+        else {
+            throw error('Expected a valid vuln kind or number between 0-3', {
+                found: kindValue,
+            });
+        }
+    }
+    return { kind, comparator };
+};
+/**
+ * :vuln / :vulnerable Pseudo-Selector, matches nodes with vulnerability alerts.
+ *
+ * Usage:
+ * - :vuln - matches vulnerabilities with severity >= medium (critical, high, medium but not low)
+ * - :vuln(critical) - matches specific vulnerability kind
+ * - :vuln(>1) - matches vulnerabilities with severity greater than 1
+ * - :vuln(">=medium") - matches vulnerabilities with severity >= medium
+ */
+export const vuln = async (state) => {
+    assertSecurityArchive(state, 'vuln');
+    let internals;
+    try {
+        internals = parseInternals(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);
+        // Always exclude nodes that don't have security data or alerts
+        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 === undefined && comparator === undefined) {
+                // Parameterless :vuln - match vuln alerts with severity >= medium
+                // Includes: criticalCVE, cve, potentialVulnerability, gptSecurity,
+                //           and any alert carrying a cveId prop
+                // Excludes: mildCVE, gptAnomaly (low severity)
+                exclude = !report.alerts.some(alert => {
+                    const level = getAlertLevel(alert);
+                    return level != null && level <= 2;
+                });
+            }
+            else if (comparator) {
+                // retrieve the value to compare against
+                const kindLevel = kindLevelMap.get(kind);
+                // the kindLevel value has already been validated at this point
+                // and thus can never return an undefined/falsy value but ts doesn't
+                // know about that, so we have the extra check here
+                /* c8 ignore next - impossible */
+                if (kindLevel == null)
+                    break;
+                // Check each alert to find any that match our comparison criteria
+                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 we've found a match, no need to check other alerts
+                    if (!exclude)
+                        break;
+                }
+            }
+            else {
+                // Exact match behavior — also matches gptSecurity/gptAnomaly
+                // at the same level as their mapped kind, and cveId-bearing alerts
+                const targetLevel = kindLevelMap.get(kind);
+                exclude = !report.alerts.some(alert => {
+                    const level = getAlertLevel(alert);
+                    return level != null && level === targetLevel;
+                });
+            }
+        }
+        if (exclude) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

package/dist/{esm/pseudo → pseudo}/workspace.d.ts

@@ -3,4 +3,3 @@ import type { ParserState } from '../types.ts';
  * :workspace Pseudo-Selector will only match workspace dependencies.
  */
 export declare const workspace: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=workspace.d.ts.map

package/dist/{esm/pseudo → pseudo}/workspace.js

@@ -17,4 +17,3 @@ export const workspace = async (state) => {
     }
     return state;
 };
-//# sourceMappingURL=workspace.js.map

package/dist/{esm/pseudo.d.ts → pseudo.d.ts}

@@ -3,4 +3,3 @@ import type { ParserState } from './types.ts';
  * Parsers the `pseudo` node types.
  */
 export declare const pseudo: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=pseudo.d.ts.map

package/dist/{esm/pseudo.js → pseudo.js}

@@ -11,6 +11,8 @@ import { cwe } from "./pseudo/cwe.js";
 import { debug } from "./pseudo/debug.js";
 import { deprecated } from "./pseudo/deprecated.js";
 import { dev } from "./pseudo/dev.js";
+import { diff } from "./pseudo/diff.js";
+import { dist } from "./pseudo/dist.js";
 import { dynamic } from "./pseudo/dynamic.js";
 import { empty } from "./pseudo/empty.js";
 import { entropic } from "./pseudo/entropic.js";
@@ -18,6 +20,7 @@ import { env } from "./pseudo/env.js";
 import { evalParser } from "./pseudo/eval.js";
 import { fs } from "./pseudo/fs.js";
 import { hostContext } from "./pseudo/host.js";
+import { hostname } from "./pseudo/hostname.js";
 import { license } from "./pseudo/license.js";
 import { link } from "./pseudo/link.js";
 import { malware } from "./pseudo/malware.js";
@@ -34,6 +37,7 @@ import { peer } from "./pseudo/peer.js";
 import { prerelease } from "./pseudo/prerelease.js";
 import { published } from "./pseudo/published.js";
 import { privateParser } from "./pseudo/private.js";
+import { registry } from "./pseudo/registry.js";
 import { prod } from "./pseudo/prod.js";
 import { root } from "./pseudo/root.js";
 import { scanned } from "./pseudo/scanned.js";
@@ -54,6 +58,7 @@ import { unknown } from "./pseudo/unknown.js";
 import { unmaintained } from "./pseudo/unmaintained.js";
 import { unpopular } from "./pseudo/unpopular.js";
 import { unstable } from "./pseudo/unstable.js";
+import { vuln } from "./pseudo/vuln.js";
 import { workspace } from "./pseudo/workspace.js";
 /**
  * :has Pseudo-Selector, matches only nodes that have valid results
@@ -81,6 +86,8 @@ const has = async (state) => {
                     edges: new Set(state.partial.edges),
                     nodes: new Set(state.partial.nodes),
                 },
+                diffFiles: state.diffFiles,
+                loose: state.loose,
                 hostContexts: state.hostContexts,
                 importers: state.importers,
                 retries: state.retries,
@@ -155,6 +162,7 @@ const is = async (state) => {
                     nodes: new Set(),
                 },
                 current: node,
+                diffFiles: state.diffFiles,
                 initial: state.initial,
                 loose: true,
                 partial: {
@@ -200,7 +208,9 @@ const not = async (state) => {
                     nodes: new Set(),
                 },
                 current: node,
+                diffFiles: state.diffFiles,
                 initial: state.initial,
+                loose: state.loose,
                 partial: {
                     nodes: new Set(state.partial.nodes),
                     edges: new Set(state.partial.edges),
@@ -277,6 +287,8 @@ const pseudoSelectors = new Map(Object.entries({
     debug,
     deprecated,
     dev,
+    diff,
+    dist,
     dynamic,
     eval: evalParser,
     empty,
@@ -285,6 +297,7 @@ const pseudoSelectors = new Map(Object.entries({
     fs,
     has,
     host: hostContext,
+    hostname,
     is,
     license,
     link,
@@ -304,6 +317,7 @@ const pseudoSelectors = new Map(Object.entries({
     published,
     private: privateParser,
     prod,
+    registry,
     project,
     root,
     scanned,
@@ -327,6 +341,8 @@ const pseudoSelectors = new Map(Object.entries({
     unpopular,
     unstable,
     v: semver,
+    vuln,
+    vulnerable: vuln,
     workspace,
 }));
 /**
@@ -358,4 +374,3 @@ export const pseudo = async (state) => {
     }
     return result;
 };
-//# sourceMappingURL=pseudo.js.map