@trustify-da/trustify-da-javascript-client 0.3.0-ea.a783c26 → 0.3.0-ea.a87208f

package/dist/src/providers/javascript_bun.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'jsonc-parser';
+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";
+    }
+    _listCmdArgs() {
+        throw new Error("not supported by Bun");
+    }
+    _updateLockFileCmdArgs() {
+        return ['install', '--lockfile-only'];
+    }
+    _buildDependencyTree(includeTransitive, opts = {}) {
+        this._version();
+        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 || {};
+        const memberName = this._getManifest().name;
+        const workspaceEntry = this.#findWorkspaceEntry(lockData, lockDir, manifestDir, memberName);
+        const directDeps = workspaceEntry?.dependencies || {};
+        const tree = { name: memberName, version: this._getManifest().version, dependencies: {} };
+        const visited = new Set();
+        for (const depName of Object.keys(directDeps)) {
+            const resolved = this.#resolvePackage(depName, '', packages);
+            if (resolved) {
+                tree.dependencies[depName] = this.#buildNode(depName, resolved, packages, includeTransitive, visited);
+            }
+        }
+        return tree;
+    }
+    #findWorkspaceEntry(lockData, lockDir, manifestDir, memberName) {
+        const workspaces = lockData.workspaces || {};
+        const relPath = path.relative(lockDir, path.resolve(manifestDir));
+        if (!relPath || relPath === '.') {
+            return workspaces[''] || {};
+        }
+        const normalised = relPath.split(path.sep).join('/');
+        if (workspaces[normalised]) {
+            return workspaces[normalised];
+        }
+        for (const [wsPath, entry] of Object.entries(workspaces)) {
+            if (entry.name === memberName && wsPath !== '') {
+                return entry;
+            }
+        }
+        return workspaces[''] || {};
+    }
+    #resolvePackage(depName, parentKey, packages) {
+        if (parentKey) {
+            const scopedKey = `${parentKey}/${depName}`;
+            if (packages[scopedKey]) {
+                return packages[scopedKey];
+            }
+        }
+        return packages[depName] || null;
+    }
+    #buildNode(depName, resolved, packages, includeTransitive, visited) {
+        const resolvedId = Array.isArray(resolved) ? resolved[0] : resolved;
+        const version = this.#extractVersion(resolvedId);
+        const node = { version };
+        if (!includeTransitive) {
+            return node;
+        }
+        const metadata = Array.isArray(resolved) ? (resolved[2] || {}) : {};
+        const subDeps = metadata.dependencies || {};
+        if (Object.keys(subDeps).length > 0) {
+            const visitKey = `${depName}@${version}`;
+            if (visited.has(visitKey)) {
+                return node;
+            }
+            visited.add(visitKey);
+            node.dependencies = {};
+            for (const subName of Object.keys(subDeps)) {
+                const subResolved = this.#resolvePackage(subName, depName, packages);
+                if (subResolved) {
+                    node.dependencies[subName] = this.#buildNode(subName, subResolved, packages, true, visited);
+                }
+            }
+        }
+        return node;
+    }
+    #extractVersion(resolvedId) {
+        if (typeof resolvedId !== 'string') {
+            return '0.0.0';
+        }
+        const atIdx = resolvedId.lastIndexOf('@');
+        if (atIdx > 0) {
+            return resolvedId.substring(atIdx + 1);
+        }
+        return '0.0.0';
+    }
+}

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,21 +1,71 @@
-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";
     }
     _listCmdArgs(includeTransitive) {
-        return ['ls', includeTransitive ? '--depth=Infinity' : '--depth=0', '--prod', '--json'];
+        return ['ls', includeTransitive ? '--depth=Infinity' : '--depth=0', '--prod', '--json', '-r'];
     }
     _updateLockFileCmdArgs() {
         return ['install', '--frozen-lockfile'];
     }
     _buildDependencyTree(includeTransitive, opts = {}) {
+        // pnpm ls --json returns an array with one entry per workspace package.
+        // When analyzing a workspace member, find its entry by name instead of
+        // blindly taking the first element (which is the workspace root).
         const tree = super._buildDependencyTree(includeTransitive, opts);
         if (Array.isArray(tree) && tree.length > 0) {
-            return tree[0];
+            const memberName = this._getManifest().name;
+            return tree.find(pkg => pkg.name === memberName) || tree[0];
         }
         return {};
     }

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/marker_evaluator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Maps Node.js/OS values to PEP 508 marker variables.
+ * Example: on Linux, sys_platform='linux', platform_system='Linux', os_name='posix'
+ * @returns {Record<string, string>}
+ */
+export function getEnvironmentMarkers(): Record<string, string>;
+/**
+ * Evaluates a full PEP 508 marker expression against the current platform.
+ * Example: "sys_platform == 'win32' and python_version >= '3.8'" → false on Linux
+ * Empty/missing markers return true (unconditional dependency).
+ * @param {string} markerExpr
+ * @returns {boolean}
+ */
+export function evaluateMarker(markerExpr: string): boolean;

