@cdxgen/cdxgen 13.1.0 → 13.2.0

package/types/lib/ecosystems/parsers-elm.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Parse an Elm project from its 0.19 `elm.json`.
+ *
+ * @param {string} elmJsonFile Path to `elm.json`
+ * @param {object} [cacheReader] Reader returned by {@link createElmCacheReader};
+ *   when omitted, one is derived from the manifest's pinned compiler version
+ * @returns {{ pkgList: object[], dependencies: object[], parentComponent: object, rootInputs: string[] }}
+ */
+export declare function parseElmProject(elmJsonFile: string, cacheReader?: object): {
+    pkgList: object[];
+    dependencies: object[];
+    parentComponent: object;
+    rootInputs: string[];
+};
+/**
+ * Parse a legacy 0.18 Elm project from `elm-package.json` and its optional
+ * `elm-stuff/exact-dependencies.json` lock file.
+ *
+ * @param {string} elmPackageJsonFile Path to `elm-package.json`
+ * @param {string} [exactDepsFile] Path to the lock file, if present
+ * @returns {{ pkgList: object[], dependencies: object[], parentComponent: object, rootInputs: string[] }}
+ */
+export declare function parseLegacyElmProject(elmPackageJsonFile: string, exactDepsFile?: string): {
+    pkgList: object[];
+    dependencies: object[];
+    parentComponent: object;
+    rootInputs: string[];
+};
+/**
+ * Tell whether a candidate `elm.json` really is an Elm manifest. The file
+ * name is distinctive but lives in every Elm project, so detection only
+ * needs a cheap content check before dispatching.
+ *
+ * @param {string} filePath Path to the candidate `elm.json`
+ * @returns {boolean} true when the file declares an Elm project
+ */
+export declare function isElmProjectFile(filePath: string): boolean;
+/**
+ * Create a reader for the local Elm package cache. Reads are memoised and
+ * silently disabled when the cache directory does not exist.
+ *
+ * @param {string} [elmVersionHint] Exact compiler version directory to try
+ *   first, when the project pins one
+ * @returns {{ readMetadata: (name: string, version: string) => object|null, listVersions: (name: string) => string[] }}
+ */
+export declare function createElmCacheReader(elmVersionHint?: string): {
+    readMetadata: (name: string, version: string) => object | null;
+    listVersions: (name: string) => string[];
+};
+/**
+ * Whether the registry's `robots.txt` permits fetching a package's documents.
+ *
+ * @param {string} name Package name, `author/project`
+ * @returns {boolean} true when no `Disallow` rule covers the package
+ */
+export declare function isRegistryCrawlable(name: string): boolean;
+/**
+ * Enrich Elm components from the package registry.
+ *
+ * Only the gaps left by the local cache are fetched, and only for packages
+ * with a resolved version that `robots.txt` permits. Two documents are read
+ * per package, both of which the compiler itself reads when it installs one:
+ *
+ *   - `elm.json` — the published manifest, carrying the summary, the license
+ *     and the package's own dependencies, which close the gaps in the
+ *     dependency graph that an unpopulated cache leaves behind.
+ *   - `endpoint.json` — the source archive URL and the SHA-1 of its bytes,
+ *     which the compiler verifies after downloading. It becomes the
+ *     component's distribution reference and hash.
+ *
+ * Requests carry cdxgen's contact user-agent and pass through the shared
+ * per-host rate policy for `package.elm-lang.org` (see `fetchRate.js`).
+ *
+ * @param {object[]} pkgList Components to enrich, mutated in place
+ * @param {object[]} [dependencies] Dependency edges to complete in place
+ * @returns {Promise<object[]>} The same package list
+ */
+export declare function getElmMetadata(pkgList: object[], dependencies?: object[]): Promise<object[]>;
+//# sourceMappingURL=parsers-elm.d.ts.map

package/types/lib/ecosystems/parsers-elm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-elm.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-elm.js"],"names":[],"mappings":"AAiEA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EALhC,MAKgC,EAAE,WAAW,AAJrD,CAEA,EAFQ,MAI6C,GAF3C;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAoGxG;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,kBAAkB,EAJ7C,MAI6C,EAAE,aAAa,AAHpE,CACA,EADQ,MAG4D,GAF1D;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAyFxG;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAH9B,MAG8B,GAF5B,OAAO,CAKnB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,AAJhD,CAEA,EAFQ,MAIwC,GAFtC;IAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,GAAC,IAAI,CAAC;IAAC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,CAAA;CAAE,CA6FtH;AAmRD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAH7B,MAG6B,GAF3B,OAAO,CAKnB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAJjC,MAAM,EAI2B,EAAE,YAAY,AAHvD,CACA,EADQ,MAAM,EAGyC,GAF7C,OAAO,CAAC,MAAM,EAAE,CAAC,CAyD7B"}

