@cyclonedx/cdxgen 11.2.5 → 11.2.7

package/README.md

@@ -516,7 +516,7 @@ Please check out our [contribute to CycloneDX/cdxgen documentation][github-contr
 
 Before raising a PR, please run the following commands.
 
-```bash
+```shell
 corepack enable pnpm
 pnpm install --config.strict-dep-builds=true
 # Generate types using jsdoc syntax
@@ -527,6 +527,17 @@ pnpm run lint
 pnpm test
 ```
 
+### Testing main branch
+
+Use `pnpm add -g` command to quickly test the main branch.
+
+```shell
+corepack pnpm bin -g
+corepack pnpm setup
+corepack pnpm add -g --allow-build sqlite3 https://github.com/CycloneDX/cdxgen
+cdxgen --help
+```
+
 ## Sponsors
 
 <img src="./docs/_media/LevoLogo-LightBg.jpg" width="200" height="auto">

package/bin/cdxgen.js

@@ -196,17 +196,14 @@ const args = yargs(hideBin(process.argv))
   })
   .option("usages-slices-file", {
     description: "Path for the usages slices file created by atom.",
-    default: "usages.slices.json",
     hidden: true,
   })
   .option("data-flow-slices-file", {
     description: "Path for the data-flow slices file created by atom.",
-    default: "data-flow.slices.json",
     hidden: true,
   })
   .option("reachables-slices-file", {
     description: "Path for the reachables slices file created by atom.",
-    default: "reachables.slices.json",
     hidden: true,
   })
   .option("semantics-slices-file", {
@@ -440,6 +437,15 @@ const options = Object.assign({}, args, {
       ? resolve(join(filePath, args.output))
       : args.output,
 });
+// Should we create the output directory?
+const outputDirectory = dirname(options.output);
+if (
+  outputDirectory &&
+  outputDirectory !== process.cwd() &&
+  !safeExistsSync(outputDirectory)
+) {
+  fs.mkdirSync(outputDirectory, { recursive: true });
+}
 // Filter duplicate types. Eg: -t gradle -t gradle
 if (options.projectType && Array.isArray(options.projectType)) {
   options.projectType = Array.from(new Set(options.projectType));
@@ -661,6 +667,11 @@ const checkPermissions = (filePath, options) => {
   }
   // Secure mode checks
   if (isSecureMode) {
+    if (process.env?.GITHUB_TOKEN) {
+      console.log(
+        "Ensure that the GitHub token provided to cdxgen is restricted to read-only scopes.",
+      );
+    }
     if (process.permission.has("fs.read", "*")) {
       console.log(
         "\x1b[1;35mSECURE MODE: DO NOT run cdxgen with FileSystemRead permission set to wildcard.\x1b[0m",
@@ -788,10 +799,6 @@ const checkPermissions = (filePath, options) => {
     }
     return;
   }
-  // This will prevent people from accidentally using the usages slices belonging to a different project
-  if (!options.usagesSlicesFile) {
-    options.usagesSlicesFile = `${options.projectName}-usages.json`;
-  }
   prepareEnv(filePath, options);
   thoughtLog("Getting ready to generate the BOM ⚡️.");
   let bomNSData = (await createBom(filePath, options)) || {};

package/data/component-tags.json

@@ -231,7 +231,7 @@
     "sbom": [
       {
         "test": [
-          "(junit|xmlunit|testng|mocha|jest|test4j|xunit|coverlet|Test\\.Sdk)",
+          "(junit|xmlunit|testng|mocha|jest|test4j|xunit|coverlet|Test\\.Sdk|Moq)",
           "^(chai)$"
         ]
       },

package/data/frameworks-list.json

@@ -5,6 +5,16 @@
     "System.Data",
     "Microsoft.AspNetCore",
     "Microsoft.NETCore",
+    "Microsoft.EntityFrameworkCore",
+    "pkg:nuget/EntityFramework",
+    "pkg:nuget/Microsoft.Build.Framework",
+    "EntityFrameworkCore",
+    "Microsoft.Data.OData",
+    "Microsoft.NETCore.Targets",
+    "System.Diagnostics.DiagnosticSource",
+    "Microsoft.OData.",
+    "Google.Cloud.",
+    "PnP.Framework",
     "springframework",
     "pkg:maven/us.springett/alpine",
     "pkg:pypi/flask",
@@ -26,13 +36,15 @@
     "play",
     "spark",
     "struts",
-    "angular",
-    "react",
-    "next",
-    "ember",
-    "express",
-    "knex",
-    "vue",
+    "pkg:npm/%40angular",
+    "pkg:npm/react",
+    "pkg:npm/next",
+    "pkg:npm/ember",
+    "pkg:npm/%40electron",
+    "pkg:npm/%40protobufjs",
+    "pkg:npm/express",
+    "pkg:npm/knex",
+    "pkg:npm/vue",
     "pkg:pypi/aiohttp",
     "pkg:pypi/bottle",
     "pkg:pypi/cherrypy",

package/data/pypi-pkg-aliases.json

@@ -1144,6 +1144,7 @@
   "uwsgidecorators": "uwsgi",
   "valentine": "ab",
   "validate": "configobj",
+  "vdb": "appthreat-vulnerability-db",
   "version": "chartio",
   "virtualenvapi": "ar-virtualenv-api",
   "vyatta": "brocade-plugins",

package/lib/cli/index.js

@@ -15,7 +15,6 @@ import {
 import { platform as _platform, arch, homedir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import process from "node:process";
-import { URL } from "node:url";
 import got from "got";
 import { load as loadYaml } from "js-yaml";
 import { PackageURL } from "packageurl-js";
@@ -786,6 +785,10 @@ function addMetadata(parentComponent = {}, options = {}, context = {}) {
             "PNPM_STORE_PATH",
             "PNPM_HOME",
             "PNPM_CONFIG_",
+            "GIO_MODULE_DIR",
+            "GST_PLUGIN_PATH",
+            "GST_PLUGIN_SYSTEM_PATH",
+            "APPDIR_LIBRARY_PATH", // appimage specific which gets prepended to LD_LIBRARY_PATH
           ]) {
             if (evalue.includes(senvValue)) {
               mproperties.push({
@@ -1203,6 +1206,13 @@ function determinePackageType(pkg) {
           return "application";
         }
       }
+      // See #1760
+      if (
+        purl.namespace?.startsWith("@types") ||
+        (purl.namespace?.includes("-types") && pkg?.type === "npm")
+      ) {
+        return "library";
+      }
       for (const cf of frameworksList.all) {
         if (
           pkg.purl.startsWith(cf) ||
@@ -1232,6 +1242,13 @@ function determinePackageType(pkg) {
       }
     }
   }
+  if (Object.prototype.hasOwnProperty.call(pkg, "tags")) {
+    for (const tag of pkg.tags) {
+      if (tag && tag.toLowerCase() === "framework") {
+        return "framework";
+      }
+    }
+  }
   return "library";
 }
 
@@ -1965,46 +1982,45 @@ export async function createJavaBom(path, options) {
       options,
     )
   ) {
+    let includedBuilds = [];
     let allProjectsStr = [];
     if (process.env.GRADLE_INCLUDED_BUILDS) {
-      // Automatically add the colon prefix
-      allProjectsStr = process.env.GRADLE_INCLUDED_BUILDS.split(",").map((b) =>
+      includedBuilds = process.env.GRADLE_INCLUDED_BUILDS.split(",").map((b) =>
         !b.startsWith(":") ? `:${b}` : b,
       );
     }
     let parallelPropTaskOut = executeParallelGradleProperties(
       gradleRootPath,
-      [null],
+      [null].concat(includedBuilds),
       process.env.GRADLE_INCLUDED_BUILDS
         ? []
         : ["--init-script", GRADLE_INIT_SCRIPT],
     );
-    if (!process.env.GRADLE_INCLUDED_BUILDS) {
+    if (process.env.GRADLE_INCLUDED_BUILDS === undefined) {
       const outputLines = parallelPropTaskOut.split("\n");
       for (const [i, line] of outputLines.entries()) {
-        if (line.startsWith("Root project '")) {
+        if (line.startsWith("Root project '") || line.startsWith("Project '")) {
           break;
         }
         if (line.startsWith("<CDXGEN:includedBuild>")) {
           const includedBuild = line.split(">");
-          if (!allProjectsStr.includes(includedBuild[1].trim())) {
-            allProjectsStr.push(includedBuild[1].trim());
+          if (!includedBuilds.includes(includedBuild[1].trim())) {
+            includedBuilds.push(includedBuild[1].trim());
           }
         }
       }
-    }
-    if (allProjectsStr.length > 0) {
-      thoughtLog(
-        `Wait, this gradle project uses composite builds. I must carefully process these ${allProjectsStr.length} projects, in addition to the root.`,
-      );
-      if (DEBUG_MODE) {
-        console.log(`Composite builds: ${allProjectsStr.join(" ").trim()}.`);
+      if (includedBuilds.length > 0) {
+        thoughtLog(
+          `Wait, this gradle project uses composite builds. I must carefully process these ${includedBuilds.length} projects, in addition to the root.`,
+        );
+        if (DEBUG_MODE) {
+          console.log(`Composite builds: ${includedBuilds.join(" ").trim()}.`);
+        }
+        parallelPropTaskOut = parallelPropTaskOut.concat(
+          "\n",
+          executeParallelGradleProperties(gradleRootPath, includedBuilds),
+        );
       }
-      parallelPropTaskOut = parallelPropTaskOut.concat(
-        "\n",
-        executeParallelGradleProperties(gradleRootPath, allProjectsStr),
-      );
-      allProjectsStr = [];
     }
     const splitPropTaskOut = splitOutputByGradleProjects(parallelPropTaskOut, [
       "properties",
@@ -2017,7 +2033,7 @@ export async function createJavaBom(path, options) {
           rootProject,
           retMap.metadata,
         );
-        if (!key.startsWith(":")) {
+        if (!includedBuilds.includes(key)) {
           parentComponent = rootComponent;
         }
         gradleModules.set(key, rootComponent);
@@ -2303,7 +2319,7 @@ export async function createJavaBom(path, options) {
           query = ["--bazelrc=.bazelrc"];
         }
         if (["true", "1"].includes(process.env.BAZEL_USE_ACTION_GRAPH)) {
-          query = query.concat(["aquery", `outputs('.*.jar',deps(${target}))`]);
+          query = query.concat(["query", `deps(${target})`, "--output=label"]);
           bazelParser = parseBazelActionGraph;
         } else {
           query = query.concat([
@@ -2762,11 +2778,7 @@ export async function createNodejsBom(path, options) {
   let allImports = {};
   let allExports = {};
   if (
-    !hasAnyProjectType(
-      ["docker", "oci", "container", "os", "pnpm"],
-      options,
-      false,
-    ) &&
+    !hasAnyProjectType(["docker", "oci", "container", "os"], options, false) &&
     !options.noBabel
   ) {
     if (DEBUG_MODE) {
@@ -4837,7 +4849,10 @@ export function createCppBom(path, options) {
       parentComponent = retMap.parentComponent;
     } else {
       parentComponent.components = parentComponent.components || [];
-      if (!addedParentComponentsMap[retMap.parentComponent.name]) {
+      if (
+        retMap?.parentComponent?.name &&
+        !addedParentComponentsMap[retMap.parentComponent.name]
+      ) {
         parentComponent.components.push(retMap.parentComponent);
         addedParentComponentsMap[retMap.parentComponent.name] = true;
       }
@@ -6806,6 +6821,8 @@ export function trimComponents(components) {
       if (comp?.evidence?.identity) {
         if (!existingComponent.evidence) {
           existingComponent.evidence = { identity: [] };
+        } else if (!existingComponent?.evidence?.identity) {
+          existingComponent.evidence.identity = [];
         } else if (
           existingComponent?.evidence?.identity &&
           !Array.isArray(existingComponent.evidence.identity)

package/lib/evinser/evinser.js

@@ -235,6 +235,8 @@ export async function createSlice(
     language = "js";
   } else if (language.startsWith("python")) {
     language = "python";
+  } else if (PROJECT_TYPE_ALIASES.scala.includes(language)) {
+    language = "scala";
   }
   if (
     PROJECT_TYPE_ALIASES.swift.includes(language) &&
@@ -253,11 +255,11 @@ export async function createSlice(
   }
   const slicesFile =
     options[`${sliceType}SlicesFile`] ||
-    join(sliceOutputDir, `${sliceType}.slices.json`);
+    join(sliceOutputDir, `${language}-${sliceType}.slices.json`);
   const openapiSpecFile = basename(
     options.openapiSpecFile ||
       process.env?.ATOM_TOOLS_OPENAPI_FILENAME ||
-      "openapi.json",
+      join(sliceOutputDir, `${language}-openapi.json`),
   );
   // For some languages such as scala, semantics slices file would get created during usages slicing.
   let semanticsSlicesFile;
@@ -275,7 +277,7 @@ export async function createSlice(
   console.log(
     `Creating ${sliceType} slice for ${resolve(filePath)}. Please wait ...`,
   );
-  const atomFile = join(sliceOutputDir, "app.atom");
+  const atomFile = join(sliceOutputDir, `${language}-app.atom`);
   let args = [sliceType];
   // Support for crypto slices aka CBOM
   if (sliceType === "reachables" && options.includeCrypto) {
@@ -319,7 +321,7 @@ export async function createSlice(
     ATOM_TOOLS_OPENAPI_FILENAME: openapiSpecFile, // The file would get over-written
     ATOM_TOOLS_OPENAPI_FORMAT:
       process.env?.ATOM_TOOLS_OPENAPI_FORMAT || "openapi3.1.0", // editor.swagger.io doesn't support 3.1.0 yet
-    ATOM_TOOLS_WORK_DIR: resolve(filePath), // This must be the directory containing semantics.slices.json
+    ATOM_TOOLS_WORK_DIR: process.env?.ATOM_TOOLS_WORK_DIR || resolve(filePath), // This must be the directory containing semantics.slices.json
     OPENAPI_SERVER_URL: process.env?.OPENAPI_SERVER_URL,
   });
   if (!result || !safeExistsSync(slicesFile)) {
@@ -1410,7 +1412,6 @@ export function createEvinseFile(sliceArtefacts, options) {
     dataFlowFrames,
     cryptoComponents,
     cryptoGeneratePurls,
-    openapiSpecFile,
   } = sliceArtefacts;
   const bomFile = options.input;
   const evinseOutFile = options.output;

package/lib/helpers/envcontext.js

@@ -29,10 +29,10 @@ export const GIT_COMMAND = process.env.GIT_CMD || "git";
 
 // sdkman tool aliases
 export const SDKMAN_JAVA_TOOL_ALIASES = {
-  java8: process.env.JAVA8_TOOL || "8.0.442-amzn", // Temurin no longer offers java8 :(
-  java11: process.env.JAVA11_TOOL || "11.0.25-tem",
-  java17: process.env.JAVA17_TOOL || "17.0.14-tem",
-  java21: process.env.JAVA21_TOOL || "21.0.6-tem",
+  java8: process.env.JAVA8_TOOL || "8.0.452-amzn", // Temurin no longer offers java8 :(
+  java11: process.env.JAVA11_TOOL || "11.0.26-tem",
+  java17: process.env.JAVA17_TOOL || "17.0.15-tem",
+  java21: process.env.JAVA21_TOOL || "21.0.7-tem",
   java22: process.env.JAVA22_TOOL || "22.0.2-tem",
   java23: process.env.JAVA23_TOOL || "23.0.2-tem",
   java24: process.env.JAVA24_TOOL || "24-tem",

package/lib/helpers/utils.js

@@ -4091,12 +4091,7 @@ export function executeParallelGradleProperties(
  * @param {string} rawOutput Raw string output
  */
 export function parseBazelActionGraph(rawOutput) {
-  const mavenPrefixRegex = RegExp(
-    `^.*v1/https/[^/]*(?:${
-      process.env.BAZEL_STRIP_MAVEN_PREFIX || "/maven2/"
-    })?(.*)/(.*)/(.*)/(.*.jar)(?:"| \\\\)?$`,
-    "g",
-  );
+  const mavenPrefixRegex = /^@maven\/\/:(.*)\/(.*)\/(.*)\/(.*\.jar)$/g;
 
   if (typeof rawOutput === "string") {
     const deps = [];
@@ -4104,10 +4099,7 @@ export function parseBazelActionGraph(rawOutput) {
     const tmpA = rawOutput.split("\n");
     tmpA.forEach((l) => {
       l = l.replace("\r", "");
-      if (
-        l.trim().startsWith("arguments") ||
-        l.trim().startsWith("bazel-out")
-      ) {
+      if (l.trim().startsWith("@maven//:")) {
         const matches = Array.from(l.matchAll(mavenPrefixRegex));
 
         if (matches[0]?.[1]) {
@@ -12665,7 +12657,9 @@ function fullScanCocoaPod(dependency, component, options) {
     component.authors = [];
     if (podspec.authors.constructor === Object) {
       Object.entries(podspec.authors).forEach(([name, email]) =>
-        component.authors.push({ name, email }),
+        email.includes("@")
+          ? component.authors.push({ name, email })
+          : component.authors.push({ name }),
       );
     } else if (podspec.authors.constructor === Array) {
       podspec.authors.forEach((name) => component.authors.push({ name }));
@@ -13034,7 +13028,6 @@ export function executeAtom(src, args, extra_env = {}) {
     cwd,
     encoding: "utf-8",
     timeout: TIMEOUT_MS,
-    detached: !isWin && !process.env.CI,
     shell: isWin,
     killSignal: "SIGKILL",
     env,
@@ -13064,6 +13057,12 @@ export function executeAtom(src, args, extra_env = {}) {
       console.warn(
         "WARN: The binary plugin used by atom has crashed. Please try an alternative container image and file an issue with steps to reproduce at: https://github.com/AppThreat/atom/issues",
       );
+    } else if (
+      result.stderr?.includes("Could not parse command line options")
+    ) {
+      console.warn(
+        "Invalid command-line options passed to atom. Please file a bug in the cdxgen repository.",
+      );
     }
   }
   if (result.stdout) {
@@ -13110,7 +13109,7 @@ export function findAppModules(
   slicesFile = undefined,
 ) {
   const tempDir = mkdtempSync(join(tmpdir(), "atom-deps-"));
-  const atomFile = join(tempDir, "app.atom");
+  const atomFile = join(tempDir, `${language}-app.atom`);
   if (!slicesFile) {
     slicesFile = join(tempDir, "slices.json");
   }

package/lib/helpers/utils.test.js

@@ -1318,7 +1318,7 @@ describe("go data with licenses", () => {
   afterAll(() => {
     delete process.env.FETCH_LICENSE;
   });
-  test("parseGoSumData with licenses", async () => {
+  test.skip("parseGoSumData with licenses", async () => {
     let dep_list = await parseGosumData(null);
     expect(dep_list).toEqual([]);
     dep_list = await parseGosumData(
@@ -1386,7 +1386,7 @@ describe("go data with licenses", () => {
     });
   }, 120000);
 
-  test("parseGoModData with licenses", async () => {
+  test.skip("parseGoModData with licenses", async () => {
     let retMap = await parseGoModData(null);
     expect(retMap).toEqual({});
     const gosumMap = {
@@ -2447,7 +2447,7 @@ test("parse github actions workflow data", () => {
   let dep_list = parseGitHubWorkflowData(
     readFileSync("./.github/workflows/nodejs.yml", { encoding: "utf-8" }),
   );
-  expect(dep_list.length).toEqual(4);
+  expect(dep_list.length).toEqual(5);
   expect(dep_list[0]).toEqual({
     group: "actions",
     name: "checkout",
@@ -2456,18 +2456,12 @@ test("parse github actions workflow data", () => {
   dep_list = parseGitHubWorkflowData(
     readFileSync("./.github/workflows/repotests.yml", { encoding: "utf-8" }),
   );
-  expect(dep_list.length).toEqual(14);
+  expect(dep_list.length).toEqual(13);
   expect(dep_list[0]).toEqual({
     group: "actions",
     name: "checkout",
     version: "v4",
   });
-  dep_list = parseGitHubWorkflowData(
-    readFileSync("./.github/workflows/app-release.yml", {
-      encoding: "utf-8",
-    }),
-  );
-  expect(dep_list.length).toEqual(3);
 });
 
 test("parse cs pkg data", () => {
@@ -3785,8 +3779,8 @@ test("parsePnpmLock", async () => {
   expect(parsedList.dependenciesList).toHaveLength(462);
   expect(parsedList.pkgList.filter((pkg) => !pkg.scope)).toHaveLength(3);
   parsedList = await parsePnpmLock("./pnpm-lock.yaml");
-  expect(parsedList.pkgList.length).toEqual(622);
-  expect(parsedList.dependenciesList.length).toEqual(622);
+  expect(parsedList.pkgList.length).toEqual(623);
+  expect(parsedList.dependenciesList.length).toEqual(623);
   expect(parsedList.pkgList[0]).toEqual({
     group: "@ampproject",
     name: "remapping",
@@ -5184,13 +5178,13 @@ test("parse bazel action graph", () => {
       encoding: "utf-8",
     }),
   );
-  expect(deps.length).toEqual(10);
+  expect(deps.length).toEqual(2);
   expect(deps[0].group).toEqual("org.scala-lang");
   expect(deps[0].name).toEqual("scala-library");
-  expect(deps[0].version).toEqual("2.13.11");
+  expect(deps[0].version).toEqual("2.13.16");
   expect(deps[1].group).toEqual("org.jline");
   expect(deps[1].name).toEqual("jline");
-  expect(deps[1].version).toEqual("3.21.0");
+  expect(deps[1].version).toEqual("3.26.3");
 });
 
 test("parse bazel build", () => {

package/lib/helpers/validator.js

@@ -137,8 +137,12 @@ export const validateMetadata = (bomJson) => {
 export const validatePurls = (bomJson) => {
   const errorList = [];
   const warningsList = [];
+  let frameworksCount = 0;
   if (bomJson?.components) {
     for (const comp of bomJson.components) {
+      if (comp.type === "framework") {
+        frameworksCount += 1;
+      }
       if (comp.type === "cryptographic-asset") {
         if (comp.purl?.length) {
           errorList.push(
@@ -187,6 +191,11 @@ export const validatePurls = (bomJson) => {
       }
     }
   }
+  if (frameworksCount > 20) {
+    warningsList.push(
+      `BOM likey has too many framework components. Count: ${frameworksCount}`,
+    );
+  }
   if (DEBUG_MODE && warningsList.length !== 0) {
     console.log("===== WARNINGS =====");
     console.log(warningsList);

package/lib/managers/binary.js

@@ -9,7 +9,7 @@ import {
   statSync,
 } from "node:fs";
 import { arch as _arch, platform as _platform, homedir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 import process from "node:process";
 import { PackageURL } from "packageurl-js";
 import {
@@ -28,8 +28,6 @@ import {
   safeMkdirSync,
 } from "../helpers/utils.js";
 
-import { URL } from "node:url";
-
 const dirName = dirNameStr;
 
 const isWin = _platform() === "win32";
@@ -60,6 +58,9 @@ switch (arch) {
     break;
 }
 
+// cdxgen plugins version
+const CDXGEN_PLUGINS_VERSION = "1.6.10";
+
 // Retrieve the cdxgen plugins directory
 let CDXGEN_PLUGINS_DIR = process.env.CDXGEN_PLUGINS_DIR;
 // Is there a non-empty local plugins directory
@@ -126,11 +127,54 @@ if (!CDXGEN_PLUGINS_DIR) {
       `cdxgen-plugins-bin${pluginsBinSuffix}`,
       "plugins",
     );
+    // pnpm add -g
+    let altGlobalPlugins;
+    if (dirName.includes(join("node_modules", ".pnpm", "@cyclonedx+cdxgen"))) {
+      const tmpA = dirName.split(join("node_modules", ".pnpm"));
+      altGlobalPlugins = join(
+        tmpA[0],
+        "node_modules",
+        ".pnpm",
+        `@cyclonedx+cdxgen-plugins-bin${pluginsBinSuffix}@${CDXGEN_PLUGINS_VERSION}`,
+        "node_modules",
+        "@cyclonedx",
+        `cdxgen-plugins-bin${pluginsBinSuffix}`,
+        "plugins",
+      );
+    } else if (dirName.includes(join(".pnpm", "@cyclonedx+cdxgen"))) {
+      // pnpm dlx
+      const tmpA = dirName.split(".pnpm");
+      altGlobalPlugins = join(
+        tmpA[0],
+        ".pnpm",
+        `@cyclonedx+cdxgen-plugins-bin${pluginsBinSuffix}@${CDXGEN_PLUGINS_VERSION}`,
+        "node_modules",
+        "@cyclonedx",
+        `cdxgen-plugins-bin${pluginsBinSuffix}`,
+        "plugins",
+      );
+    }
+    const extraNMBinPath = join(
+      globalNodePath,
+      "..",
+      ".pnpm",
+      "node_modules",
+      ".bin",
+    );
     if (existsSync(globalPlugins)) {
       CDXGEN_PLUGINS_DIR = globalPlugins;
       if (DEBUG_MODE) {
         console.log("Found global plugins", CDXGEN_PLUGINS_DIR);
       }
+    } else if (altGlobalPlugins && existsSync(altGlobalPlugins)) {
+      CDXGEN_PLUGINS_DIR = altGlobalPlugins;
+      // To help detect bin commands such as atom, astgen, etc, we need to set this to the PATH variable.
+      if (!process.env?.PATH?.includes(extraNMBinPath)) {
+        process.env.PATH = `${extraNMBinPath}${delimiter}${process.env.PATH}`;
+      }
+      if (DEBUG_MODE) {
+        console.log("Found global plugins", CDXGEN_PLUGINS_DIR);
+      }
     }
   }
 }

package/lib/managers/docker.js

@@ -19,6 +19,7 @@ import got from "got";
 import { x } from "tar";
 import {
   DEBUG_MODE,
+  TIMEOUT_MS,
   extractPathEnv,
   getAllFiles,
   getTmpDir,
@@ -650,22 +651,45 @@ export const getImage = async (fullImageName) => {
         dockerCmd = "nerdctl";
       }
     }
-    let result = spawnSync(dockerCmd, ["pull", fullImageName], {
+    let needsPull = true;
+    // Let's check the local cache first
+    let result = spawnSync(dockerCmd, ["images", "--format=json"], {
       encoding: "utf-8",
     });
-    if (result.status !== 0 || result.error) {
-      if (result.stderr?.includes("docker daemon is not running")) {
-        console.log(
-          "Ensure Docker for Desktop is running as an administrator with 'Exposing daemon on TCP without TLS' setting turned on.",
-        );
-      } else if (result.stderr?.includes("not found")) {
-        console.log(
-          "Set the environment variable DOCKER_CMD to use an alternative command such as nerdctl or podman.",
-        );
-      } else {
-        console.log(result.stderr);
+    if (result.status === 0 && result.stdout) {
+      for (const imgLine of result.stdout.split("\n")) {
+        try {
+          const imgObj = JSON.parse(Buffer.from(imgLine).toString());
+          if (
+            imgObj.Repository === fullImageName ||
+            imgObj?.Name?.endsWith(fullImageName)
+          ) {
+            needsPull = false;
+            break;
+          }
+        } catch (err) {
+          // continue regardless of error
+        }
+      }
+    }
+    if (needsPull) {
+      result = spawnSync(dockerCmd, ["pull", fullImageName], {
+        encoding: "utf-8",
+        timeout: TIMEOUT_MS,
+      });
+      if (result.status !== 0 || result.error) {
+        if (result.stderr?.includes("docker daemon is not running")) {
+          console.log(
+            "Ensure Docker for Desktop is running as an administrator with 'Exposing daemon on TCP without TLS' setting turned on.",
+          );
+        } else if (result.stderr?.includes("not found")) {
+          console.log(
+            "Set the environment variable DOCKER_CMD to use an alternative command such as nerdctl or podman.",
+          );
+        } else {
+          console.log(result.stderr);
+        }
       }
-      return localData;
     }
     result = spawnSync(dockerCmd, ["inspect", fullImageName], {
       encoding: "utf-8",
@@ -854,6 +878,7 @@ export const extractTar = async (fullImageName, dir, options) => {
             path.includes("usr/share/doc/") ||
             path.includes("usr/share/i18n/") ||
             path.includes("var/lib/ca-certificates") ||
+            path.includes("root/.gnupg") ||
             basename(path).startsWith(".") ||
             path.includes("usr/share/licenses/device-mapper-libs") ||
             [
@@ -865,6 +890,7 @@ export const extractTar = async (fullImageName, dir, options) => {
               "SymbolicLink",
               "RenamedOrSymlinked",
               "HardLink",
+              "Link",
             ].includes(entry.type)
           );
         },
@@ -901,22 +927,16 @@ export const extractTar = async (fullImageName, dir, options) => {
       return false;
     } else if (["EACCES"].includes(err.code)) {
       console.log(err);
-      /*
-       * We do not display errors messages for errors:
-       * 1) TAR_ENTRY_INFO is an informative error indicating that an entry is being modified.
-       * 2) TAR_ENTRY_INVALID indicates that a given entry is not valid tar archive entry and will be skipped.
-       */
-    } else if (
-      DEBUG_MODE &&
-      ["TAR_ENTRY_INFO", "TAR_ENTRY_INVALID"].includes(err.code)
-    ) {
+    } else if (["TAR_ENTRY_INFO", "TAR_ENTRY_INVALID"].includes(err.code)) {
       if (
         err?.header?.path?.includes("{") ||
         err?.message?.includes("linkpath required")
       ) {
         return false;
       }
-      console.log(err);
+      if (DEBUG_MODE) {
+        console.log(err);
+      }
     } else if (DEBUG_MODE) {
       console.log(err.code, "is not handled yet in extractTar method.");
     }
@@ -1372,7 +1392,9 @@ export const getCredsFromHelper = (exeSuffix, serverAddress) => {
     encoding: "utf-8",
   });
   if (result.status !== 0 || result.error) {
-    console.log(result.stdout, result.stderr);
+    if (result.stdout || result.stderr) {
+      console.log(result.stdout, result.stderr);
+    }
   } else if (result.stdout) {
     const cmdOutput = Buffer.from(result.stdout).toString();
     try {

package/lib/managers/piptree.js

@@ -147,7 +147,9 @@ export const getTreeWithPlugin = (env, python_cmd, basePath) => {
     env,
   });
   if (result.status !== 0 || result.error) {
-    console.log(result.stdout, result.stderr);
+    if (result.stdout || result.stderr) {
+      console.log(result.stdout, result.stderr);
+    }
   }
   if (existsSync(pipTreeJson)) {
     tree = JSON.parse(

package/lib/server/openapi.yaml

@@ -338,6 +338,10 @@ components:
           $ref: '#/components/schemas/Services'
         dependencies:
           $ref: '#/components/schemas/Dependencies'
+        annotations:
+          $ref: '#/components/schemas/Annotations'
+        formulation:
+          $ref: '#/components/schemas/Formulation'
 
     ErrorResponse:
       type: object
@@ -362,5 +366,9 @@ components:
 
     Dependencies:
       type: object
-      xml:
-        name: pet
+
+    Annotations:
+      type: object
+
+    Formulation:
+      type: object

package/lib/server/server.js

@@ -178,6 +178,14 @@ const start = (options) => {
       process.exit(1);
     }
   }
+  if (!process.env.CDXGEN_SERVER_ALLOWED_HOSTS) {
+    console.log(
+      "No allowlist for hosts has been specified. This is a security risk that could expose the system to SSRF vulnerabilities!",
+    );
+    if (isSecureMode) {
+      process.exit(1);
+    }
+  }
   const cdxgenServer = http
     .createServer(app)
     .listen(options.serverPort, options.serverHost);
@@ -189,6 +197,15 @@ const start = (options) => {
   });
 
   app.use("/sbom", async (req, res) => {
+    // Limit to only GET and POST requests
+    if (req.method && !["GET", "POST"].includes(req.method.toUpperCase())) {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      return res.end(
+        JSON.stringify({
+          error: "Method Not Allowed",
+        }),
+      );
+    }
     const requestUrl = new URL(req.url, `http://${req.headers.host}`);
     const q = Object.fromEntries(requestUrl.searchParams.entries());
     let cleanup = false;
@@ -202,7 +219,7 @@ const start = (options) => {
       res.writeHead(500, { "Content-Type": "application/json" });
       return res.end(
         JSON.stringify({
-          error: "path or url is required.",
+          error: "Path or URL is required.",
         }),
       );
     }
@@ -215,7 +232,7 @@ const start = (options) => {
         return res.end(
           JSON.stringify({
             error: "Host Not Allowed",
-            details: `The Git URL host is not allowed: '${gitUrlObj.hostname}'.`,
+            details: "The Git URL host is not allowed as per the allowlist.",
           }),
         );
       }
@@ -227,20 +244,20 @@ const start = (options) => {
         return res.end(
           JSON.stringify({
             error: "Path Not Allowed",
-            details: `Path is not allowed: '${srcDir}'.`,
+            details: "Path is not allowed as per the allowlist.",
           }),
         );
       }
     }
     if (srcDir !== path.resolve(srcDir)) {
       console.log(
-        `Invoke the API with an absolute path '${path.resolve(srcDir)}' instead of '${srcDir}' to reduce security risks.`,
+        `Invoke the API with an absolute path '${path.resolve(srcDir)}' to reduce security risks.`,
       );
       if (isSecureMode) {
         res.writeHead(500, { "Content-Type": "application/json" });
         return res.end(
           JSON.stringify({
-            error: `Provide an absolute path instead of '${srcDir}'`,
+            error: "Absolute path needed",
             details: "Relative paths are not supported in secure mode.",
           }),
         );
@@ -250,6 +267,15 @@ const start = (options) => {
     let bomNSData = (await createBom(srcDir, reqOptions)) || {};
     bomNSData = postProcess(bomNSData, reqOptions);
     if (reqOptions.serverUrl && reqOptions.apiKey) {
+      if (!isAllowedHost(reqOptions.serverUrl)) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        return res.end(
+          JSON.stringify({
+            error: "Host Not Allowed",
+            details: "The URL host is not allowed as per the allowlist.",
+          }),
+        );
+      }
       if (isSecureMode && !reqOptions.serverUrl?.startsWith("https://")) {
         console.log(
           "Dependency Track API server is used with a non-https url, which poses a security risk.",
@@ -267,7 +293,7 @@ const start = (options) => {
           res.writeHead(500, { "Content-Type": "application/json" });
           return res.end(
             JSON.stringify({
-              error: `Unable to submit the SBOM ${reqOptions.projectName} to the Dependency Track server ${reqOptions.serverUrl}`,
+              error: "Unable to submit the SBOM to the Dependency-Track server",
               details: errorMessages,
             }),
           );

package/lib/stages/pregen/pregen.js

@@ -79,7 +79,11 @@ export function prepareSdkmanBuild(projectType) {
  */
 export function preparePythonEnv(_filePath, options) {
   if (hasAnyProjectType(["python"], options, false)) {
-    if (process.env?.CDXGEN_IN_CONTAINER !== "true" && arch() !== "x64") {
+    if (
+      DEBUG_MODE &&
+      process.env?.CDXGEN_IN_CONTAINER !== "true" &&
+      arch() !== "x64"
+    ) {
       console.log(
         `INFO: Many pypi packages have limited support for ${arch()} architecture. Run the cdxgen container image with --platform=linux/amd64 for best experience.`,
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonedx/cdxgen",
-  "version": "11.2.5",
+  "version": "11.2.7",
   "description": "Creates CycloneDX Software Bill of Materials (SBOM) from source or container image",
   "homepage": "http://github.com/cyclonedx/cdxgen",
   "author": "Prabhu Subramanian <prabhu@appthreat.com>",
@@ -71,8 +71,8 @@
     "*": "biome check --fix --no-errors-on-unmatched"
   },
   "dependencies": {
-    "@babel/parser": "^7.27.0",
-    "@babel/traverse": "^7.27.0",
+    "@babel/parser": "^7.27.1",
+    "@babel/traverse": "^7.27.1",
     "@iarna/toml": "2.2.5",
     "@npmcli/arborist": "9.0.2",
     "ajv": "^8.17.1",
@@ -80,7 +80,7 @@
     "cheerio": "^1.0.0",
     "edn-data": "1.1.2",
     "find-up": "7.0.0",
-    "glob": "^11.0.0",
+    "glob": "^11.0.2",
     "global-agent": "^3.0.0",
     "got": "^14.4.7",
     "iconv-lite": "^0.6.3",
@@ -101,7 +101,7 @@
     "yoctocolors": "^2.1.1"
   },
   "optionalDependencies": {
-    "@appthreat/atom": "2.1.15",
+    "@appthreat/atom": "2.1.18",
     "@appthreat/cdx-proto": "1.0.1",
     "@cyclonedx/cdxgen-plugins-bin": "1.6.10",
     "@cyclonedx/cdxgen-plugins-bin-linux-arm": "1.6.10",
@@ -133,7 +133,7 @@
     "typescript": "^5.8.3"
   },
   "overrides": {
-    "glob": "^11.0.0",
+    "glob": "^11.0.2",
     "node-gyp": "^10.2.0",
     "prebuild": "^13.0.0",
     "pacote": "^20.0.0",

package/types/lib/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AAw7BA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAuXD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAyEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAivChB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAuvBhB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAkehB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAuIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAkEhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA8IhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BAmJhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAmUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAiJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAwNhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA8ZhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDA+FC;AAED;;;;;;;;;GASG;AACH,2GAuCC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BA6vBlB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAqUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBA2QhB;AAED;;;;;;;GAOG;AACH,wDAHY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CA2HjD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AA27BA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAqYD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAyEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAgvChB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAmvBhB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAkehB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAuIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAkEhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAkLhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA8IhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BAmJhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAmUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAiJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAwNhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA8ZhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDAiGC;AAED;;;;;;;;;GASG;AACH,2GAuCC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BA6vBlB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAqUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBA2QhB;AAED;;;;;;;GAOG;AACH,wDAHY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CA2HjD"}

package/types/lib/helpers/utils.d.ts.map

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

package/types/lib/helpers/validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../lib/helpers/validator.js"],"names":[],"mappings":"AA8TA;;;;GAIG;AACH,uCAFW,MAAM,WA0FhB;AAxYM,qCAJI,MAAM,WAkDhB;AAOM,0CAFI,MAAM,WA2DhB;AAOM,uCAFI,MAAM,WAmEhB;AA6BM,sCAFI,MAAM,WAwFhB"}
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../lib/helpers/validator.js"],"names":[],"mappings":"AAuUA;;;;GAIG;AACH,uCAFW,MAAM,WA0FhB;AAjZM,qCAJI,MAAM,WAkDhB;AAOM,0CAFI,MAAM,WA2DhB;AAOM,uCAFI,MAAM,WA4EhB;AA6BM,sCAFI,MAAM,WAwFhB"}

package/types/lib/managers/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../lib/managers/binary.js"],"names":[],"mappings":"AA4SA,wDAkBC;AAED;;;;;GAKG;AACH,kDAFa,SAAS,MAAO,CAqB5B;AAED;;;;;;;GAOG;AACH,kEAqaC;AAsDD,gDAoDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA0ChB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA8BlB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../lib/managers/binary.js"],"names":[],"mappings":"AAwVA,wDAkBC;AAED;;;;;GAKG;AACH,kDAFa,SAAS,MAAO,CAqB5B;AAED;;;;;;;GAOG;AACH,kEAqaC;AAsDD,gDAoDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA0ChB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA8BlB"}

package/types/lib/managers/docker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../../lib/managers/docker.js"],"names":[],"mappings":"AAiFA;;GAEG;AACH,oCAmBC;AAED;;GAEG;AACH,4CA6CC;AA7HD,4BAA6C;AAC7C,kCAAmC,WAAW,CAAC;AAmCxC,kDAeN;AAqFM,iCAHI,MAAM,WACN,MAAM,iDAehB;AAqBM,6DAmBN;AAgLM,4EAsGN;AAEM,oFAwBN;AAUM;;;;;;;;EAyEN;AAsBM,2DAgLN;AAgBM,yFA2GN;AAMM;;;;;;;;;;;;;;GAwDN;AAEM;;;;;;;;GAyGN;AAMM,4EA+IN;AAKM,4EA2GN;AAEM,+EAEN;AAEM,4EAyCN;AAEM,iFA0BN"}
+{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../../lib/managers/docker.js"],"names":[],"mappings":"AAkFA;;GAEG;AACH,oCAmBC;AAED;;GAEG;AACH,4CA6CC;AA7HD,4BAA6C;AAC7C,kCAAmC,WAAW,CAAC;AAmCxC,kDAeN;AAqFM,iCAHI,MAAM,WACN,MAAM,iDAehB;AAqBM,6DAmBN;AAgLM,4EAsGN;AAEM,oFAwBN;AAUM;;;;;;;;EAyEN;AAsBM,2DAuMN;AAgBM,yFAuGN;AAMM;;;;;;;;;;;;;;GAwDN;AAEM;;;;;;;;GAyGN;AAMM,4EA+IN;AAKM,4EA2GN;AAEM,+EAEN;AAEM,4EA2CN;AAEM,iFA0BN"}

package/types/lib/managers/piptree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"piptree.d.ts","sourceRoot":"","sources":["../../../lib/managers/piptree.js"],"names":[],"mappings":"AAgIO,uFAkCN"}
+{"version":3,"file":"piptree.d.ts","sourceRoot":"","sources":["../../../lib/managers/piptree.js"],"names":[],"mappings":"AAgIO,uFAoCN"}

package/types/lib/server/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/server/server.js"],"names":[],"mappings":"AA8IA,yDAKC;AAED,0CAgJC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/server/server.js"],"names":[],"mappings":"AA8IA,yDAKC;AAED,0CA0KC"}

package/types/lib/stages/pregen/pregen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pregen.d.ts","sourceRoot":"","sources":["../../../../lib/stages/pregen/pregen.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,iEAkBC;AAED;;;;GAIG;AACH,iEASC;AAED;;;;;GAKG;AACH,wEAqCC;AAED;;;;;GAKG;AACH,qEAyDC;AAED;;;;;;;;GAQG;AACH,uEAmBC;AAED;;;;;GAKG;AACH,0EAyCC;AAED;;;;;GAKG;AACH,sEA6EC;AAED;;;;;GAKG;AACH,qEA8PC"}
+{"version":3,"file":"pregen.d.ts","sourceRoot":"","sources":["../../../../lib/stages/pregen/pregen.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,iEAkBC;AAED;;;;GAIG;AACH,iEASC;AAED;;;;;GAKG;AACH,wEAyCC;AAED;;;;;GAKG;AACH,qEAyDC;AAED;;;;;;;;GAQG;AACH,uEAmBC;AAED;;;;;GAKG;AACH,0EAyCC;AAED;;;;;GAKG;AACH,sEA6EC;AAED;;;;;GAKG;AACH,qEA8PC"}