@cyclonedx/cdxgen 12.4.0 → 12.4.2

package/lib/helpers/dosai.poku.js

@@ -0,0 +1,302 @@
+import esmock from "esmock";
+import { assert, describe, it } from "poku";
+import sinon from "sinon";
+
+import {
+  buildPurlAliasMap,
+  collectDosaiDataFlowFrames,
+  collectDosaiPurlEvidence,
+  collectDosaiServicesFromMethods,
+  isDosaiDotnetLanguage,
+  normalizeDosaiServiceMap,
+  resolveComponentPurl,
+} from "./dosai.js";
+
+describe("dosai helpers", () => {
+  it("recognizes C#, VB.NET, and F# language aliases", () => {
+    for (const language of [
+      "csharp",
+      "dotnet",
+      "vb",
+      "vbnet",
+      "visualbasic",
+      "f#",
+      "fs",
+      "fsharp",
+    ]) {
+      assert.strictEqual(isDosaiDotnetLanguage(language), true);
+    }
+  });
+
+  it("matches versionless dosai purls to cdxgen component purls", () => {
+    const components = [{ purl: "pkg:nuget/System.Text.Json@10.0.0" }];
+    const aliases = buildPurlAliasMap(components);
+
+    assert.strictEqual(
+      resolveComponentPurl("pkg:nuget/System.Text.Json", aliases),
+      "pkg:nuget/System.Text.Json@10.0.0",
+    );
+  });
+
+  it("collects package occurrence evidence from dosai PackageReachability", () => {
+    const methodsSlice = {
+      CallGraph: {
+        Edges: [
+          {
+            Id: "e1",
+            FileName: "System.Text.Json.dll",
+            LineNumber: 12,
+            CalledMethodName: "System.Text.Json.JsonSerializer.Deserialize",
+            TargetName: "Deserialize",
+          },
+        ],
+        Nodes: [
+          {
+            Id: "n1",
+            FileName: "Program.cs",
+            LineNumber: 10,
+            ClassName: "Program",
+            Name: "Main",
+          },
+          {
+            Id: "n2",
+            FileName: "System.Text.Json.dll",
+            LineNumber: 0,
+            ClassName: "JsonSerializer",
+            Name: "Deserialize",
+          },
+        ],
+      },
+      PackageReachability: [
+        {
+          Purl: "pkg:nuget/System.Text.Json",
+          EdgeIds: ["e1"],
+          NodeIds: ["n1", "n2"],
+          SourceLocations: [
+            {
+              Path: "Controllers/Parser.cs",
+              FileName: "Parser.cs",
+              LineNumber: 42,
+              ColumnNumber: 13,
+              Kind: "CallGraphEdge",
+            },
+          ],
+        },
+      ],
+    };
+    const retMap = collectDosaiPurlEvidence(methodsSlice, [
+      { purl: "pkg:nuget/System.Text.Json@10.0.0" },
+    ]);
+
+    assert.deepStrictEqual(
+      Array.from(
+        retMap.purlLocationMap["pkg:nuget/System.Text.Json@10.0.0"],
+      ).sort(),
+      ["Controllers/Parser.cs#42"],
+    );
+    assert.ok(
+      retMap.purlMethodsMap["pkg:nuget/System.Text.Json@10.0.0"].has(
+        "System.Text.Json.JsonSerializer.Deserialize",
+      ),
+    );
+  });
+
+  it("keeps PackageReachability fallback occurrence evidence source-only", () => {
+    const retMap = collectDosaiPurlEvidence(
+      {
+        CallGraph: {
+          Edges: [
+            {
+              Id: "e1",
+              FileName: "System.Text.Json.dll",
+              LineNumber: 12,
+              CalledMethodName: "System.Text.Json.JsonSerializer.Deserialize",
+              CallLocation: {
+                FileName: "Program.fs",
+                LineNumber: 8,
+              },
+            },
+            {
+              Id: "e2",
+              FileName: "Controllers/EpisodesController.cs",
+              LineNumber: 17,
+              CalledMethodName: "System.Text.Json.JsonSerializer.Serialize",
+            },
+          ],
+        },
+        PackageReachability: [
+          {
+            Purl: "pkg:nuget/System.Text.Json",
+            EdgeIds: ["e1", "e2"],
+          },
+        ],
+      },
+      [{ purl: "pkg:nuget/System.Text.Json@10.0.0" }],
+    );
+
+    assert.deepStrictEqual(
+      Array.from(retMap.purlLocationMap["pkg:nuget/System.Text.Json@10.0.0"]),
+      ["Program.fs#8", "Controllers/EpisodesController.cs#17"],
+    );
+    assert.ok(
+      !Array.from(
+        retMap.purlLocationMap["pkg:nuget/System.Text.Json@10.0.0"],
+      ).some((location) => location.includes(".dll")),
+    );
+  });
+
+  it("collects package occurrence evidence from dosai Dependencies with purls", () => {
+    const retMap = collectDosaiPurlEvidence(
+      {
+        Dependencies: [
+          {
+            Path: "Program.vb",
+            FileName: "Program.vb",
+            Name: "Newtonsoft.Json",
+            Purl: "pkg:nuget/Newtonsoft.Json@13.0.3",
+            LineNumber: 4,
+            ColumnNumber: 9,
+          },
+        ],
+      },
+      [{ purl: "pkg:nuget/Newtonsoft.Json@13.0.3" }],
+    );
+
+    assert.deepStrictEqual(
+      Array.from(retMap.purlLocationMap["pkg:nuget/Newtonsoft.Json@13.0.3"]),
+      ["Program.vb#4"],
+    );
+    assert.ok(
+      retMap.purlModulesMap["pkg:nuget/Newtonsoft.Json@13.0.3"].has(
+        "Newtonsoft.Json",
+      ),
+    );
+  });
+
+  it("builds CycloneDX services from dosai ApiEndpoints without raw policy names", () => {
+    const servicesMap = collectDosaiServicesFromMethods({
+      ApiEndpoints: [
+        {
+          Route: "/api/podcasts?sig=secret",
+          FileName: "EpisodesController.cs",
+          Path: "Controllers/EpisodesController.cs",
+          ClassName: "EpisodesController",
+          MethodName: "Get",
+          HttpMethod: "GET",
+          EndpointKind: "Attribute",
+          AuthorizationRequired: true,
+          AuthorizationPolicies: ["InternalPolicyName"],
+          Roles: ["Admin"],
+          AllowAnonymous: false,
+          LineNumber: 42,
+          ColumnNumber: 9,
+        },
+      ],
+    });
+    const services = normalizeDosaiServiceMap(servicesMap);
+
+    assert.strictEqual(services.length, 1);
+    assert.deepStrictEqual(services[0].endpoints, ["/api/podcasts"]);
+    assert.strictEqual(services[0].authenticated, true);
+    assert.ok(
+      services[0].properties.some(
+        (property) =>
+          property.name === "cdx:dosai:authorizationPolicyCount" &&
+          property.value === "1",
+      ),
+    );
+    assert.ok(!JSON.stringify(services[0]).includes("InternalPolicyName"));
+  });
+
+  it("collects callstack frames from dosai data-flow slices", () => {
+    const frames = collectDosaiDataFlowFrames(
+      {
+        Nodes: [
+          {
+            Id: "dfn1",
+            Path: "Controllers/EpisodesController.cs",
+            Namespace: "Podcast.Api",
+            ClassName: "EpisodesController",
+            MethodName: "Get",
+            LineNumber: 12,
+            ColumnNumber: 5,
+          },
+          {
+            Id: "dfn2",
+            Path: "Services/JsonLoader.cs",
+            Namespace: "Podcast.Api",
+            ClassName: "JsonLoader",
+            MethodName: "Load",
+            LineNumber: 20,
+            ColumnNumber: 9,
+          },
+        ],
+        Slices: [
+          {
+            NodeIds: ["dfn1", "dfn2"],
+            Purls: ["pkg:nuget/System.Text.Json"],
+          },
+        ],
+      },
+      [{ purl: "pkg:nuget/System.Text.Json@10.0.0" }],
+    );
+
+    assert.strictEqual(frames["pkg:nuget/System.Text.Json@10.0.0"].length, 1);
+    assert.strictEqual(
+      frames["pkg:nuget/System.Text.Json@10.0.0"][0][1].function,
+      "Load",
+    );
+  });
+
+  it("rejects unsafe dosai command inputs before spawning", async () => {
+    const safeSpawnSync = sinon.stub().returns({ status: 0 });
+    const { runDosaiCommand } = await esmock("./dosai.js", {
+      "./plugins.js": { resolvePluginBinary: sinon.stub().returns("dosai") },
+      "./utils.js": {
+        DEBUG_MODE: false,
+        getTmpDir: sinon.stub().returns("/tmp"),
+        safeExistsSync: sinon.stub().returns(true),
+        safeMkdtempSync: sinon.stub(),
+        safeRmSync: sinon.stub(),
+        safeSpawnSync,
+      },
+    });
+
+    assert.strictEqual(
+      runDosaiCommand("methods;rm -rf /", "/tmp/project", "/tmp/out.json"),
+      false,
+    );
+    assert.strictEqual(
+      runDosaiCommand("methods", "/tmp/project\n--bad", "/tmp/out.json"),
+      false,
+    );
+    sinon.assert.notCalled(safeSpawnSync);
+  });
+
+  it("spawns dosai with argument arrays and shell disabled", async () => {
+    const safeSpawnSync = sinon.stub().returns({ status: 0 });
+    const { runDosaiCommand } = await esmock("./dosai.js", {
+      "./plugins.js": { resolvePluginBinary: sinon.stub().returns("dosai") },
+      "./utils.js": {
+        DEBUG_MODE: false,
+        getTmpDir: sinon.stub().returns("/tmp"),
+        safeExistsSync: sinon.stub().returns(true),
+        safeMkdtempSync: sinon.stub(),
+        safeRmSync: sinon.stub(),
+        safeSpawnSync,
+      },
+    });
+
+    assert.strictEqual(
+      runDosaiCommand("dataflows", "/tmp/project", "/tmp/out.json", {
+        dataFlowPatterns: "/tmp/patterns.json",
+        patternPacks: "/tmp/packs",
+      }),
+      true,
+    );
+    sinon.assert.calledOnce(safeSpawnSync);
+    assert.strictEqual(safeSpawnSync.firstCall.args[0], "dosai");
+    assert.ok(Array.isArray(safeSpawnSync.firstCall.args[1]));
+    assert.strictEqual(safeSpawnSync.firstCall.args[2].shell, false);
+  });
+});