package/types/lib/ecosystems/parsers-julia.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Julia project parser.
+ *
+ * Two files are consulted:
+ *   - `Project.toml` — the manifest holding the project name, UUID, version,
+ *     the names (and UUIDs) of its direct dependencies, and version
+ *     compatibility constraints.
+ *   - `Manifest.toml` — the lock file written by Pkg on resolve, pinning every
+ *     package in the environment with its UUID, version, content hash, and the
+ *     names of the packages it depends on.
+ *
+ * Packages are identified with the registered `julia` purl type, which carries
+ * the package UUID as a required qualifier (`pkg:julia/JSON@0.21.4?uuid=…`).
+ * The UUID is what Julia itself uses to identify packages, so keeping it in
+ * the purl lets consumers match components across differently named mirrors.
+ *
+ * Julia standard libraries ship with the language itself and carry no version
+ * in the manifest; they are emitted without a version and marked as standard
+ * libraries so they can be told apart from registry packages.
+ */
+/**
+ * Parse a Julia environment from its `Project.toml` and optional
+ * `Manifest.toml`.
+ *
+ * @param {string} [projectTomlFile] Path to `Project.toml`, if present
+ * @param {string} [manifestTomlFile] Path to `Manifest.toml`, if present
+ * @returns {{ pkgList: object[], dependencies: object[], parentComponent: object, rootInputs?: string[] }}
+ */
+export declare function parseJuliaProject(projectTomlFile?: string, manifestTomlFile?: string): {
+    pkgList: object[];
+    dependencies: object[];
+    parentComponent: object;
+    rootInputs?: string[];
+};
+/**
+ * Tell whether a `Project.toml` declares a Julia environment.
+ *
+ * Cloud Native Buildpacks and Gleam use the same file names, so the caller
+ * needs a content check before dispatching. A Julia project always carries a
+ * package `uuid`, a `[deps]` table, or a `[compat]` table.
+ *
+ * @param {string} filePath Path to the candidate `Project.toml`
+ * @returns {boolean} true when the file is a Julia project
+ */
+export declare function isJuliaProjectFile(filePath: string): boolean;
+/**
+ * Tell whether a `Manifest.toml` is a Julia lock file.
+ *
+ * Gleam writes a lowercase `manifest.toml` that case-insensitive filesystems
+ * surface under the same glob; a Julia manifest is recognised by its
+ * `manifest_format` marker or its `[[deps.<Name>]]` tables.
+ *
+ * @param {string} filePath Path to the candidate `Manifest.toml`
+ * @returns {boolean} true when the file is a Julia manifest
+ */
+export declare function isJuliaManifestFile(filePath: string): boolean;
+//# sourceMappingURL=parsers-julia.d.ts.map

package/types/lib/ecosystems/parsers-julia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-julia.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-julia.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,AAJ9C,CACA,EADQ,MAIsC,EAAE,gBAAgB,AAHhE,CACA,EADQ,MAGwD,GAFtD;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA+FzG;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAHhC,MAGgC,GAF9B,OAAO,CAUnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAHjC,MAGiC,GAF/B,OAAO,CASnB"}

