@vltpkg/query 1.0.0-rc.8 → 1.0.1

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

@@ -4,4 +4,3 @@ import type { ParserState } from '../types.ts';
  * It filters out any node that has edges out, i.e., has dependencies.
  */
 export declare const empty: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=empty.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -36,4 +36,3 @@ export declare const clear: (state: ParserState) => ParserState;
 export declare const createSecuritySelectorFilter: (name: string, type: string) => (state: ParserState) => Promise<ParserState & {
     securityArchive: NonNullable<ParserState["securityArchive"]>;
 }>;
-//# sourceMappingURL=helpers.d.ts.map

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

@@ -13,7 +13,7 @@ export const removeNode = (state, node) => {
  */
 export const removeEdge = (state, edge) => {
     state.partial.edges.delete(edge);
-    if (edge.to && edge.to.edgesIn.size === 1) {
+    if (edge.to?.edgesIn.size === 1) {
         state.partial.nodes.delete(edge.to);
     }
 };
@@ -77,4 +77,3 @@ export const createSecuritySelectorFilter = (name, type) => {
         return state;
     };
 };
-//# sourceMappingURL=helpers.js.map

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

@@ -17,4 +17,3 @@ export declare const parseInternals: (nodes: PostcssNode[]) => string;
  * - :host(local) - Switches to graphs loaded from the local context
  */
 export declare const hostContext: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=host.d.ts.map

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

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

package/dist/pseudo/hostname.d.ts

@@ -0,0 +1,11 @@
+import type { ParserState } from '../types.ts';
+/**
+ * :hostname(str) Pseudo-Selector, matches only nodes whose
+ * upstream hostname matches the provided domain string.
+ *
+ * Examples:
+ * - :hostname("registry.npmjs.org") — default npm registry deps
+ * - :hostname("github.com") — github git deps
+ * - :hostname("example.com") — custom registry deps
+ */
+export declare const hostname: (state: ParserState) => Promise<ParserState>;

package/dist/pseudo/hostname.js

@@ -0,0 +1,140 @@
+import { splitDepID } from '@vltpkg/dep-id/browser';
+import { getOptions, gitHostWebsites } from '@vltpkg/spec/browser';
+import { asPostcssNodeWithChildren } from '@vltpkg/dss-parser';
+import { error } from '@vltpkg/error-cause';
+import { removeDanglingEdges, removeNode } from "./helpers.js";
+import { parseInternals } from "./spec.js";
+/**
+ * Given a named git host (e.g. "github"), resolve its hostname
+ * by looking up `gitHostWebsites` (e.g. "github.com"), or
+ * falling back to the `git-hosts` template URL.
+ */
+const resolveGitHostname = (namedHost, gitHosts) => {
+    // Check gitHostWebsites first (e.g. github -> github.com)
+    const website = gitHostWebsites[namedHost];
+    if (website) {
+        try {
+            return new URL(website).hostname;
+            /* c8 ignore next */
+        }
+        catch { }
+    }
+    // Fall back to parsing the git-hosts template URL
+    const template = gitHosts[namedHost];
+    if (template) {
+        try {
+            // Templates look like 'git+ssh://git@github.com:$1/$2.git'
+            // Replace colons after the host with / for URL parsing
+            const normalized = template
+                .replace(/^git\+/, '')
+                .replace(/:(\$)/, '/$1');
+            return new URL(normalized).hostname;
+            /* c8 ignore next */
+        }
+        catch { }
+    }
+    /* c8 ignore next */
+    return undefined;
+};
+/**
+ * Resolve the hostname for a git remote string.
+ * Named hosts: "github:user/repo" -> extract "github" and look up.
+ * Full URLs: "git+ssh://git@example.com/repo.git" -> parse URL.
+ */
+const getGitHostname = (gitRemote, gitHosts) => {
+    // Check if it's a named git host like "github:user/repo"
+    const colonIdx = gitRemote.indexOf(':');
+    if (colonIdx > 0) {
+        const possibleHost = gitRemote.slice(0, colonIdx);
+        // If this is a known named git host, resolve it
+        if (possibleHost in gitHosts) {
+            return resolveGitHostname(possibleHost, gitHosts);
+        }
+        // Could be a protocol URL like git+ssh://...
+        try {
+            const normalized = gitRemote
+                .replace(/^git\+/, '')
+                .replace(/^ssh:\/\/([^@]+@)?([^:/]+)[:/]/, 'ssh://$1$2/');
+            return new URL(normalized).hostname;
+            /* c8 ignore next */
+        }
+        catch { }
+    }
+    /* c8 ignore start - git remotes always contain a colon */
+    // Try parsing as a plain URL
+    try {
+        return new URL(gitRemote).hostname;
+    }
+    catch { }
+    return undefined;
+    /* c8 ignore stop */
+};
+/**
+ * :hostname(str) Pseudo-Selector, matches only nodes whose
+ * upstream hostname matches the provided domain string.
+ *
+ * Examples:
+ * - :hostname("registry.npmjs.org") — default npm registry deps
+ * - :hostname("github.com") — github git deps
+ * - :hostname("example.com") — custom registry deps
+ */
+export const hostname = async (state) => {
+    let internals;
+    try {
+        internals = parseInternals(asPostcssNodeWithChildren(state.current).nodes);
+    }
+    catch (err) {
+        throw error('Failed to parse :hostname selector', {
+            cause: err,
+        });
+    }
+    const targetHostname = internals.specValue;
+    for (const node of state.partial.nodes) {
+        const tuple = splitDepID(node.id);
+        const type = tuple[0];
+        let nodeHostname;
+        switch (type) {
+            case 'registry': {
+                const registryName = tuple[1];
+                const options = getOptions(node.options);
+                // Look up the registry URL from registries map. There is no
+                // default registry, so a node with an empty registry field and
+                // no configured registry has no hostname, and never matches.
+                const registryUrl = options.registries[registryName] ?? options.registry;
+                if (registryUrl) {
+                    try {
+                        nodeHostname = new URL(registryUrl).hostname;
+                        /* c8 ignore next */
+                    }
+                    catch { }
+                }
+                break;
+            }
+            case 'git': {
+                const gitRemote = tuple[1];
+                const options = getOptions(node.options);
+                nodeHostname = getGitHostname(gitRemote, options['git-hosts']);
+                break;
+            }
+            case 'remote': {
+                const url = tuple[1];
+                try {
+                    nodeHostname = new URL(url).hostname;
+                    /* c8 ignore next */
+                }
+                catch { }
+                break;
+            }
+            // file and workspace deps are local — no hostname
+            default: {
+                nodeHostname = undefined;
+                break;
+            }
+        }
+        if (nodeHostname !== targetHostname) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

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

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

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

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

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

@@ -6,4 +6,3 @@ import type { ParserState } from '../types.ts';
  * type that ends with 'tar.gz' since these are local tarballs.
  */
 export declare const link: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=link.d.ts.map

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

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

package/dist/pseudo/malware.d.ts

@@ -0,0 +1,10 @@
+import type { ParserState } from '../types.ts';
+/**
+ * :malware Pseudo-Selector, matches nodes with any malware-related alert.
+ *
+ * This is a binary selector — no parameters. A node matches if it has
+ * at least one alert whose type is `malware` or `gptMalware`.
+ */
+export declare const malware: (state: ParserState) => Promise<ParserState & {
+    securityArchive: NonNullable<ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/malware.js

@@ -0,0 +1,26 @@
+import { error } from '@vltpkg/error-cause';
+import { asPostcssNodeWithChildren } from '@vltpkg/dss-parser';
+import { assertSecurityArchive, removeDanglingEdges, removeNode, } from "./helpers.js";
+const malwareAlertTypes = new Set(['malware', 'gptMalware']);
+/**
+ * :malware Pseudo-Selector, matches nodes with any malware-related alert.
+ *
+ * This is a binary selector — no parameters. A node matches if it has
+ * at least one alert whose type is `malware` or `gptMalware`.
+ */
+export const malware = async (state) => {
+    assertSecurityArchive(state, 'malware');
+    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.');
+    }
+    for (const node of state.partial.nodes) {
+        const report = state.securityArchive.get(node.id);
+        const hasMalware = report?.alerts.some(alert => malwareAlertTypes.has(alert.type));
+        if (!hasMalware) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

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

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

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

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

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

@@ -5,4 +5,3 @@ import type { ParserState } from '../types.ts';
  * and clears all nodes from the result.
  */
 export declare const missing: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=missing.d.ts.map

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

@@ -12,4 +12,3 @@ export const missing = async (state) => {
     state.partial.nodes.clear();
     return state;
 };
-//# sourceMappingURL=missing.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -51,4 +51,3 @@ export declare const queueNode: (state: ParserState, node: NodeLike, kind: Outda
  *  that does not satisfy any of the available remote versions.
  */
 export declare const outdated: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=outdated.d.ts.map

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

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

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

@@ -5,4 +5,3 @@ import type { ParserState } from '../types.ts';
  * and removes any unlinked nodes from the result.
  */
 export declare const overridden: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=overridden.d.ts.map

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

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

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

@@ -16,4 +16,3 @@ export declare function createPathMatcher(pattern: string, loose?: boolean): (pa
  * parser conflicts with special characters.
  */
 export declare const path: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=path.d.ts.map

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

@@ -9,12 +9,10 @@ import { removeNode, removeDanglingEdges, removeQuotes, clear, } from "./helpers
  * This ensures consistent path comparison regardless of how paths are specified.
  */
 export function normalizePath(path) {
-    const trimmed = path.trim();
-    // Handle root path case - normalize '.' to empty string for consistency
+    const trimmed = path.trim().replaceAll('\\', '/');
     if (trimmed === '.') {
         return '';
     }
-    // Remove leading './' prefix
     if (trimmed.startsWith('./')) {
         return trimmed.slice(2);
     }
@@ -110,4 +108,3 @@ export const path = async (state) => {
     removeDanglingEdges(state);
     return state;
 };
-//# sourceMappingURL=path.js.map

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

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

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

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

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

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

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

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

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

@@ -4,4 +4,3 @@ import type { ParserState } from '../types.ts';
  * a `private: true` key set in their `package.json` metadata.
  */
 export declare const privateParser: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=private.d.ts.map

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

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

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

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

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

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

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

@@ -37,4 +37,3 @@ export declare const queueNode: (state: ParserState, node: NodeLike, relativeDat
  * - :published("<=2023-12-31") - Matches packages published on or before December 31st, 2023
  */
 export declare const published: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=published.d.ts.map

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

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

package/dist/pseudo/registry.d.ts

@@ -0,0 +1,10 @@
+import type { ParserState } from '../types.ts';
+/**
+ * :registry(name) Pseudo-Selector, matches only nodes that
+ * belong to the specified registry configuration alias.
+ *
+ * For example, `:registry(npm)` matches deps from the default
+ * npm registry, and `:registry(custom)` matches deps from a
+ * custom-named registry.
+ */
+export declare const registry: (state: ParserState) => Promise<ParserState>;

package/dist/pseudo/registry.js

@@ -0,0 +1,24 @@
+import { splitDepID } from '@vltpkg/dep-id/browser';
+import { asPostcssNodeWithChildren, asTagNode, } from '@vltpkg/dss-parser';
+import { removeDanglingEdges, removeNode } from "./helpers.js";
+/**
+ * :registry(name) Pseudo-Selector, matches only nodes that
+ * belong to the specified registry configuration alias.
+ *
+ * For example, `:registry(npm)` matches deps from the default
+ * npm registry, and `:registry(custom)` matches deps from a
+ * custom-named registry.
+ */
+export const registry = async (state) => {
+    const top = asPostcssNodeWithChildren(state.current);
+    const selector = asPostcssNodeWithChildren(top.nodes[0]);
+    const name = asTagNode(selector.nodes[0]).value;
+    for (const node of state.partial.nodes) {
+        const tuple = splitDepID(node.id);
+        if (tuple[0] !== 'registry' || tuple[1] !== name) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

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

@@ -4,4 +4,3 @@ import type { ParserState } from '../types.ts';
  * It matches only nodes marked as `mainImporter`.
  */
 export declare const root: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=root.d.ts.map

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

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

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

@@ -6,4 +6,3 @@ import type { ParserState } from '../types.ts';
  * in the security archive.
  */
 export declare const scanned: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=scanned.d.ts.map

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

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

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

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

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

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

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

@@ -7,4 +7,3 @@ import type { ParserState } from '../types.ts';
  * - Prepare scripts on importers or git dependencies (prepare, preprepare, postprepare)
  */
 export declare const scripts: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=scripts.d.ts.map

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

@@ -18,7 +18,7 @@ const nodeNeedsBuild = (node) => {
         return true;
     // Check for prepare scripts on importers or git dependencies
     const prepable = node.id.startsWith('git') || node.importer;
-    const runPrepare = !!((scripts.prepare || scripts.preprepare || scripts.postprepare)
+    const runPrepare = !!(scripts.prepare || scripts.preprepare || scripts.postprepare
     /* c8 ignore next 2 */
     ) && prepable;
     if (runPrepare)
@@ -41,4 +41,3 @@ export const scripts = async (state) => {
     removeDanglingEdges(state);
     return state;
 };
-//# sourceMappingURL=scripts.js.map

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

@@ -5,13 +5,14 @@ import type { PostcssNode } from '@vltpkg/dss-parser';
 export type SemverInternals = {
     semverValue: string;
     semverFunction: SemverComparatorFn;
+    semverRangeFunction: SemverRangeComparatorFn | undefined;
     compareAttribute: SemverCompareAttribute;
 };
-export type SemverFunctionNames = 'satisfies' | 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq';
+export type SemverFunctionNames = 'satisfies' | 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'intersects' | 'subset';
 export type SemverComparatorFn = (version: Version | string, range: string) => boolean;
+export type SemverRangeComparatorFn = (r1: string, r2: string) => boolean;
 export type SemverCompareAttribute = Pick<AttrInternals, 'attribute' | 'properties'> | undefined;
 export declare const isSemverFunctionName: (name: string) => name is SemverFunctionNames;
 export declare const asSemverFunctionName: (name: string) => SemverFunctionNames;
 export declare const parseInternals: (nodes: PostcssNode[], loose: boolean) => SemverInternals;
 export declare const semverParser: (state: ParserState) => Promise<ParserState>;
-//# sourceMappingURL=semver.d.ts.map