package/lib/helpers/dosaiParsers.js

@@ -0,0 +1,103 @@
+import { PackageURL } from "packageurl-js";
+
+export function normalizeDosaiPurlKey(purl) {
+  if (!purl || typeof purl !== "string") {
+    return undefined;
+  }
+  try {
+    const purlObj = PackageURL.fromString(purl);
+    return [
+      purlObj.type?.toLowerCase(),
+      purlObj.namespace?.toLowerCase() || "",
+      purlObj.name?.toLowerCase(),
+    ].join("/");
+  } catch (_err) {
+    return purl.split("?")[0].split("#")[0].split("@")[0].toLowerCase();
+  }
+}
+
+export function addDosaiSetValue(map, key, value) {
+  if (!key || !value) {
+    return;
+  }
+  map[key] ??= new Set();
+  map[key].add(value);
+}
+
+export function dosaiLocation(item) {
+  const location = item?.Location || item?.CallLocation || item;
+  const fileName =
+    location?.Path || location?.FileName || item?.Path || item?.FileName;
+  if (!fileName || fileName === "<unknown>") {
+    return undefined;
+  }
+  const lineNumber = location?.LineNumber || item?.LineNumber;
+  if (lineNumber && lineNumber > 0) {
+    return `${fileName}#${lineNumber}`;
+  }
+  return fileName;
+}
+
+function dosaiSourceFileName(item) {
+  const location = item?.Location || item?.CallLocation || item;
+  return String(
+    location?.Path || location?.FileName || item?.Path || item?.FileName || "",
+  );
+}
+
+function dosaiSourceLineNumber(item) {
+  const location = item?.Location || item?.CallLocation || item;
+  return location?.LineNumber || item?.LineNumber;
+}
+
+export function dosaiSourceLocationFromNode(node) {
+  const location = dosaiLocation(node);
+  const fileName = dosaiSourceFileName(node).toLowerCase();
+  const lineNumber = dosaiSourceLineNumber(node);
+  if (!location || !/\.(cs|vb|fs|fsx)$/i.test(fileName)) {
+    return undefined;
+  }
+  if (!lineNumber || lineNumber <= 0) {
+    return undefined;
+  }
+  return location;
+}
+
+export function dosaiSourceLocation(location) {
+  const sourceLocation = dosaiLocation(location);
+  const fileName = dosaiSourceFileName(location);
+  const lineNumber = dosaiSourceLineNumber(location);
+  if (!sourceLocation || !/\.(cs|vb|fs|fsx)$/i.test(fileName)) {
+    return undefined;
+  }
+  if (!lineNumber || lineNumber <= 0) {
+    return undefined;
+  }
+  return sourceLocation;
+}
+
+export function buildDosaiPurlAliasMap(components = []) {
+  const purlAliasMap = new Map();
+  for (const component of components) {
+    if (!component?.purl) {
+      continue;
+    }
+    purlAliasMap.set(component.purl, component.purl);
+    const key = normalizeDosaiPurlKey(component.purl);
+    if (key && !purlAliasMap.has(key)) {
+      purlAliasMap.set(key, component.purl);
+    }
+  }
+  return purlAliasMap;
+}
+
+export function resolveDosaiComponentPurl(purl, purlAliasMap) {
+  if (!purl) {
+    return undefined;
+  }
+  return (
+    purlAliasMap.get(purl) ||
+    purlAliasMap.get(normalizeDosaiPurlKey(purl)) ||
+    purl
+  );
+}