package/types/lib/ecosystems/parsers-lua.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Lua parser for rockspecs and `luarocks.lock`.
+ *
+ * A rockspec is a Lua source file whose top level is a sequence of
+ * assignments describing one package: its name, version, source, and a
+ * `dependencies` table of constraint strings (`"lua >= 5.1"`). LuaRocks 3
+ * can also persist the resolved set to `luarocks.lock`. Both are read with a
+ * small line scanner over the shapes these files actually use, rather than a
+ * Lua interpreter.
+ *
+ * Rocks are identified with the registered `luarocks` purl type
+ * (`pkg:luarocks/<name>@<version>`). Lua versions carry a rock revision
+ * suffix (`5.4.6-1`); the full rock version is kept verbatim because the
+ * revision distinguishes distinct builds.
+ */
+/**
+ * Parse a rockspec manifest.
+ *
+ * @param {string} rockspecFile Path to the `.rockspec` file
+ * @returns {{ pkgList: object[], parentComponent: object }}
+ */
+export declare function parseRockspecFile(rockspecFile: string): {
+    pkgList: object[];
+    parentComponent: object;
+};
+/**
+ * Parse a `luarocks.lock` file.
+ *
+ * @param {string} lockFile Path to `luarocks.lock`
+ * @param {string} [rockspecFile] Path to the rockspec, to mark direct deps
+ * @returns {{ pkgList: object[], parentComponent: object }}
+ */
+export declare function parseLuaRocksLock(lockFile: string, rockspecFile?: string): {
+    pkgList: object[];
+    parentComponent: object;
+};
+/**
+ * Read the top-level assignments of a Lua configuration file.
+ *
+ * The files cdxgen consumes use a constrained surface: `key = value` lines
+ * where the value is a quoted string, a table of strings or
+ * `["key"] = "value"` entries, or a short list expression. Values are
+ * normalised to strings, arrays of `{name, constraint}` records, or arrays
+ * of `{key, value}` records for mixed tables.
+ *
+ * @param {string} filePath File to read
+ * @returns {Map<string, *>} Parsed top-level fields
+ */
+export declare function readLuaAssignments(filePath: string): Map<string, any>;
+//# sourceMappingURL=parsers-lua.d.ts.map

package/types/lib/ecosystems/parsers-lua.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-lua.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-lua.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAHnC,MAGmC,GAFjC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CA4B1D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAJ/B,MAI+B,EAAE,YAAY,AAHrD,CACA,EADQ,MAG6C,GAF3C;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CA8B1D;AAuCD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAHhC,MAGgC,GAF9B,GAAG,CAAC,MAAM,EAAE,GAAC,CAAC,CA4D1B"}

package/types/lib/ecosystems/parsers-misc.d.ts

@@ -447,4 +447,27 @@ export declare function resetCocoaPodspecPrefetch(): void;
  * @returns {Promise<void>}
  */
 export declare function prefetchCocoaPodspecs(dependencies: Array<Object>): Promise<void>;
+/**
+ * Parse an xmake `xmake-requires.lock` file.
+ *
+ * The lock is a Lua table, written when the `package.requires_lock` policy is
+ * enabled. Its top level holds a `__meta__` entry plus one section per build
+ * configuration, keyed `platform|arch`; each section maps a requirement key
+ * (`"zlib#31fecfc4"`, or `"sol2 v3.2.1#72267bd5"` when the requirement
+ * carries a version) to a table with the resolved `version` and the
+ * `repo` revision the package definition came from.
+ *
+ * The same package appears once per configuration, so entries are collapsed
+ * by name and version, and the configurations a package was resolved for are
+ * kept as a property. A requirement key without a `version` field names a
+ * system package xmake did not resolve; it is inventoried without a version.
+ *
+ * No `xmake` purl type is registered, so packages are identified as generic
+ * carrying a `cdx:purl:proposedType=xmake` property, following the
+ * convention used for nix and zig.
+ *
+ * @param {string} lockFile Path to `xmake-requires.lock`
+ * @returns {Object[]} Package records for the pinned requirements
+ */
+export declare function parseXmakeRequiresLock(lockFile: string): Object[];
 //# sourceMappingURL=parsers-misc.d.ts.map

package/types/lib/ecosystems/parsers-misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsers-misc.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-misc.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"parsers-misc.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-misc.js"],"names":[],"mappings":"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"}

