@trustify-da/trustify-da-javascript-client 0.3.0-ea.e660b02 → 0.3.0-ea.efdc87d

package/dist/src/providers/javascript_bun.js

@@ -1,11 +1,51 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'jsonc-parser';
-import Base_javascript from './base_javascript.js';
+import Base_javascript, { sriToHash } from './base_javascript.js';
 export default class Javascript_bun extends Base_javascript {
     _lockFileName() {
         return "bun.lock";
     }
+    /**
+     * Parses `bun.lock` into a hash map keyed by `name@version`. Each entry in
+     * the `packages` section is an array whose first element is the resolved id
+     * (`name@version`) and whose fourth element is the SRI integrity string.
+     * @param {string} lockDir - Directory containing bun.lock
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    _parseLockFileHashes(lockDir) {
+        const map = new Map();
+        const lockPath = path.join(lockDir, this._lockFileName());
+        if (!fs.existsSync(lockPath)) {
+            return map;
+        }
+        let lockData;
+        try {
+            lockData = parse(fs.readFileSync(lockPath, 'utf-8'));
+        }
+        catch (_) {
+            return map;
+        }
+        const packages = lockData?.packages || {};
+        for (const entry of Object.values(packages)) {
+            if (!Array.isArray(entry) || typeof entry[0] !== 'string' || typeof entry[3] !== 'string') {
+                continue;
+            }
+            const id = entry[0];
+            const at = id.lastIndexOf('@');
+            if (at <= 0) {
+                continue;
+            }
+            const name = id.slice(0, at);
+            const version = id.slice(at + 1);
+            const hash = sriToHash(entry[3]);
+            if (name && version && hash) {
+                map.set(`${name}@${version}`, [hash]);
+            }
+        }
+        return map;
+    }
     _cmdName() {
         return "bun";
     }
@@ -20,6 +60,7 @@ export default class Javascript_bun extends Base_javascript {
         const manifestDir = path.dirname(this._getManifest().manifestPath);
         const lockDir = this._findLockFileDir(manifestDir, opts) || manifestDir;
         this._createLockFile(lockDir);
+        this._loadHashes(lockDir);
         const lockContent = fs.readFileSync(path.join(lockDir, 'bun.lock'), 'utf-8');
         const lockData = parse(lockContent);
         const packages = lockData.packages || {};

package/dist/src/providers/javascript_npm.d.ts

@@ -1,5 +1,23 @@
 export default class Javascript_npm extends Base_javascript {
+    /**
+     * Parses `package-lock.json` (lockfileVersion 2/3) into a hash map keyed by
+     * `name@version`. Each `packages` entry is keyed by its install path
+     * (e.g. `node_modules/@hapi/joi`); the package name is the segment after the
+     * final `node_modules/`. The `integrity` field holds an SRI string.
+     * @param {string} lockDir - Directory containing package-lock.json
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    protected _parseLockFileHashes(lockDir: string): Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>;
     _listCmdArgs(includeTransitive: any): string[];
-    _buildDependencyTree(includeTransitive: any, opts?: {}): any;
+    _buildDependencyTree(includeTransitive: any, opts?: {}): Object | {
+        name: any;
+        version: any;
+        dependencies: any;
+        optionalDependencies: any;
+    };
 }
 import Base_javascript from './base_javascript.js';

package/dist/src/providers/javascript_npm.js

@@ -1,8 +1,47 @@
-import Base_javascript from './base_javascript.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import Base_javascript, { sriToHash } from './base_javascript.js';
 export default class Javascript_npm extends Base_javascript {
     _lockFileName() {
         return "package-lock.json";
     }
+    /**
+     * Parses `package-lock.json` (lockfileVersion 2/3) into a hash map keyed by
+     * `name@version`. Each `packages` entry is keyed by its install path
+     * (e.g. `node_modules/@hapi/joi`); the package name is the segment after the
+     * final `node_modules/`. The `integrity` field holds an SRI string.
+     * @param {string} lockDir - Directory containing package-lock.json
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    _parseLockFileHashes(lockDir) {
+        const map = new Map();
+        const lockPath = path.join(lockDir, this._lockFileName());
+        if (!fs.existsSync(lockPath)) {
+            return map;
+        }
+        let lock;
+        try {
+            lock = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+        }
+        catch (_) {
+            return map;
+        }
+        const packages = lock.packages || {};
+        for (const [pkgPath, entry] of Object.entries(packages)) {
+            if (!pkgPath || !entry || !entry.integrity || !entry.version) {
+                continue;
+            }
+            const marker = 'node_modules/';
+            const idx = pkgPath.lastIndexOf(marker);
+            const name = idx < 0 ? pkgPath : pkgPath.slice(idx + marker.length);
+            const hash = sriToHash(entry.integrity);
+            if (name && hash) {
+                map.set(`${name}@${entry.version}`, [hash]);
+            }
+        }
+        return map;
+    }
     _cmdName() {
         return "npm";
     }

package/dist/src/providers/javascript_pnpm.d.ts

@@ -1,4 +1,17 @@
 export default class Javascript_pnpm extends Base_javascript {
+    /**
+     * Parses `pnpm-lock.yaml` (lockfileVersion 9) into a hash map keyed by
+     * `name@version`. Entries in the `packages` section are keyed by
+     * `<name>@<version>` (optionally followed by a `(peer@x)` suffix); the
+     * `resolution.integrity` field holds an SRI string.
+     * @param {string} lockDir - Directory containing pnpm-lock.yaml
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    protected _parseLockFileHashes(lockDir: string): Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>;
     _listCmdArgs(includeTransitive: any): string[];
     _buildDependencyTree(includeTransitive: any, opts?: {}): any;
 }

package/dist/src/providers/javascript_pnpm.js

@@ -1,8 +1,54 @@
-import Base_javascript from './base_javascript.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { load as yamlLoad } from 'js-yaml';
+import Base_javascript, { sriToHash } from './base_javascript.js';
 export default class Javascript_pnpm extends Base_javascript {
     _lockFileName() {
         return "pnpm-lock.yaml";
     }
+    /**
+     * Parses `pnpm-lock.yaml` (lockfileVersion 9) into a hash map keyed by
+     * `name@version`. Entries in the `packages` section are keyed by
+     * `<name>@<version>` (optionally followed by a `(peer@x)` suffix); the
+     * `resolution.integrity` field holds an SRI string.
+     * @param {string} lockDir - Directory containing pnpm-lock.yaml
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    _parseLockFileHashes(lockDir) {
+        const map = new Map();
+        const lockPath = path.join(lockDir, this._lockFileName());
+        if (!fs.existsSync(lockPath)) {
+            return map;
+        }
+        let lock;
+        try {
+            lock = yamlLoad(fs.readFileSync(lockPath, 'utf-8'));
+        }
+        catch (_) {
+            return map;
+        }
+        const packages = lock?.packages || {};
+        for (const [key, entry] of Object.entries(packages)) {
+            const integrity = entry?.resolution?.integrity;
+            if (!key || !integrity) {
+                continue;
+            }
+            // Strip any peer-dependency suffix, then split name from version
+            const base = key.split('(')[0];
+            const at = base.lastIndexOf('@');
+            if (at <= 0) {
+                continue;
+            }
+            const name = base.slice(0, at);
+            const version = base.slice(at + 1);
+            const hash = sriToHash(integrity);
+            if (name && version && hash) {
+                map.set(`${name}@${version}`, [hash]);
+            }
+        }
+        return map;
+    }
     _cmdName() {
         return "pnpm";
     }

package/dist/src/providers/javascript_yarn.d.ts

@@ -1,5 +1,17 @@
 export default class Javascript_yarn extends Base_javascript {
     static VERSION_PATTERN: RegExp;
+    /**
+     * Parses `yarn.lock` into a hash map keyed by `name@version`. Supports both
+     * Yarn Classic (v1) entries with an `integrity` SRI field and Yarn Berry
+     * (v2+) entries with a `checksum` field.
+     * @param {string} lockDir - Directory containing yarn.lock
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    protected _parseLockFileHashes(lockDir: string): Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>;
     _listCmdArgs(includeTransitive: any, manifestDir: any): any;
     _updateLockFileCmdArgs(manifestDir: any): any;
     _setUp(manifestPath: any, opts: any): void;

package/dist/src/providers/javascript_yarn.js

@@ -1,12 +1,85 @@
-import Base_javascript from './base_javascript.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSyml } from '@yarnpkg/parsers';
+import Base_javascript, { sriToHash } from './base_javascript.js';
 import Yarn_berry_processor from './processors/yarn_berry_processor.js';
 import Yarn_classic_processor from './processors/yarn_classic_processor.js';
+/**
+ * Converts a Yarn Berry `checksum` value to a CycloneDX hash object. Berry
+ * checksums are formatted as `<cacheKey>/<hex-sha512>`; the digest is the
+ * hex-encoded SHA-512 following the final slash.
+ * @param {string} checksum - The checksum field value
+ * @returns {{alg: string, content: string}|null} CycloneDX hash, or null
+ */
+function berryChecksumToHash(checksum) {
+    if (typeof checksum !== 'string') {
+        return null;
+    }
+    const slash = checksum.lastIndexOf('/');
+    const hex = (slash >= 0 ? checksum.slice(slash + 1) : checksum).trim();
+    if (!/^[0-9a-f]+$/i.test(hex)) {
+        return null;
+    }
+    return { alg: 'SHA-512', content: hex.toLowerCase() };
+}
 export default class Javascript_yarn extends Base_javascript {
     static VERSION_PATTERN = /^([0-9]+)\./;
     #processor;
     _lockFileName() {
         return "yarn.lock";
     }
+    /**
+     * Parses `yarn.lock` into a hash map keyed by `name@version`. Supports both
+     * Yarn Classic (v1) entries with an `integrity` SRI field and Yarn Berry
+     * (v2+) entries with a `checksum` field.
+     * @param {string} lockDir - Directory containing yarn.lock
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    _parseLockFileHashes(lockDir) {
+        const map = new Map();
+        const lockPath = path.join(lockDir, this._lockFileName());
+        if (!fs.existsSync(lockPath)) {
+            return map;
+        }
+        let content;
+        try {
+            content = fs.readFileSync(lockPath, 'utf-8');
+        }
+        catch (_) {
+            return map;
+        }
+        const parsed = parseSyml(content);
+        for (const [spec, entry] of Object.entries(parsed)) {
+            if (spec === '__metadata') {
+                continue;
+            }
+            const version = entry.version;
+            if (!version) {
+                continue;
+            }
+            let hash = null;
+            if (entry.integrity) {
+                hash = sriToHash(entry.integrity);
+            }
+            else if (entry.checksum) {
+                hash = berryChecksumToHash(entry.checksum);
+            }
+            if (!hash) {
+                continue;
+            }
+            // Handle comma-separated specifiers (e.g., "pkg@^1.0.0, pkg@^2.0.0")
+            for (const rawSpec of spec.split(',')) {
+                const trimmed = rawSpec.trim();
+                const atIndex = trimmed.lastIndexOf('@');
+                if (atIndex > 0) {
+                    const name = trimmed.slice(0, atIndex);
+                    map.set(`${name}@${version}`, [hash]);
+                }
+            }
+        }
+        return map;
+    }
     _cmdName() {
         return "yarn";
     }
@@ -34,6 +107,6 @@ export default class Javascript_yarn extends Base_javascript {
         return this.#processor.parseDepTreeOutput(output);
     }
     _addDependenciesToSbom(sbom, depTree) {
-        this.#processor.addDependenciesToSbom(sbom, depTree);
+        this.#processor.addDependenciesToSbom(sbom, depTree, purl => this._hashesForPurl(purl));
     }
 }

package/dist/src/providers/manifest.js

@@ -55,11 +55,14 @@ export default class Manifest {
     }
     loadIgnored(content) {
         let deps = [];
-        if (!content.exhortignore) {
+        // Prefer the new 'trustify-da-ignore' key, falling back to the legacy
+        // 'exhortignore' key for backwards compatibility.
+        let ignored = content['trustify-da-ignore'] || content.exhortignore;
+        if (!ignored) {
             return deps;
         }
-        for (let i = 0; i < content.exhortignore.length; i++) {
-            deps.push(toPurl("npm", content.exhortignore[i]));
+        for (let i = 0; i < ignored.length; i++) {
+            deps.push(toPurl("npm", ignored[i]));
         }
         return deps;
     }

package/dist/src/providers/oci_dockerfile.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Parse all FROM instructions from a Dockerfile using tree-sitter to extract base image references.
+ * In multi-stage builds, every FROM line is returned so each image can be analyzed independently.
+ * ARG substitutions are resolved using declared default values. FROM lines with unresolvable
+ * variables (ARGs without defaults) are silently skipped.
+ * @param {string} manifestContent the content of the Dockerfile
+ * @returns {Promise<string[]>} array of image references from all resolvable FROM instructions
+ * @throws {Error} when no FROM instruction is found or when no FROM lines can be resolved
+ */
+export function parseAllFromImages(manifestContent: string): Promise<string[]>;
+declare namespace _default {
+    export { isSupported };
+    export { validateLockFile };
+    export { provideComponent };
+    export { provideStack };
+    export { readLicenseFromManifest };
+    export function packageManagerName(): string;
+}
+export default _default;
+export type Provided = any;
+/**
+ * Check if the given manifest name is a Dockerfile or Containerfile.
+ * Supports dot-suffixed variants such as Dockerfile.dev or Containerfile.prod.
+ * @param {string} manifestName the manifest file name to check
+ * @returns {boolean} true if the manifest is a Dockerfile or Containerfile
+ */
+declare function isSupported(manifestName: string): boolean;
+/**
+ * Dockerfiles have no lock file, so validation always passes.
+ * @returns {boolean} always true
+ */
+declare function validateLockFile(): boolean;
+/**
+ * Provide content and content type for Dockerfile component analysis.
+ * @param {string} manifest path to the Dockerfile
+ * @param {{}} [opts={}] optional various options to pass along the application
+ * @returns {Promise<Provided>}
+ */
+declare function provideComponent(manifest: string, opts?: {}): Promise<Provided>;
+/**
+ * Provide content and content type for Dockerfile stack analysis.
+ * @param {string} manifest path to the Dockerfile
+ * @param {{}} [opts={}] optional various options to pass along the application
+ * @returns {Promise<Provided>}
+ */
+declare function provideStack(manifest: string, opts?: {}): Promise<Provided>;
+/**
+ * Dockerfiles contain no license information.
+ * @returns {null} always null
+ */
+declare function readLicenseFromManifest(): null;

package/dist/src/providers/oci_dockerfile.js

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import { generateImageSBOM, parseImageRef } from '../oci_image/utils.js';
+import { getArgQuery, getFromQuery, getParser } from './containerfile_parser.js';
+export default { isSupported, validateLockFile, provideComponent, provideStack, readLicenseFromManifest, packageManagerName() { return 'oci'; } };
+/** @typedef {import('../provider').Provider} */
+/** @typedef {import('../provider').Provided} Provided */
+/**
+ * @type {string} ecosystem identifier for OCI image packages
+ * @private
+ */
+const ecosystem = 'oci';
+/**
+ * Check if the given manifest name is a Dockerfile or Containerfile.
+ * Supports dot-suffixed variants such as Dockerfile.dev or Containerfile.prod.
+ * @param {string} manifestName the manifest file name to check
+ * @returns {boolean} true if the manifest is a Dockerfile or Containerfile
+ */
+function isSupported(manifestName) {
+    return /^(Dockerfile|Containerfile)(\..+)?$/.test(manifestName);
+}
+/**
+ * Dockerfiles have no lock file, so validation always passes.
+ * @returns {boolean} always true
+ */
+function validateLockFile() { return true; }
+/**
+ * Check whether a syntax node contains any expansion (variable substitution) children.
+ * @param {import('web-tree-sitter').SyntaxNode} node
+ * @returns {boolean}
+ * @private
+ */
+function containsExpansion(node) {
+    if (node.type === 'expansion') {
+        return true;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        if (containsExpansion(node.child(i))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Strip surrounding single or double quotes from a string.
+ * @param {string} text
+ * @returns {string}
+ * @private
+ */
+function stripQuotes(text) {
+    if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+        return text.slice(1, -1);
+    }
+    return text;
+}
+/**
+ * Collect ARG key-value pairs from the Dockerfile AST.
+ * Only ARGs with a default value are collected (ARGs without defaults cannot be resolved statically).
+ * @param {import('web-tree-sitter').Tree} tree the parsed Dockerfile tree
+ * @param {import('web-tree-sitter').Query} argQuery the tree-sitter query for arg_instruction nodes
+ * @returns {Map<string, string>} map of ARG names to their default values
+ * @private
+ */
+function collectArgs(tree, argQuery) {
+    const args = new Map();
+    for (const match of argQuery.matches(tree.rootNode)) {
+        const name = match.captures.find(c => c.name === 'name')?.node.text;
+        const defaultValue = match.captures.find(c => c.name === 'default')?.node.text;
+        if (name && defaultValue) {
+            args.set(name, stripQuotes(defaultValue));
+        }
+    }
+    return args;
+}
+/**
+ * Resolve ARG substitutions in an image spec text using the collected ARG map.
+ * Replaces ${VAR} and $VAR patterns with their ARG default values.
+ * @param {string} text the image spec text potentially containing variable references
+ * @param {Map<string, string>} args map of ARG names to their default values
+ * @returns {string|null} the resolved text, or null if any variable could not be resolved
+ * @private
+ */
+function resolveArgs(text, args) {
+    let resolved = text;
+    let hasUnresolved = false;
+    resolved = resolved.replace(/\$\{([^}]+)\}|\$([A-Za-z_]\w*)/g, (_match, braced, plain) => {
+        const key = braced || plain;
+        if (args.has(key)) {
+            return args.get(key);
+        }
+        hasUnresolved = true;
+        return _match;
+    });
+    return hasUnresolved ? null : resolved;
+}
+/**
+ * Parse all FROM instructions from a Dockerfile using tree-sitter to extract base image references.
+ * In multi-stage builds, every FROM line is returned so each image can be analyzed independently.
+ * ARG substitutions are resolved using declared default values. FROM lines with unresolvable
+ * variables (ARGs without defaults) are silently skipped.
+ * @param {string} manifestContent the content of the Dockerfile
+ * @returns {Promise<string[]>} array of image references from all resolvable FROM instructions
+ * @throws {Error} when no FROM instruction is found or when no FROM lines can be resolved
+ */
+export async function parseAllFromImages(manifestContent) {
+    const [parser, fromQuery, argQuery] = await Promise.all([getParser(), getFromQuery(), getArgQuery()]);
+    const tree = parser.parse(manifestContent);
+    const matches = fromQuery.matches(tree.rootNode);
+    if (matches.length === 0) {
+        throw new Error('No FROM line found in Dockerfile');
+    }
+    const args = collectArgs(tree, argQuery);
+    const images = [];
+    for (const match of matches) {
+        const imageSpec = match.captures.find(c => c.name === 'image').node;
+        if (containsExpansion(imageSpec)) {
+            const resolved = resolveArgs(imageSpec.text, args);
+            if (resolved != null) {
+                images.push(resolved);
+            }
+            continue;
+        }
+        images.push(imageSpec.text);
+    }
+    if (images.length === 0) {
+        throw new Error('Dockerfile uses ARG substitution in all FROM lines — cannot resolve variable references');
+    }
+    return images;
+}
+/**
+ * Generate image SBOMs for all FROM instructions in a Dockerfile manifest using syft.
+ * Returns a batch result with a purl-to-SBOM map suitable for the batch-analysis endpoint.
+ * @param {string} manifest path to the Dockerfile
+ * @param {{}} [opts={}] optional various options to pass along the application
+ * @returns {Promise<{ecosystem: string, content: string, contentType: string, batch: boolean}>}
+ * @private
+ */
+async function getImageSBOM(manifest, opts = {}) {
+    const manifestContent = fs.readFileSync(manifest, 'utf-8');
+    const images = await parseAllFromImages(manifestContent);
+    const sbomByPurl = {};
+    for (const image of images) {
+        const imageRef = parseImageRef(image, opts);
+        const purl = imageRef.getPackageURL().toString();
+        if (purl in sbomByPurl)
+            continue;
+        sbomByPurl[purl] = generateImageSBOM(imageRef, opts);
+    }
+    return {
+        ecosystem,
+        content: JSON.stringify(sbomByPurl),
+        contentType: 'application/vnd.cyclonedx+json',
+        batch: true
+    };
+}
+/**
+ * Provide content and content type for Dockerfile component analysis.
+ * @param {string} manifest path to the Dockerfile
+ * @param {{}} [opts={}] optional various options to pass along the application
+ * @returns {Promise<Provided>}
+ */
+async function provideComponent(manifest, opts = {}) {
+    return getImageSBOM(manifest, opts);
+}
+/**
+ * Provide content and content type for Dockerfile stack analysis.
+ * @param {string} manifest path to the Dockerfile
+ * @param {{}} [opts={}] optional various options to pass along the application
+ * @returns {Promise<Provided>}
+ */
+async function provideStack(manifest, opts = {}) {
+    return getImageSBOM(manifest, opts);
+}
+/**
+ * Dockerfiles contain no license information.
+ * @returns {null} always null
+ */
+function readLicenseFromManifest() { return null; }

package/dist/src/providers/processors/yarn_berry_processor.d.ts

@@ -29,13 +29,17 @@ export default class Yarn_berry_processor extends Yarn_processor {
    * @param {Object} depTree - The dependency tree object
    * @returns {Map<string, PackageURL>} Map of dependency names to their PackageURL objects
    */
-    getRootDependencies(depTree: any): Map<string, PackageURL>;
+    getRootDependencies(depTree: Object): Map<string, PackageURL>;
     /**
    * Adds dependencies to the SBOM
    * @param {Sbom} sbom - The SBOM object to add dependencies to
    * @param {Object} depTree - The dependency tree object
+   * @param {function(PackageURL): (Array<{alg: string, content: string}>|undefined)} [hashesForPurl] - Resolves lock-file hashes for a purl
    */
-    addDependenciesToSbom(sbom: Sbom, depTree: any): void;
+    addDependenciesToSbom(sbom: Sbom, depTree: Object, hashesForPurl?: (arg0: PackageURL) => (Array<{
+        alg: string;
+        content: string;
+    }> | undefined)): void;
     #private;
 }
 import Yarn_processor from "./yarn_processor.js";

package/dist/src/providers/processors/yarn_berry_processor.js

@@ -78,8 +78,9 @@ export default class Yarn_berry_processor extends Yarn_processor {
    * Adds dependencies to the SBOM
    * @param {Sbom} sbom - The SBOM object to add dependencies to
    * @param {Object} depTree - The dependency tree object
+   * @param {function(PackageURL): (Array<{alg: string, content: string}>|undefined)} [hashesForPurl] - Resolves lock-file hashes for a purl
    */
-    addDependenciesToSbom(sbom, depTree) {
+    addDependenciesToSbom(sbom, depTree, hashesForPurl = () => undefined) {
         if (!depTree) {
             return;
         }
@@ -137,7 +138,7 @@ export default class Yarn_berry_processor extends Yarn_processor {
                 }
                 const to = this.#purlFromLocator(d.locator);
                 if (to) {
-                    sbom.addDependency(from, to);
+                    sbom.addDependency(from, to, undefined, hashesForPurl(to));
                 }
             });
         });

package/dist/src/providers/processors/yarn_classic_processor.d.ts

@@ -25,13 +25,17 @@ export default class Yarn_classic_processor extends Yarn_processor {
    * @param {Object} depTree - The dependency tree object
    * @returns {Map<string, PackageURL>} Map of dependency names to their PackageURL objects
    */
-    getRootDependencies(depTree: any): Map<string, PackageURL>;
+    getRootDependencies(depTree: Object): Map<string, PackageURL>;
     /**
    * Adds dependencies to the SBOM
    * @param {Sbom} sbom - The SBOM object to add dependencies to
    * @param {Object} depTree - The dependency tree object
+   * @param {function(PackageURL): (Array<{alg: string, content: string}>|undefined)} [hashesForPurl] - Resolves lock-file hashes for a purl
    */
-    addDependenciesToSbom(sbom: Sbom, depTree: any): void;
+    addDependenciesToSbom(sbom: Sbom, depTree: Object, hashesForPurl?: (arg0: PackageURL) => (Array<{
+        alg: string;
+        content: string;
+    }> | undefined)): void;
     #private;
 }
 import Yarn_processor from "./yarn_processor.js";