package/lib/helpers/plugins.js

@@ -24,6 +24,21 @@ function isMusl() {
   return result?.stdout?.includes("musl") || result?.stderr?.includes("musl");
 }
 
+function hasUsablePluginsDir(pluginsDir) {
+  return (
+    safeExistsSync(pluginsDir) &&
+    (safeExistsSync(join(pluginsDir, "plugins-manifest.json")) ||
+      [
+        "cargo-auditable",
+        "dosai",
+        "osquery",
+        "sourcekitten",
+        "trivy",
+        "trustinspector",
+      ].some((pluginName) => safeExistsSync(join(pluginsDir, pluginName))))
+  );
+}
+
 /**
  * Determine the normalized plugin target tuple for the current runtime.
  *
@@ -81,17 +96,13 @@ export function resolveCdxgenPlugins() {
   let pluginsDir = process.env.CDXGEN_PLUGINS_DIR || "";
   let extraNMBinPath;
 
-  if (
-    !pluginsDir &&
-    safeExistsSync(join(dirNameStr, "plugins")) &&
-    safeExistsSync(join(dirNameStr, "plugins", "trivy"))
-  ) {
+  if (!pluginsDir && hasUsablePluginsDir(join(dirNameStr, "plugins"))) {
     pluginsDir = join(dirNameStr, "plugins");
   }
 
   if (
     !pluginsDir &&
-    safeExistsSync(
+    hasUsablePluginsDir(
       join(
         dirNameStr,
         "node_modules",
@@ -99,16 +110,6 @@ export function resolveCdxgenPlugins() {
         `cdxgen-plugins-bin${target.pluginsBinSuffix}`,
         "plugins",
       ),
-    ) &&
-    safeExistsSync(
-      join(
-        dirNameStr,
-        "node_modules",
-        "@cdxgen",
-        `cdxgen-plugins-bin${target.pluginsBinSuffix}`,
-        "plugins",
-        "trivy",
-      ),
     )
   ) {
     pluginsDir = join(

package/lib/helpers/protobom.js

@@ -11,6 +11,7 @@ import {
   supportedSpecVersions,
 } from "@appthreat/cdx-proto";
 
+import { toCycloneDxSpecVersionString } from "./bomUtils.js";
 import { safeExistsSync, safeWriteSync } from "./utils.js";
 
 const JSON_READ_OPTIONS = {
@@ -29,6 +30,11 @@ const PROTO_BOM_FILE_EXTENSIONS = [".cdx", ".cdx.bin", ".proto"];
 
 const DEFAULT_SPEC_VERSION =
   supportedSpecVersions[supportedSpecVersions.length - 1];
+const PROTO_SUPPORTED_SPEC_VERSIONS = new Set(
+  supportedSpecVersions.map((specVersion) =>
+    toCycloneDxSpecVersionString(specVersion),
+  ),
+);
 
 const isProtoMessageBom = (bom) =>
   Boolean(
@@ -47,6 +53,42 @@ const hasExplicitSpecVersion = (bomJson) =>
       (bomJson.specVersion !== undefined || bomJson.spec_version !== undefined),
   );
 
+const resolveExplicitSpecVersion = (bomJson) =>
+  bomJson?.specVersion ?? bomJson?.spec_version;
+
+const hasProvidedSpecVersion = (specVersion) =>
+  specVersion !== undefined &&
+  specVersion !== null &&
+  `${specVersion}`.trim() !== "";
+
+export const isProtoSupportedSpecVersion = (specVersion) => {
+  if (!hasProvidedSpecVersion(specVersion)) {
+    return true;
+  }
+  const normalizedSpecVersion = toCycloneDxSpecVersionString(specVersion);
+  return (
+    normalizedSpecVersion !== undefined &&
+    PROTO_SUPPORTED_SPEC_VERSIONS.has(normalizedSpecVersion)
+  );
+};
+
+export const assertProtoSupportedSpecVersion = (
+  specVersion,
+  operation = "protobuf operations",
+) => {
+  if (!hasProvidedSpecVersion(specVersion)) {
+    return;
+  }
+  const normalizedSpecVersion = toCycloneDxSpecVersionString(specVersion);
+  if (isProtoSupportedSpecVersion(specVersion)) {
+    return;
+  }
+  const displaySpecVersion = normalizedSpecVersion || `${specVersion}`.trim();
+  throw new Error(
+    `CycloneDX ${displaySpecVersion} is not currently supported for ${operation}. @appthreat/cdx-proto supports ${supportedSpecVersions.join(", ")} only.`,
+  );
+};
+
 const OBJECT_WRAPPED_LIST_FIELDS = ["declarations", "definitions"];
 
 const isPlainObject = (value) =>
@@ -121,15 +163,25 @@ const resolveBomMessage = (bomJson, specVersion = DEFAULT_SPEC_VERSION) => {
       JSON.parse(`${bomJson}`),
     );
     if (hasExplicitSpecVersion(parsedBomJson)) {
+      assertProtoSupportedSpecVersion(
+        resolveExplicitSpecVersion(parsedBomJson),
+        "protobuf serialization",
+      );
       return parseBomJson(parsedBomJson, JSON_READ_OPTIONS);
     }
+    assertProtoSupportedSpecVersion(specVersion, "protobuf serialization");
     return decodeBomJson(specVersion, parsedBomJson, JSON_READ_OPTIONS);
   }
   if (bomJson && typeof bomJson === "object" && !Array.isArray(bomJson)) {
     const normalizedBomJson = normalizeObjectWrappedListsForProto(bomJson);
     if (hasExplicitSpecVersion(normalizedBomJson)) {
+      assertProtoSupportedSpecVersion(
+        resolveExplicitSpecVersion(normalizedBomJson),
+        "protobuf serialization",
+      );
       return parseBomJson(normalizedBomJson, JSON_READ_OPTIONS);
     }
+    assertProtoSupportedSpecVersion(specVersion, "protobuf serialization");
     return decodeBomJson(specVersion, normalizedBomJson, JSON_READ_OPTIONS);
   }
   return createBom(specVersion);
@@ -175,6 +227,7 @@ export const writeBinary = (
  */
 export const readBinary = (binFile, asJson, specVersion) => {
   asJson = asJson ?? true;
+  assertProtoSupportedSpecVersion(specVersion, "protobuf decoding");
   if (!safeExistsSync(binFile)) {
     return undefined;
   }

package/lib/helpers/protobom.poku.js

@@ -3,7 +3,12 @@ import { join } from "node:path";
 
 import { assert, it } from "poku";
 
-import { isProtoBomFile, readBinary, writeBinary } from "./protobom.js";
+import {
+  assertProtoSupportedSpecVersion,
+  isProtoBomFile,
+  readBinary,
+  writeBinary,
+} from "./protobom.js";
 import { getTmpDir } from "./utils.js";
 
 const testBom = JSON.parse(
@@ -137,6 +142,44 @@ it("keeps canonical definitions and declarations as objects during proto round-t
   cleanupTempDir(tempDir);
 });
 
+it("rejects unsupported CycloneDX 2.0 protobuf operations with a clear error", () => {
+  const tempDir = createTempDir();
+  const binFile = join(tempDir, "unsupported-2.0.cdx");
+  assert.throws(
+    () =>
+      writeBinary(
+        {
+          specFormat: "CycloneDX",
+          specVersion: "2.0",
+          version: 1,
+        },
+        binFile,
+      ),
+    /CycloneDX 2\.0 is not currently supported for protobuf serialization/,
+  );
+  assert.throws(
+    () => assertProtoSupportedSpecVersion("2.0", "protobuf export"),
+    /@appthreat\/cdx-proto supports 1\.5, 1\.6, 1\.7 only/,
+  );
+  assert.throws(
+    () =>
+      writeBinary(
+        {
+          bomFormat: "CycloneDX",
+          specVersion: "2.0.1",
+          version: 1,
+        },
+        binFile,
+      ),
+    /CycloneDX 2\.0\.1 is not currently supported for protobuf serialization/,
+  );
+  assert.throws(
+    () => assertProtoSupportedSpecVersion("2.0.1", "protobuf export"),
+    /CycloneDX 2\.0\.1 is not currently supported for protobuf export/,
+  );
+  cleanupTempDir(tempDir);
+});
+
 it("round-trips real CBOM fixture data with cryptographic assets intact", () => {
   const tempDir = createTempDir();
   const binFile = join(tempDir, "cbom-fixture.cdx");

package/lib/helpers/protobomLoader.js

@@ -0,0 +1,43 @@
+const PROTO_BOM_FILE_EXTENSIONS = [".cdx", ".cdx.bin", ".proto"];
+
+/**
+ * Determine whether a path looks like a CycloneDX protobuf BOM file.
+ *
+ * @param {string} filePath File path
+ * @returns {boolean} true when the path uses a protobuf BOM extension
+ */
+export function isProtoBomPath(filePath) {
+  const normalizedPath = `${filePath || ""}`.toLowerCase();
+  return PROTO_BOM_FILE_EXTENSIONS.some((extension) =>
+    normalizedPath.endsWith(extension),
+  );
+}
+
+/**
+ * Import protobuf BOM helpers and replace optional-dependency loader failures
+ * with actionable command-specific messages.
+ *
+ * @param {string} [commandName="cdxgen"] CLI command name
+ * @param {string} [featureDescription="protobuf support"] Feature being used
+ * @returns {Promise<object>} Loaded protobom module namespace
+ */
+export async function importProtobomModule(
+  commandName = "cdxgen",
+  featureDescription = "protobuf support",
+) {
+  try {
+    return await import("./protobom.js");
+  } catch (error) {
+    const message = `${error?.message || ""}`;
+    if (
+      error?.code === "ERR_MODULE_NOT_FOUND" ||
+      message.includes("@appthreat/cdx-proto") ||
+      message.includes("@bufbuild/protobuf")
+    ) {
+      throw new Error(
+        `${commandName} ${featureDescription} requires the optional '@appthreat/cdx-proto' and '@bufbuild/protobuf' dependencies. Install optional dependencies or use a binary that bundles protobuf support.`,
+      );
+    }
+    throw error;
+  }
+}

package/lib/helpers/protobomLoader.poku.js

@@ -0,0 +1,31 @@
+import { assert, describe, it } from "poku";
+
+import { importProtobomModule, isProtoBomPath } from "./protobomLoader.js";
+
+describe("protobomLoader", () => {
+  it("detects protobuf BOM file extensions", () => {
+    assert.strictEqual(isProtoBomPath("bom.cdx"), true);
+    assert.strictEqual(isProtoBomPath("bom.CDX.BIN"), true);
+    assert.strictEqual(isProtoBomPath("bom.proto"), true);
+    assert.strictEqual(isProtoBomPath("bom.json"), false);
+    assert.strictEqual(isProtoBomPath(""), false);
+  });
+
+  it("imports the protobuf BOM helper when optional support is installed", async () => {
+    let protobomModule;
+    try {
+      protobomModule = await importProtobomModule(
+        "cdx-test",
+        "protobuf BOM input",
+      );
+    } catch (error) {
+      assert.match(
+        error.message,
+        /requires the optional '@appthreat\/cdx-proto' and '@bufbuild\/protobuf' dependencies/u,
+      );
+      return;
+    }
+    assert.strictEqual(typeof protobomModule.readBinary, "function");
+    assert.strictEqual(typeof protobomModule.writeBinary, "function");
+  });
+});