package/types/lib/ecosystems/parsers-nim.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Nim parser for `.nimble` manifests and `nimble.lock`.
+ *
+ * A `.nimble` file is a Nim script whose practical surface is a set of
+ * `key = "value"` assignments plus `requires "dep >= 1.0"` lines; it is read
+ * with a line scanner over those shapes rather than a Nim interpreter.
+ * Nimble persists the resolved dependency set to `nimble.lock` (JSON), which
+ * is the source of truth for versions.
+ *
+ * No `nim` purl type is registered, so packages are identified as generic
+ * carrying a `cdx:purl:proposedType=nim` property, following the convention
+ * used for nix and zig.
+ */
+/**
+ * Parse a Nim project from a `.nimble` manifest and optional `nimble.lock`.
+ *
+ * @param {string} nimbleFile Path to the `.nimble` file
+ * @param {string} [nimbleLockFile] Path to `nimble.lock`, if present
+ * @returns {{ pkgList: object[], dependencies: object[], parentComponent: object, rootInputs?: string[] }}
+ */
+export declare function parseNimProject(nimbleFile: string, nimbleLockFile?: string): {
+    pkgList: object[];
+    dependencies: object[];
+    parentComponent: object;
+    rootInputs?: string[];
+};
+/**
+ * Read the assignments and requirements of a `.nimble` file.
+ *
+ * @param {string} filePath File to read
+ * @returns {{name?: string, version?: string, description?: string, license?: string, requires: Array<{name: string, constraint?: string}>}}
+ */
+export declare function readNimbleFile(filePath: string): {
+    name?: string;
+    version?: string;
+    description?: string;
+    license?: string;
+    requires: Array<{
+        name: string;
+        constraint?: string;
+    }>;
+};
+//# sourceMappingURL=parsers-nim.d.ts.map

package/types/lib/ecosystems/parsers-nim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-nim.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-nim.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AAEH;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAJ/B,MAI+B,EAAE,cAAc,AAHvD,CACA,EADQ,MAG+C,GAF7C;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAqGzG;AA2CD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAH5B,MAG4B,GAF1B;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAAC,CAgD3I"}

package/types/lib/ecosystems/parsers-opam.d.ts

@@ -0,0 +1,31 @@
+/**
+ * OCaml opam parser for `.opam.locked` files.
+ *
+ * `opam lock` writes a `<name>.opam.locked` file that pins the full resolved
+ * dependency set of a project: a `depends:` field listing every package with
+ * an equality constraint on its version, and a `pin-depends:` field for
+ * packages pinned to a URL. The file is opam's own syntax, a small
+ * line-oriented field language, which is read here with a line scanner rather
+ * than a monolithic expression.
+ *
+ * A locked file holds the closure only: it does not record which packages are
+ * direct dependencies of the project, so every entry is reported with the
+ * same standing and the project root links to all of them.
+ *
+ * Packages are identified with the registered `opam` purl type
+ * (`pkg:opam/<name>@<version>`).
+ */
+/**
+ * Parse an `.opam.locked` (or plain `.opam`) file.
+ *
+ * @param {string} opamLockedFile Path to the opam file
+ * @returns {{ pkgList: object[], pins: Array<{name: string, url: string}> }}
+ */
+export declare function parseOpamLockedFile(opamLockedFile: string): {
+    pkgList: object[];
+    pins: Array<{
+        name: string;
+        url: string;
+    }>;
+};
+//# sourceMappingURL=parsers-opam.d.ts.map

package/types/lib/ecosystems/parsers-opam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-opam.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-opam.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,cAAc,EAHvC,MAGuC,GAFrC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAAE,CAoD3E"}

package/types/lib/ecosystems/parsers-perl.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Perl parser for `cpanfile` and `cpanfile.snapshot`.
+ *
+ * Carton snapshots the resolved install set as a text document: one entry per
+ * distribution, each carrying the `pathname` it was fetched from (which
+ * encodes the PAUSE author id), the packages it provides, and the
+ * requirements it was resolved against. The declared `cpanfile` lists the
+ * project's own requirements.
+ *
+ * Distributions are identified with the registered `cpan` purl type, whose
+ * rules require the author id as the namespace
+ * (`pkg:cpan/<AUTHOR>/<Distribution>@<version>`).
+ */
+/**
+ * Parse a `cpanfile.snapshot` into distributions with a dependency graph.
+ *
+ * @param {string} snapshotFile Path to `cpanfile.snapshot`
+ * @param {string} [cpanfileFile] Path to `cpanfile`, if present
+ * @returns {{ pkgList: object[], dependencies: object[] }}
+ */
+export declare function parseCpanSnapshot(snapshotFile: string, cpanfileFile?: string): {
+    pkgList: object[];
+    dependencies: object[];
+};
+/**
+ * Collect the requirement names declared in a `cpanfile`.
+ *
+ * Only the `requires` keyword outside phase blocks is read; phases such as
+ * `on 'test'` are ignored so test-only modules do not become direct
+ * dependencies.
+ *
+ * @param {string} cpanfileFile Path to `cpanfile`
+ * @returns {Set<string>} Declared requirement names
+ */
+export declare function directRequirementsFromCpanfile(cpanfileFile: string): Set<string>;
+//# sourceMappingURL=parsers-perl.d.ts.map