package/dist/src/providers/marker_evaluator.js

@@ -0,0 +1,191 @@
+// PEP 508 environment marker evaluator.
+// Filters Python dependencies by platform/version markers so that e.g.
+// "pywin32 ; sys_platform == 'win32'" is excluded on Linux/macOS.
+// See https://peps.python.org/pep-0508/#environment-markers
+import os from 'node:os';
+import { getCustomPath, invokeCommand } from '../tools.js';
+let cachedPythonVersions = undefined;
+function getPythonVersions() {
+    if (cachedPythonVersions !== undefined) {
+        return cachedPythonVersions;
+    }
+    try {
+        let python = getCustomPath('python3');
+        let out = invokeCommand(python, ['-c', "import sys; v=sys.version_info; print(f'{v.major}.{v.minor} {v.major}.{v.minor}.{v.micro}')"], { timeout: 5000 }).toString().trim();
+        let [short, full] = out.split(' ');
+        cachedPythonVersions = { short, full };
+    }
+    catch {
+        cachedPythonVersions = null;
+    }
+    return cachedPythonVersions;
+}
+/**
+ * Maps Node.js/OS values to PEP 508 marker variables.
+ * Example: on Linux, sys_platform='linux', platform_system='Linux', os_name='posix'
+ * @returns {Record<string, string>}
+ */
+export function getEnvironmentMarkers() {
+    let platform = process.platform;
+    let systemMap = { win32: 'Windows', linux: 'Linux', darwin: 'Darwin' };
+    let machine = typeof os.machine === 'function' ? os.machine() : process.arch;
+    let pyVer = getPythonVersions();
+    return {
+        sys_platform: platform,
+        platform_system: systemMap[platform] || platform,
+        os_name: platform === 'win32' ? 'nt' : 'posix',
+        platform_machine: machine,
+        platform_release: os.release(),
+        platform_version: os.version?.() || '',
+        python_version: pyVer?.short || '',
+        python_full_version: pyVer?.full || '',
+        implementation_name: 'cpython',
+    };
+}
+function compareVersions(left, right) {
+    let lParts = left.split('.').map(Number);
+    let rParts = right.split('.').map(Number);
+    let len = Math.max(lParts.length, rParts.length);
+    for (let i = 0; i < len; i++) {
+        let l = lParts[i] || 0;
+        let r = rParts[i] || 0;
+        if (l < r) {
+            return -1;
+        }
+        if (l > r) {
+            return 1;
+        }
+    }
+    return 0;
+}
+// Evaluates a single comparison like sys_platform == 'win32' or python_version >= '3.8'.
+// Version-bearing variables (python_version, python_full_version) use numeric comparison;
+// all others use string equality. Returns false when the env value is missing.
+function evaluateComparison(variable, op, value, env) {
+    let envVal = env[variable];
+    if (envVal === undefined || envVal === '') {
+        return false;
+    }
+    let isVersion = variable.includes('version');
+    if (isVersion) {
+        let cmp = compareVersions(envVal, value);
+        switch (op) {
+            case '==': return cmp === 0;
+            case '!=': return cmp !== 0;
+            case '>=': return cmp >= 0;
+            case '<=': return cmp <= 0;
+            case '>': return cmp > 0;
+            case '<': return cmp < 0;
+            case '~=': {
+                let parts = value.split('.');
+                parts.pop();
+                let prefix = parts.join('.');
+                return envVal.startsWith(prefix) && cmp >= 0;
+            }
+            default: return true;
+        }
+    }
+    switch (op) {
+        case '==': return envVal === value;
+        case '!=': return envVal !== value;
+        case 'in': return value.includes(envVal);
+        case 'not in': return !value.includes(envVal);
+        default: return envVal === value;
+    }
+}
+// Parses a single marker comparison into {variable, op, value}.
+// Handles both normal and reversed forms:
+//   "sys_platform == 'linux'"  → { variable: 'sys_platform', op: '==', value: 'linux' }
+//   "'linux' == sys_platform"  → { variable: 'sys_platform', op: '==', value: 'linux' }
+function parseAtom(expr) {
+    // Normal form: variable op 'value'
+    let m = expr.match(/^\s*([\w.]+)\s*(~=|!=|==|>=|<=|>|<|not\s+in|in)\s*["']([^"']*)["']\s*$/);
+    if (m) {
+        return { variable: m[1], op: m[2].replace(/\s+/g, ' '), value: m[3] };
+    }
+    // Reversed form: 'value' op variable — reverse directional operators
+    let mReverse = expr.match(/^\s*["']([^"']*)['"]\s*(~=|!=|==|>=|<=|>|<|not\s+in|in)\s*([\w.]+)\s*$/);
+    if (mReverse) {
+        let reverseOp = { '<': '>', '>': '<', '<=': '>=', '>=': '<=' };
+        let op = mReverse[2].replace(/\s+/g, ' ');
+        return { variable: mReverse[3], op: reverseOp[op] || op, value: mReverse[1] };
+    }
+    return null;
+}
+/**
+ * Evaluates a full PEP 508 marker expression against the current platform.
+ * Example: "sys_platform == 'win32' and python_version >= '3.8'" → false on Linux
+ * Empty/missing markers return true (unconditional dependency).
+ * @param {string} markerExpr
+ * @returns {boolean}
+ */
+export function evaluateMarker(markerExpr) {
+    if (!markerExpr || !markerExpr.trim()) {
+        return true;
+    }
+    let env = getEnvironmentMarkers();
+    return evaluateExpr(markerExpr.trim(), env);
+}
+function evaluateExpr(expr, env) {
+    let orParts = splitLogical(expr, ' or ');
+    if (orParts.length > 1) {
+        return orParts.some(part => evaluateExpr(part, env));
+    }
+    let andParts = splitLogical(expr, ' and ');
+    if (andParts.length > 1) {
+        return andParts.every(part => evaluateExpr(part, env));
+    }
+    let trimmed = expr.trim();
+    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+        return evaluateExpr(trimmed.slice(1, -1), env);
+    }
+    let atom = parseAtom(trimmed);
+    if (!atom) {
+        return true;
+    }
+    return evaluateComparison(atom.variable, atom.op, atom.value, env);
+}
+// Splits an expression by " and " or " or " at the top level, skipping
+// separators inside parentheses or quoted strings.
+// Example: splitLogical("a == 'x' and (b == 'y' or c == 'z')", " and ")
+//        → ["a == 'x'", "(b == 'y' or c == 'z')"]
+function splitLogical(expr, sep) {
+    let parts = [];
+    let depth = 0;
+    let current = '';
+    let i = 0;
+    let quoteChar = null;
+    while (i < expr.length) {
+        let ch = expr[i];
+        if (quoteChar) {
+            if (ch === quoteChar) {
+                quoteChar = null;
+            }
+            current += ch;
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quoteChar = ch;
+            current += ch;
+            i++;
+            continue;
+        }
+        if (ch === '(') {
+            depth++;
+        }
+        if (ch === ')') {
+            depth--;
+        }
+        if (depth === 0 && expr.substring(i, i + sep.length) === sep) {
+            parts.push(current);
+            current = '';
+            i += sep.length;
+            continue;
+        }
+        current += ch;
+        i++;
+    }
+    parts.push(current);
+    return parts.filter(p => p.trim());
+}

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;