package/types/lib/ecosystems/parsers-perl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-perl.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-perl.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAJnC,MAImC,EAAE,YAAY,AAHzD,CACA,EADQ,MAGiD,GAF/C;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAyHzD;AAkFD;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,YAAY,EAHhD,MAGgD,GAF9C,GAAG,CAAC,MAAM,CAAC,CA0CvB"}

package/types/lib/ecosystems/parsers-r.d.ts

@@ -0,0 +1,35 @@
+/**
+ * R project parser for renv lock files.
+ *
+ * `renv.lock` records the R version, the repositories packages were resolved
+ * from, and every package in the project library with its exact version, an
+ * integrity hash, and the names of the packages it requires. The lock is a
+ * JSON document, which makes it a reliable offline source of both the
+ * resolved dependency set and the graph between packages.
+ *
+ * Packages are identified with the registered `cran` purl type
+ * (`pkg:cran/<Package>@<Version>`). Requirement strings may carry version
+ * constraints (`"R (>= 3.6)"`); only the leading package name is used, and
+ * the R runtime itself is recorded as the parent's version rather than an
+ * edge.
+ */
+/**
+ * Parse an `renv.lock` file.
+ *
+ * @param {string} renvLockFile Path to `renv.lock`
+ * @returns {{
+ *   pkgList: object[],
+ *   dependencies: object[],
+ *   rootInputs: string[],
+ *   parentComponent: object,
+ *   rVersion: string|undefined
+ * }}
+ */
+export declare function parseRenvLock(renvLockFile: string): {
+    pkgList: object[];
+    dependencies: object[];
+    rootInputs: string[];
+    parentComponent: object;
+    rVersion: string | undefined;
+};
+//# sourceMappingURL=parsers-r.d.ts.map

package/types/lib/ecosystems/parsers-r.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-r.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-r.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAT/B,MAS+B,GAR7B;IACR,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAC,SAAS,CAAA;CAC3B,CAsGH"}

package/types/lib/ecosystems/parsers-rebar.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Erlang rebar3 parser for `rebar.lock`.
+ *
+ * A rebar lock holds one or two Erlang terms, each ended by a period:
+ *
+ *   {"1.2.0", [{<<"cowboy">>,{pkg,<<"cowboy">>,<<"2.10.0">>},0}]}.
+ *   [{pkg_hash, [{<<"cowboy">>, <<"3AFD...">>}]},
+ *    {pkg_hash_ext, [...]}].
+ *
+ * The first term pairs the lock format version with the locked dependency
+ * list; the hashes live in a separate second term, which is absent from locks
+ * that hold no hex packages. Lock format 1.0.0 omitted the version and wrote
+ * the dependency list as the only term.
+ *
+ * Rather than a large regular expression over the surface syntax, a small
+ * recursive reader parses the terms into plain JavaScript values: tuples and
+ * lists become arrays, binaries and strings become strings, atoms become
+ * strings. Only the shapes rebar actually writes are understood; anything
+ * else is skipped.
+ *
+ * Hex dependencies are identified with the registered `hex` purl type, since
+ * rebar resolves Erlang packages through hex.pm. The `pkg_hash` values hex
+ * publishes are SHA-256 digests of the package tarball, so they are emitted
+ * into the CycloneDX `hashes` array where consumers expect content hashes.
+ */
+/**
+ * Parse a `rebar.lock` file.
+ *
+ * @param {string} rebarLockFile Path to `rebar.lock`
+ * @returns {{ pkgList: object[] }} Locked packages
+ */
+export declare function parseRebarLock(rebarLockFile: string): {
+    pkgList: object[];
+};
+/**
+ * Parse every period-terminated Erlang term in a source text.
+ *
+ * @param {string} text Source text
+ * @returns {Array} Parsed terms, in file order
+ */
+export declare function parseErlangTerms(text: string): any[];
+//# sourceMappingURL=parsers-rebar.d.ts.map

package/types/lib/ecosystems/parsers-rebar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-rebar.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-rebar.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAHjC,MAGiC,GAF/B;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAyDjC;AAuHD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAH1B,MAG0B,SA2BpC"}