efiencrypt 0.0.0

package/build-laCVTTyp.js

@@ -0,0 +1,2438 @@
+import { spawn } from "node:child_process";
+import { readFile, mkdtemp, mkdir, cp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { randomBytes, createHash, createCipheriv } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { Readable, Transform } from "node:stream";
+import { resolveSmbiosField, getSmbiosField, smbiosDataTypeSize, parseSmbios } from "./smbios.js";
+class StringBuilder {
+  #content = [];
+  write(content) {
+    this.#content.push(content);
+    return this;
+  }
+  async *#read() {
+    const content = this.#content;
+    this.#content = [];
+    while (content.length > 0) {
+      const item = content.shift();
+      if (item instanceof StringBuilder) {
+        content.unshift(...item.#content);
+        item.#content = [];
+      } else if (typeof item === "string") {
+        yield item;
+      } else if (Readable.isReadable(item)) {
+        for await (const part of item) {
+          yield part;
+        }
+      }
+    }
+  }
+  toReadable() {
+    return Readable.from(this.#read(), {
+      objectMode: false,
+      encoding: "ascii"
+    });
+  }
+}
+const hex = (buffer) => {
+  const res = Buffer.alloc(buffer.length * 6, " 0x00,");
+  for (let i = 0; i < buffer.length; i++) {
+    if (i % 16 === 0) {
+      res.write("\n", i * 6, "ascii");
+    }
+    const byte = buffer.at(i);
+    res.write(byte.toString(16), i * 6 + (byte >= 16 ? 3 : 4), "ascii");
+  }
+  return res;
+};
+class CountTransform extends Transform {
+  length = 0;
+  constructor() {
+    super({
+      objectMode: false
+    });
+  }
+  _transform(chunk, encoding, callback) {
+    chunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this.length += chunk.length;
+    callback(null, chunk);
+  }
+}
+class HexTransform extends CountTransform {
+  _transform(chunk, encoding, callback) {
+    super._transform(chunk, encoding, (err, data) => callback(err, hex(data)));
+  }
+}
+class HexCVarTransform extends HexTransform {
+  #varName;
+  #static;
+  constructor(varName, isStatic) {
+    super();
+    this.#varName = varName;
+    this.#static = isStatic;
+    this.push(`${this.#static ? "static " : ""}uint8_t ${this.#varName}[] = {`);
+  }
+  _flush(callback) {
+    this.push(`};
+${this.#static ? "static " : ""}size_t ${this.#varName}_len = 0x${this.length.toString(16)};
+`);
+    callback();
+  }
+}
+class CodeBuilder {
+  #varCounter = 0;
+  #blocks = /* @__PURE__ */ new Map();
+  #alreadyIncluded = /* @__PURE__ */ new Map();
+  curBlock = "main";
+  constructor(header = "") {
+    this.#blocks.set(this.curBlock, new StringBuilder());
+    this.write(header);
+    this.writeNewBlock("headers");
+    this.writeNewBlock("global");
+  }
+  changeCurBlock(curBlock, fn) {
+    const savedCurBlock = this.curBlock;
+    try {
+      this.curBlock = curBlock;
+      fn();
+    } finally {
+      this.curBlock = savedCurBlock;
+    }
+  }
+  newVar() {
+    return `var${this.#varCounter++}`;
+  }
+  write(code, blockName = this.curBlock) {
+    this.#blocks.get(blockName).write(code);
+  }
+  writeNewBlock(newBlockName, blockName = this.curBlock) {
+    const newBlock = new StringBuilder();
+    if (this.#blocks.has(newBlockName)) {
+      throw new Error(`Block ${newBlockName} already exists!`);
+    }
+    this.#blocks.set(newBlockName, newBlock);
+    this.write(newBlock, blockName);
+  }
+  createBinaryVar(content, varName, blockName = "global") {
+    const isStatic = !varName;
+    if (!varName) {
+      varName = this.newVar();
+    }
+    const readable = Buffer.isBuffer(content) ? Readable.from(content) : content;
+    this.write(readable.pipe(new HexCVarTransform(varName, isStatic)), blockName);
+    return varName;
+  }
+  insertOnce(name, fn) {
+    let data = this.#alreadyIncluded.get(name);
+    if (!data) {
+      data = {};
+      this.#alreadyIncluded.set(name, data);
+      fn(data);
+    }
+    return data;
+  }
+  addHeader(header) {
+    const headerCode = `#include ${header}
+`;
+    this.insertOnce(header, () => {
+      this.write(headerCode, "headers");
+    });
+  }
+  toReadable() {
+    return this.#blocks.get("main").toReadable();
+  }
+}
+const reorderHash = (hash) => {
+  for (let i = 0; i < 8; i++) {
+    hash.writeUint32LE(hash.readUInt32BE(i * 4), i * 4);
+  }
+  return hash;
+};
+const reorderUUID = (buffer) => {
+  buffer.writeUint32LE(buffer.readUInt32BE(0), 0);
+  buffer.writeUint16LE(buffer.readUInt16BE(4), 4);
+  buffer.writeUint16LE(buffer.readUInt16BE(6), 6);
+  return buffer;
+};
+const uuidRegExp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const parseUUID = (uuid) => {
+  if (!uuidRegExp.test(uuid)) {
+    throw new Error("Invalid UUID");
+  }
+  return reorderUUID(Buffer.from(uuid.replaceAll("-", ""), "hex"));
+};
+const fail = (msg) => {
+  throw new Error(msg);
+};
+const hashData = async (hash, binaryData) => {
+  if (binaryData.type === "missing") {
+    return binaryData.size ?? 1;
+  }
+  if (binaryData.type === "file") {
+    const count = new CountTransform();
+    const start = binaryData.offset ?? 0;
+    await pipeline(
+      createReadStream(binaryData.file, {
+        start,
+        end: binaryData.size != null ? start + binaryData.size - 1 : Infinity
+      }),
+      count,
+      hash,
+      { end: false }
+    );
+    return count.length;
+  }
+  const buffer = binaryData.type === "buffer" ? binaryData.buffer : Buffer.from(binaryData.buffer, binaryData.type);
+  hash.update(buffer);
+  return buffer.length;
+};
+const codeBlockDiskSectorVar = (codeBuilder) => {
+  codeBuilder.insertOnce(`diskSector`, () => {
+    codeBuilder.write(`UINT8 *diskSector = NULL;
+`, "gen_compute_hash_vars");
+  });
+};
+const codeBlockProtocolGuid = (codeBuilder, protocolName) => {
+  codeBuilder.insertOnce(`GUID_${protocolName}`, () => {
+    codeBuilder.insertOnce("guidVars", () => codeBuilder.writeNewBlock("guidVars", "gen_compute_hash_vars"));
+    codeBuilder.write(`EFI_GUID GUID_${protocolName} = EFI_${protocolName}_PROTOCOL_GUID;
+`, "guidVars");
+  });
+};
+const codeBlockLoadedImage = (codeBuilder) => {
+  codeBuilder.insertOnce("loadedImage", () => {
+    codeBlockProtocolGuid(codeBuilder, "LOADED_IMAGE");
+    codeBuilder.write("EFI_LOADED_IMAGE_PROTOCOL *loadedImage = NULL;\n", "gen_compute_hash_vars");
+    codeBuilder.write(
+      `HANDLE_PROTOCOL(image_handle, GUID_LOADED_IMAGE, &loadedImage);
+CHECK_ERROR(!loadedImage);
+`,
+      "gen_compute_hash_prep"
+    );
+  });
+};
+const codeBlockDevicePathToText = (codeBuilder) => {
+  codeBuilder.insertOnce("devicePathToText", () => {
+    codeBlockProtocolGuid(codeBuilder, "DEVICE_PATH_TO_TEXT");
+    codeBuilder.write("EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *devicePathToText = NULL;\n", "gen_compute_hash_vars");
+    codeBuilder.write(
+      `status = uefi_call_wrapper(gBS->LocateProtocol, 3, &GUID_DEVICE_PATH_TO_TEXT, NULL, &devicePathToText);
+CHECK_ERROR(!devicePathToText);
+`,
+      "gen_compute_hash_prep"
+    );
+  });
+};
+const codeBlockBootPartitionDevice = (codeBuilder) => {
+  codeBuilder.insertOnce("bootPartitionDevice", () => {
+    codeBlockLoadedImage(codeBuilder);
+    codeBlockDevicePathToText(codeBuilder);
+    codeBlockProtocolGuid(codeBuilder, "DEVICE_PATH");
+    codeBuilder.write("EFI_DEVICE_PATH_PROTOCOL *bootDevice = NULL;\n", "gen_compute_hash_vars");
+    codeBuilder.write(
+      `HANDLE_PROTOCOL(loadedImage->DeviceHandle, GUID_DEVICE_PATH, &bootDevice);
+CHECK_ERROR(!bootDevice);
+CHAR16 *bootPartitionDeviceString = (void *)uefi_call_wrapper(devicePathToText->ConvertDevicePathToText, 3, bootDevice, FALSE, FALSE);
+CHECK_ERROR(!bootPartitionDeviceString);
+UINTN bootPartitionDeviceStringLen = 2 * RtStrLen(bootPartitionDeviceString);
+`,
+      "gen_compute_hash_prep"
+    );
+  });
+};
+const codeBlockBootFile = (codeBuilder) => {
+  codeBuilder.insertOnce("bootFile", () => {
+    codeBlockLoadedImage(codeBuilder);
+    codeBlockDevicePathToText(codeBuilder);
+    codeBuilder.write(
+      `CHAR16 *bootFileString = (void *)uefi_call_wrapper(devicePathToText->ConvertDevicePathToText, 3, loadedImage->FilePath, FALSE, FALSE);
+CHECK_ERROR(!bootFileString);
+UINTN bootFileStringLen = 2 * RtStrLen(bootFileString);
+`,
+      "gen_compute_hash_prep"
+    );
+  });
+};
+const codeBlockFindBlock = (codeBuilder) => codeBuilder.insertOnce("findBlock", (data) => {
+  data.salt = randomBytes(32);
+  const saltVarName = codeBuilder.createBinaryVar(data.salt);
+  codeBlockProtocolGuid(codeBuilder, "DEVICE_PATH");
+  codeBlockProtocolGuid(codeBuilder, "BLOCK_IO");
+  codeBuilder.write(
+    `UINTN blockIONbHandles = 0;
+EFI_HANDLE *blockIOHandles = NULL;
+status = uefi_call_wrapper(gBS->LocateHandleBuffer, 5, ByProtocol, &GUID_BLOCK_IO, NULL, &blockIONbHandles, &blockIOHandles);
+CHECK_ERROR(0);
+for (UINTN i = 0; i < blockIONbHandles; i++)
+{
+    EFI_BLOCK_IO_PROTOCOL *bio = NULL;
+    HANDLE_PROTOCOL(blockIOHandles[i], GUID_BLOCK_IO, &bio);
+    if (EFI_ERROR(status) || !bio || !bio->Media->BlockSize)
+        continue;
+    EFI_DEVICE_PATH_PROTOCOL *devPath = NULL;
+    HANDLE_PROTOCOL(blockIOHandles[i], GUID_DEVICE_PATH, &devPath);
+    if (EFI_ERROR(status) || !devPath)
+        continue;
+    CHAR16 *devPathString = (void *)uefi_call_wrapper(devicePathToText->ConvertDevicePathToText, 3, devPath, FALSE, FALSE);
+    if (!devPathString)
+        continue;
+    UINTN devPathStringLen = 2 * RtStrLen(devPathString);
+    if (devPathStringLen)
+    {
+			sha256_context_t devPathStringHash;
+    	sha256_init(&devPathStringHash);
+			sha256_update(&devPathStringHash, ${saltVarName}, ${saltVarName}_len);
+    	sha256_update(&devPathStringHash, (void*)devPathString, devPathStringLen);
+    	sha256_finalize(&devPathStringHash);
+`
+  );
+  codeBuilder.writeNewBlock("blockIOHandlesTestDevice");
+  codeBuilder.write(`
+		}
+}
+FREE_POOL(blockIOHandles);
+`);
+});
+const codeBlockGetDeviceHandle = (codeBuilder, device) => codeBuilder.insertOnce(`deviceHandle:${device ?? ""}`, (data) => {
+  data.varName = codeBuilder.newVar();
+  codeBuilder.write(
+    `EFI_HANDLE ${data.varName}_handle = NULL;
+EFI_BLOCK_IO_PROTOCOL *${data.varName}_bio = NULL;
+UINT64 ${data.varName}_size = 0;
+CHAR16 *${data.varName}_devPathString = NULL;
+UINTN ${data.varName}_devPathStringLen = 0;
+`,
+    "gen_compute_hash_vars"
+  );
+  const { salt } = codeBlockFindBlock(codeBuilder);
+  let condition;
+  if (device) {
+    const hashVar = codeBuilder.createBinaryVar(reorderHash(createHash("sha256").update(salt).update(device, "utf16le").digest()));
+    condition = `RtCompareMem(devPathStringHash.hash, ${hashVar}, 32) == 0`;
+  } else {
+    codeBlockBootPartitionDevice(codeBuilder);
+    condition = `!bio->Media->LogicalPartition && devPathStringLen && devPathStringLen <= bootPartitionDeviceStringLen && RtCompareMem(devPathString, bootPartitionDeviceString, devPathStringLen) == 0`;
+  }
+  codeBuilder.write(
+    `if (${condition}) {
+${data.varName}_handle = blockIOHandles[i];
+${data.varName}_bio = bio;
+${data.varName}_devPathString = devPathString;
+${data.varName}_devPathStringLen = devPathStringLen;
+${data.varName}_size = ((bio->Media->LastBlock + 1) * bio->Media->BlockSize);
+}
+`,
+    "blockIOHandlesTestDevice"
+  );
+});
+const codeBlockGetDeviceDiskIO = (codeBuilder, device) => codeBuilder.insertOnce(`deviceDiskIO:${device ?? ""}`, (data) => {
+  data.varName = codeBlockGetDeviceHandle(codeBuilder, device).varName;
+  codeBlockProtocolGuid(codeBuilder, "DISK_IO");
+  codeBuilder.write(`EFI_DISK_IO_PROTOCOL *${data.varName}_dio = NULL;
+`, "gen_compute_hash_vars");
+  codeBuilder.write(`if (${data.varName}_handle) { HANDLE_PROTOCOL(${data.varName}_handle, GUID_DISK_IO, &${data.varName}_dio); }
+`);
+});
+const codeBlockGetDeviceVolume = (codeBuilder, device) => codeBuilder.insertOnce(`deviceVolume:${device ?? ""}`, (data) => {
+  let handleVariable;
+  if (device) {
+    data.varName = codeBlockGetDeviceHandle(codeBuilder, device).varName;
+    handleVariable = `${data.varName}_handle`;
+  } else {
+    codeBlockLoadedImage(codeBuilder);
+    data.varName = "efiDevice";
+    handleVariable = "loadedImage->DeviceHandle";
+  }
+  codeBlockProtocolGuid(codeBuilder, "SIMPLE_FILE_SYSTEM");
+  codeBuilder.write(`EFI_FILE_IO_INTERFACE *${data.varName}_fio = NULL;
+`, "gen_compute_hash_vars");
+  codeBuilder.write(`EFI_FILE_HANDLE ${data.varName}_volume = NULL;
+`, "gen_compute_hash_vars");
+  codeBuilder.write(`if (${handleVariable}) {
+	HANDLE_PROTOCOL(${handleVariable}, GUID_SIMPLE_FILE_SYSTEM, &${data.varName}_fio);
+	if (${data.varName}_fio) {
+		uefi_call_wrapper(${data.varName}_fio->OpenVolume, 2, ${data.varName}_fio, &${data.varName}_volume);
+	}
+}
+`);
+});
+const codeBlockGetFile = (codeBuilder, file, device) => codeBuilder.insertOnce(`file:${device ?? ""}:${file}`, (data) => {
+  data.varName = codeBuilder.newVar();
+  const { varName: deviceVar } = codeBlockGetDeviceVolume(codeBuilder, device);
+  codeBuilder.write(`EFI_FILE_HANDLE ${data.varName}_handle = NULL;
+`, "gen_compute_hash_vars");
+  codeBuilder.write(`EFI_FILE_INFO *${data.varName}_fileInfo = NULL;
+`, "gen_compute_hash_vars");
+  codeBuilder.write(`if (${deviceVar}_volume) {
+	uefi_call_wrapper(${deviceVar}_volume->Open, 5, ${deviceVar}_volume, &${data.varName}_handle, L${JSON.stringify(file)}, EFI_FILE_MODE_READ, EFI_FILE_READ_ONLY | EFI_FILE_HIDDEN | EFI_FILE_SYSTEM);
+	if (${data.varName}_handle) {
+		${data.varName}_fileInfo = LibFileInfo(${data.varName}_handle);
+	}
+}
+`);
+});
+const handlers = {
+  random({ hash, codeBuilder, hashComponent }) {
+    const secret = randomBytes(hashComponent.length);
+    hash.update(secret);
+    const secretVar = codeBuilder.createBinaryVar(secret);
+    codeBuilder.write(`sha256_update(hash, ${secretVar}, ${secretVar}_len);
+`);
+  },
+  smbios({ hash, codeBuilder, hashComponent, smbios }) {
+    const fieldRef = resolveSmbiosField(hashComponent.ref);
+    const value = hashComponent.value ?? getSmbiosField(smbios ?? fail("Missing SMBIOS information"), fieldRef);
+    if (value) {
+      if (typeof value === "string" && fieldRef.type != "string") {
+        if (fieldRef.type === "uuid") {
+          hash.update(parseUUID(value));
+        } else {
+          hash.update(Buffer.from(value, "hex"));
+        }
+      } else {
+        hash.update(value);
+      }
+      if (fieldRef.type === "string") {
+        hash.update("\0");
+      }
+    }
+    codeBuilder.addHeader('"smbios.h"');
+    if ("type" in fieldRef.table) {
+      codeBuilder.write(
+        `status = smbios_hashValue(hash, 0, ${fieldRef.table.type}, ${fieldRef.table.index ?? 0}, ${fieldRef.offset}, ${fieldRef.type === "string" ? 0 : smbiosDataTypeSize[fieldRef.type]});
+`
+      );
+    } else {
+      codeBuilder.write(
+        `status = smbios_hashValue(hash, 1, ${fieldRef.table.handle & 255}, ${fieldRef.table.handle >> 8 & 255}, ${fieldRef.offset}, ${fieldRef.type === "string" ? 0 : smbiosDataTypeSize[fieldRef.type]});
+`
+      );
+    }
+    codeBuilder.write("CHECK_ERROR(0);\n");
+  },
+  "boot-partition-device"({ hash, codeBuilder, hashComponent }) {
+    hash.update(Buffer.from(hashComponent.value, "utf16le"));
+    hash.update("\0\0");
+    codeBlockBootPartitionDevice(codeBuilder);
+    codeBuilder.write(`sha256_update(hash, (void*)bootPartitionDeviceString, bootPartitionDeviceStringLen + 2);
+`);
+  },
+  "boot-hd-device"({ hash, codeBuilder, hashComponent }) {
+    hash.update(Buffer.from(hashComponent.value, "utf16le"));
+    hash.update("\0\0");
+    const { varName } = codeBlockGetDeviceHandle(codeBuilder);
+    codeBuilder.write(`if (${varName}_devPathString) sha256_update(hash, (void*)${varName}_devPathString, ${varName}_devPathStringLen + 2);
+`);
+  },
+  "boot-file"({ hash, codeBuilder, hashComponent }) {
+    hash.update(Buffer.from(hashComponent.value, "utf16le"));
+    hash.update("\0\0");
+    codeBlockBootFile(codeBuilder);
+    codeBuilder.write(`sha256_update(hash, (void*)bootFileString, bootFileStringLen + 2);
+`);
+  },
+  "hd-size"({ hash, codeBuilder, hashComponent }) {
+    if (hashComponent.value !== "missing") {
+      const size = Buffer.alloc(8);
+      size.writeBigUInt64LE(BigInt(hashComponent.value));
+      hash.update(size);
+    }
+    const { varName } = codeBlockGetDeviceHandle(codeBuilder, hashComponent.device);
+    codeBuilder.write(`if (${varName}_bio) sha256_update(hash, (void*)&${varName}_size, sizeof ${varName}_size);
+`);
+  },
+  async "hd-data"({ hash, codeBuilder, hashComponent }) {
+    const size = await hashData(hash, hashComponent.value);
+    codeBlockDiskSectorVar(codeBuilder);
+    const { varName } = codeBlockGetDeviceDiskIO(codeBuilder, hashComponent.device);
+    const offset = BigInt(hashComponent.offset);
+    const startPos = hashComponent.offsetRef === "start" ? offset : `${varName}_size - ${offset} - ${size}`;
+    codeBuilder.write(`if (${varName}_dio && ${offset} + ${size} <= ${varName}_size) {
+	diskSector = AllocatePool(${size});
+	if (diskSector) {
+		status = uefi_call_wrapper(${varName}_dio->ReadDisk, 5, ${varName}_dio, ${varName}_bio->Media->MediaId, ${startPos}, ${size}, diskSector);
+		if (!EFI_ERROR(status)) {
+			sha256_update(hash, diskSector, ${size});
+		}
+		FREE_POOL(diskSector);
+	}
+}
+`);
+  },
+  "file-size"({ hash, codeBuilder, hashComponent }) {
+    if (hashComponent.value !== "missing") {
+      const size = Buffer.alloc(8);
+      size.writeBigUInt64LE(BigInt(hashComponent.value));
+      hash.update(size);
+    }
+    const { varName } = codeBlockGetFile(codeBuilder, hashComponent.file, hashComponent.device);
+    codeBuilder.write(`if (${varName}_fileInfo) sha256_update(hash, (void*)&${varName}_fileInfo->FileSize, 8);
+`);
+  },
+  async "file-data"({ hash, codeBuilder, hashComponent }) {
+    const size = await hashData(hash, hashComponent.value);
+    codeBlockDiskSectorVar(codeBuilder);
+    const { varName } = codeBlockGetFile(codeBuilder, hashComponent.file, hashComponent.device);
+    const ref = hashComponent.offsetRef ?? "full";
+    const offset = BigInt(ref === "full" ? 0 : hashComponent.offset ?? "0");
+    const startPos = ref === "end" ? `${varName}_fileInfo->FileSize - ${offset} - ${size}` : offset;
+    codeBuilder.write(`if (${varName}_fileInfo) {
+	UINT64 size = ${ref === "full" ? `${varName}_fileInfo->FileSize` : size};
+	if (size + ${hashComponent.offset ?? 0} <= ${varName}_fileInfo->FileSize) {
+		diskSector = AllocatePool(size);
+		if (diskSector) {
+			status = uefi_call_wrapper(${varName}_handle->SetPosition, 2, ${varName}_handle, ${startPos});
+			if (!EFI_ERROR(status)) {
+				status = uefi_call_wrapper(${varName}_handle->Read, 3, ${varName}_handle, &size, diskSector);
+				if (!EFI_ERROR(status)) {
+					sha256_update(hash, diskSector, size);
+				}
+			}
+			FREE_POOL(diskSector);
+		}
+	}
+}
+`);
+  }
+};
+const genCode = async (config) => {
+  const codeBuilder = new CodeBuilder("/*\n * DO NOT EDIT! This file was generated automatically!\n */\n");
+  codeBuilder.addHeader('"gen-code.h"');
+  codeBuilder.write(
+    `EFI_STATUS gen_compute_hash(sha256_context_t *hash, EFI_HANDLE image_handle) {
+EFI_STATUS status = 0;
+`
+  );
+  codeBuilder.writeNewBlock("gen_compute_hash_vars");
+  codeBuilder.writeNewBlock("gen_compute_hash_prep");
+  codeBuilder.writeNewBlock("gen_compute_hash");
+  codeBuilder.write("return status;\n}\n");
+  codeBuilder.curBlock = "gen_compute_hash";
+  const hash = createHash("sha256");
+  const smbios = config.smbios ? parseSmbios(await readFile(config.smbios)) : void 0;
+  for (const hashComponent of config.hashComponents) {
+    const handler = handlers[hashComponent.type];
+    await handler({ hashComponent, codeBuilder, config, hash, smbios });
+  }
+  const iv = randomBytes(16);
+  codeBuilder.createBinaryVar(iv, "iv");
+  const cipher = createCipheriv("aes-256-cbc", reorderHash(hash.digest()), iv);
+  codeBuilder.createBinaryVar(createReadStream(config.inputFile).pipe(cipher), "enc_payload");
+  await pipeline(codeBuilder.toReadable(), createWriteStream(join(config.buildFolder, "gen-code.c")));
+};
+const validate = validate10;
+const schema11 = { "properties": { "$schema": { "type": "string" }, "inputFile": { "description": "Path to the input efi file to embed.", "type": "string" }, "outputFile": { "description": "Path to the output efi file to write.", "type": "string" }, "skipGenCode": { "description": "Whether to skip generating code", "type": "boolean" }, "skipExtract": { "description": "Whether to skip extracting source code\n(can be useful if the extraction was already done)", "type": "boolean" }, "skipMake": { "description": "Whether to skip calling make\n(can be useful to change the code before calling make)", "type": "boolean" }, "buildFolder": { "description": "Folder where to build the code.\nDefaults to a temporary folder that is removed when the build is finished.", "type": "string" }, "hashComponents": { "description": "Data to include in the hash for encryption.", "type": "array", "items": { "$ref": "#/definitions/HashComponent" } }, "smbios": { "description": "Path to the input smbios dump file.\nCan be produced by: dmidecode --dump-bin <filePath>", "type": "string" } } };
+const func2 = Object.prototype.hasOwnProperty;
+const schema32 = { "properties": { "type": { "enum": ["boot-file", "boot-hd-device", "boot-partition-device"] } } };
+const schema15 = { "anyOf": [{ "type": "object", "properties": { "table": { "$ref": "#/definitions/SmbiosTableRef" }, "offset": { "type": "number" }, "type": { "enum": ["byte", "dword", "qword", "string", "uuid", "word"], "type": "string" } }, "additionalProperties": false, "required": ["offset", "table", "type"] }, { "enum": ["baseboard-asset-tag", "baseboard-manufacturer", "baseboard-product-name", "baseboard-serial-number", "baseboard-version", "bios-release-date", "bios-revision", "bios-vendor", "bios-version", "chassis-asset-tag", "chassis-manufacturer", "chassis-serial-number", "chassis-version", "processor-manufacturer", "processor-version", "system-family", "system-manufacturer", "system-product-name", "system-serial-number", "system-sku-number", "system-uuid", "system-version"], "type": "string" }] };
+const schema16 = { "anyOf": [{ "type": "object", "properties": { "handle": { "type": "number" } }, "additionalProperties": false, "required": ["handle"] }, { "type": "object", "properties": { "type": { "type": "number" }, "index": { "type": "number" } }, "additionalProperties": false, "required": ["type"] }, { "enum": ["32-bit Memory Error", "64-bit Memory Error", "Additional Information", "Baseboard", "Boot Integrity Services", "Built-in Pointing Device", "Cache", "Chassis", "Cooling Device", "Electrical Current Probe", "Firmware Inventory", "Firmware Language", "Group Associations", "Hardware Security", "IPMI Device", "Management Controller Host Interface", "Management Device", "Management Device Component", "Management Device Threshold Data", "Memory Array Mapped Address", "Memory Channel", "Memory Controller", "Memory Device", "Memory Device Mapped Address", "Memory Module", "OEM Strings", "Onboard Devices", "Onboard Devices Extended Information", "Out-of-band Remote Access", "Physical Memory Array", "Platform Firmware", "Port Connector", "Portable Battery", "Power Supply", "Processor", "Processor Additional Information", "String Property", "System", "System Boot", "System Configuration Options", "System Event Log", "System Power Controls", "System Reset", "System Slots", "TPM Device", "Temperature Probe", "Voltage Probe"], "type": "string" }, { "type": "number" }] };
+function validate13(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const _errs0 = errors;
+  let valid0 = false;
+  const _errs1 = errors;
+  if (errors === _errs1) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.offset === void 0 && (missing0 = "offset") || data.table === void 0 && (missing0 = "table") || data.type === void 0 && (missing0 = "type")) {
+        const err0 = { instancePath, schemaPath: "#/anyOf/0/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" };
+        if (vErrors === null) {
+          vErrors = [err0];
+        } else {
+          vErrors.push(err0);
+        }
+        errors++;
+      } else {
+        const _errs3 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "table" || key0 === "offset" || key0 === "type")) {
+            const err1 = { instancePath, schemaPath: "#/anyOf/0/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+              vErrors = [err1];
+            } else {
+              vErrors.push(err1);
+            }
+            errors++;
+            break;
+          }
+        }
+        if (_errs3 === errors) {
+          if (data.table !== void 0) {
+            let data0 = data.table;
+            const _errs4 = errors;
+            const _errs6 = errors;
+            let valid3 = false;
+            const _errs7 = errors;
+            if (errors === _errs7) {
+              if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                let missing1;
+                if (data0.handle === void 0 && (missing1 = "handle")) {
+                  const err2 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/0/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                  if (vErrors === null) {
+                    vErrors = [err2];
+                  } else {
+                    vErrors.push(err2);
+                  }
+                  errors++;
+                } else {
+                  const _errs9 = errors;
+                  for (const key1 in data0) {
+                    if (!(key1 === "handle")) {
+                      const err3 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/0/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                      if (vErrors === null) {
+                        vErrors = [err3];
+                      } else {
+                        vErrors.push(err3);
+                      }
+                      errors++;
+                      break;
+                    }
+                  }
+                  if (_errs9 === errors) {
+                    if (data0.handle !== void 0) {
+                      let data1 = data0.handle;
+                      if (!(typeof data1 == "number" && isFinite(data1))) {
+                        const err4 = { instancePath: instancePath + "/table/handle", schemaPath: "#/definitions/SmbiosTableRef/anyOf/0/properties/handle/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                        if (vErrors === null) {
+                          vErrors = [err4];
+                        } else {
+                          vErrors.push(err4);
+                        }
+                        errors++;
+                      }
+                    }
+                  }
+                }
+              } else {
+                const err5 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/0/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                  vErrors = [err5];
+                } else {
+                  vErrors.push(err5);
+                }
+                errors++;
+              }
+            }
+            var _valid1 = _errs7 === errors;
+            valid3 = valid3 || _valid1;
+            if (!valid3) {
+              const _errs12 = errors;
+              if (errors === _errs12) {
+                if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                  let missing2;
+                  if (data0.type === void 0 && (missing2 = "type")) {
+                    const err6 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/1/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" };
+                    if (vErrors === null) {
+                      vErrors = [err6];
+                    } else {
+                      vErrors.push(err6);
+                    }
+                    errors++;
+                  } else {
+                    const _errs14 = errors;
+                    for (const key2 in data0) {
+                      if (!(key2 === "type" || key2 === "index")) {
+                        const err7 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/1/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                        if (vErrors === null) {
+                          vErrors = [err7];
+                        } else {
+                          vErrors.push(err7);
+                        }
+                        errors++;
+                        break;
+                      }
+                    }
+                    if (_errs14 === errors) {
+                      if (data0.type !== void 0) {
+                        let data2 = data0.type;
+                        const _errs15 = errors;
+                        if (!(typeof data2 == "number" && isFinite(data2))) {
+                          const err8 = { instancePath: instancePath + "/table/type", schemaPath: "#/definitions/SmbiosTableRef/anyOf/1/properties/type/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                          if (vErrors === null) {
+                            vErrors = [err8];
+                          } else {
+                            vErrors.push(err8);
+                          }
+                          errors++;
+                        }
+                        var valid5 = _errs15 === errors;
+                      } else {
+                        var valid5 = true;
+                      }
+                      if (valid5) {
+                        if (data0.index !== void 0) {
+                          let data3 = data0.index;
+                          const _errs17 = errors;
+                          if (!(typeof data3 == "number" && isFinite(data3))) {
+                            const err9 = { instancePath: instancePath + "/table/index", schemaPath: "#/definitions/SmbiosTableRef/anyOf/1/properties/index/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                            if (vErrors === null) {
+                              vErrors = [err9];
+                            } else {
+                              vErrors.push(err9);
+                            }
+                            errors++;
+                          }
+                          var valid5 = _errs17 === errors;
+                        } else {
+                          var valid5 = true;
+                        }
+                      }
+                    }
+                  }
+                } else {
+                  const err10 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                  if (vErrors === null) {
+                    vErrors = [err10];
+                  } else {
+                    vErrors.push(err10);
+                  }
+                  errors++;
+                }
+              }
+              var _valid1 = _errs12 === errors;
+              valid3 = valid3 || _valid1;
+              if (!valid3) {
+                const _errs19 = errors;
+                if (typeof data0 !== "string") {
+                  const err11 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/2/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                  if (vErrors === null) {
+                    vErrors = [err11];
+                  } else {
+                    vErrors.push(err11);
+                  }
+                  errors++;
+                }
+                if (!(data0 === "32-bit Memory Error" || data0 === "64-bit Memory Error" || data0 === "Additional Information" || data0 === "Baseboard" || data0 === "Boot Integrity Services" || data0 === "Built-in Pointing Device" || data0 === "Cache" || data0 === "Chassis" || data0 === "Cooling Device" || data0 === "Electrical Current Probe" || data0 === "Firmware Inventory" || data0 === "Firmware Language" || data0 === "Group Associations" || data0 === "Hardware Security" || data0 === "IPMI Device" || data0 === "Management Controller Host Interface" || data0 === "Management Device" || data0 === "Management Device Component" || data0 === "Management Device Threshold Data" || data0 === "Memory Array Mapped Address" || data0 === "Memory Channel" || data0 === "Memory Controller" || data0 === "Memory Device" || data0 === "Memory Device Mapped Address" || data0 === "Memory Module" || data0 === "OEM Strings" || data0 === "Onboard Devices" || data0 === "Onboard Devices Extended Information" || data0 === "Out-of-band Remote Access" || data0 === "Physical Memory Array" || data0 === "Platform Firmware" || data0 === "Port Connector" || data0 === "Portable Battery" || data0 === "Power Supply" || data0 === "Processor" || data0 === "Processor Additional Information" || data0 === "String Property" || data0 === "System" || data0 === "System Boot" || data0 === "System Configuration Options" || data0 === "System Event Log" || data0 === "System Power Controls" || data0 === "System Reset" || data0 === "System Slots" || data0 === "TPM Device" || data0 === "Temperature Probe" || data0 === "Voltage Probe")) {
+                  const err12 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/2/enum", keyword: "enum", params: { allowedValues: schema16.anyOf[2].enum }, message: "must be equal to one of the allowed values" };
+                  if (vErrors === null) {
+                    vErrors = [err12];
+                  } else {
+                    vErrors.push(err12);
+                  }
+                  errors++;
+                }
+                var _valid1 = _errs19 === errors;
+                valid3 = valid3 || _valid1;
+                if (!valid3) {
+                  const _errs21 = errors;
+                  if (!(typeof data0 == "number" && isFinite(data0))) {
+                    const err13 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/3/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                      vErrors = [err13];
+                    } else {
+                      vErrors.push(err13);
+                    }
+                    errors++;
+                  }
+                  var _valid1 = _errs21 === errors;
+                  valid3 = valid3 || _valid1;
+                }
+              }
+            }
+            if (!valid3) {
+              const err14 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+              if (vErrors === null) {
+                vErrors = [err14];
+              } else {
+                vErrors.push(err14);
+              }
+              errors++;
+            } else {
+              errors = _errs6;
+              if (vErrors !== null) {
+                if (_errs6) {
+                  vErrors.length = _errs6;
+                } else {
+                  vErrors = null;
+                }
+              }
+            }
+            var valid1 = _errs4 === errors;
+          } else {
+            var valid1 = true;
+          }
+          if (valid1) {
+            if (data.offset !== void 0) {
+              let data4 = data.offset;
+              const _errs23 = errors;
+              if (!(typeof data4 == "number" && isFinite(data4))) {
+                const err15 = { instancePath: instancePath + "/offset", schemaPath: "#/anyOf/0/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                  vErrors = [err15];
+                } else {
+                  vErrors.push(err15);
+                }
+                errors++;
+              }
+              var valid1 = _errs23 === errors;
+            } else {
+              var valid1 = true;
+            }
+            if (valid1) {
+              if (data.type !== void 0) {
+                let data5 = data.type;
+                const _errs25 = errors;
+                if (typeof data5 !== "string") {
+                  const err16 = { instancePath: instancePath + "/type", schemaPath: "#/anyOf/0/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                  if (vErrors === null) {
+                    vErrors = [err16];
+                  } else {
+                    vErrors.push(err16);
+                  }
+                  errors++;
+                }
+                if (!(data5 === "byte" || data5 === "dword" || data5 === "qword" || data5 === "string" || data5 === "uuid" || data5 === "word")) {
+                  const err17 = { instancePath: instancePath + "/type", schemaPath: "#/anyOf/0/properties/type/enum", keyword: "enum", params: { allowedValues: schema15.anyOf[0].properties.type.enum }, message: "must be equal to one of the allowed values" };
+                  if (vErrors === null) {
+                    vErrors = [err17];
+                  } else {
+                    vErrors.push(err17);
+                  }
+                  errors++;
+                }
+                var valid1 = _errs25 === errors;
+              } else {
+                var valid1 = true;
+              }
+            }
+          }
+        }
+      }
+    } else {
+      const err18 = { instancePath, schemaPath: "#/anyOf/0/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+      if (vErrors === null) {
+        vErrors = [err18];
+      } else {
+        vErrors.push(err18);
+      }
+      errors++;
+    }
+  }
+  var _valid0 = _errs1 === errors;
+  valid0 = valid0 || _valid0;
+  if (!valid0) {
+    const _errs27 = errors;
+    if (typeof data !== "string") {
+      const err19 = { instancePath, schemaPath: "#/anyOf/1/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+      if (vErrors === null) {
+        vErrors = [err19];
+      } else {
+        vErrors.push(err19);
+      }
+      errors++;
+    }
+    if (!(data === "baseboard-asset-tag" || data === "baseboard-manufacturer" || data === "baseboard-product-name" || data === "baseboard-serial-number" || data === "baseboard-version" || data === "bios-release-date" || data === "bios-revision" || data === "bios-vendor" || data === "bios-version" || data === "chassis-asset-tag" || data === "chassis-manufacturer" || data === "chassis-serial-number" || data === "chassis-version" || data === "processor-manufacturer" || data === "processor-version" || data === "system-family" || data === "system-manufacturer" || data === "system-product-name" || data === "system-serial-number" || data === "system-sku-number" || data === "system-uuid" || data === "system-version")) {
+      const err20 = { instancePath, schemaPath: "#/anyOf/1/enum", keyword: "enum", params: { allowedValues: schema15.anyOf[1].enum }, message: "must be equal to one of the allowed values" };
+      if (vErrors === null) {
+        vErrors = [err20];
+      } else {
+        vErrors.push(err20);
+      }
+      errors++;
+    }
+    var _valid0 = _errs27 === errors;
+    valid0 = valid0 || _valid0;
+  }
+  if (!valid0) {
+    const err21 = { instancePath, schemaPath: "#/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+    if (vErrors === null) {
+      vErrors = [err21];
+    } else {
+      vErrors.push(err21);
+    }
+    errors++;
+    validate13.errors = vErrors;
+    return false;
+  } else {
+    errors = _errs0;
+    if (vErrors !== null) {
+      if (_errs0) {
+        vErrors.length = _errs0;
+      } else {
+        vErrors = null;
+      }
+    }
+  }
+  validate13.errors = vErrors;
+  return errors === 0;
+}
+function validate12(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.ref === void 0 && (missing0 = "ref") || data.type === void 0 && (missing0 = "type")) {
+        validate12.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        const _errs1 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "ref" || key0 === "value")) {
+            validate12.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if ("smbios" !== data0) {
+              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "smbios" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.ref !== void 0) {
+              const _errs4 = errors;
+              if (!validate13(data.ref, { instancePath: instancePath + "/ref", parentData: data, parentDataProperty: "ref", rootData })) {
+                vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                errors = vErrors.length;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.value !== void 0) {
+                const _errs5 = errors;
+                if (typeof data.value !== "string") {
+                  validate12.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+                var valid0 = _errs5 === errors;
+              } else {
+                var valid0 = true;
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate12.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate12.errors = vErrors;
+  return errors === 0;
+}
+const schema17 = { "properties": { "offsetRef": { "enum": ["end", "start"] } } };
+const schema18 = { "type": ["string", "number"] };
+const schema21 = { "enum": ["ascii", "base64", "base64url", "binary", "hex", "latin1", "ucs-2", "ucs2", "utf-16le", "utf-8", "utf16le", "utf8"] };
+function validate17(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.buffer === void 0 && (missing0 = "buffer") || data.type === void 0 && (missing0 = "type")) {
+        validate17.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "buffer")) {
+            validate17.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate17.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if (!(data0 === "ascii" || data0 === "base64" || data0 === "base64url" || data0 === "binary" || data0 === "hex" || data0 === "latin1" || data0 === "ucs-2" || data0 === "ucs2" || data0 === "utf-16le" || data0 === "utf-8" || data0 === "utf16le" || data0 === "utf8")) {
+              validate17.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/enum", keyword: "enum", params: { allowedValues: schema21.enum }, message: "must be equal to one of the allowed values" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.buffer !== void 0) {
+              const _errs5 = errors;
+              if (typeof data.buffer !== "string") {
+                validate17.errors = [{ instancePath: instancePath + "/buffer", schemaPath: "#/properties/buffer/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs5 === errors;
+            } else {
+              var valid0 = true;
+            }
+          }
+        }
+      }
+    } else {
+      validate17.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate17.errors = vErrors;
+  return errors === 0;
+}
+function validate16(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.offset === void 0 && (missing0 = "offset") || data.offsetRef === void 0 && (missing0 = "offsetRef") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
+        validate16.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        const _errs1 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "device" || key0 === "offsetRef" || key0 === "offset" || key0 === "value")) {
+            validate16.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate16.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if ("hd-data" !== data0) {
+              validate16.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-data" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.device !== void 0) {
+              const _errs4 = errors;
+              if (typeof data.device !== "string") {
+                validate16.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.offsetRef !== void 0) {
+                let data2 = data.offsetRef;
+                const _errs6 = errors;
+                if (typeof data2 !== "string") {
+                  validate16.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+                if (!(data2 === "end" || data2 === "start")) {
+                  validate16.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema17.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
+                  return false;
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
+              if (valid0) {
+                if (data.offset !== void 0) {
+                  let data3 = data.offset;
+                  const _errs8 = errors;
+                  if (typeof data3 !== "string" && !(typeof data3 == "number" && isFinite(data3))) {
+                    validate16.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema18.type }, message: "must be string,number" }];
+                    return false;
+                  }
+                  var valid0 = _errs8 === errors;
+                } else {
+                  var valid0 = true;
+                }
+                if (valid0) {
+                  if (data.value !== void 0) {
+                    let data4 = data.value;
+                    const _errs11 = errors;
+                    const _errs12 = errors;
+                    let valid2 = false;
+                    const _errs13 = errors;
+                    const _errs14 = errors;
+                    if (errors === _errs14) {
+                      if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                        let missing1;
+                        if (data4.file === void 0 && (missing1 = "file") || data4.type === void 0 && (missing1 = "type")) {
+                          const err0 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                          if (vErrors === null) {
+                            vErrors = [err0];
+                          } else {
+                            vErrors.push(err0);
+                          }
+                          errors++;
+                        } else {
+                          const _errs16 = errors;
+                          for (const key1 in data4) {
+                            if (!(key1 === "type" || key1 === "file" || key1 === "offset" || key1 === "size")) {
+                              const err1 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                              if (vErrors === null) {
+                                vErrors = [err1];
+                              } else {
+                                vErrors.push(err1);
+                              }
+                              errors++;
+                              break;
+                            }
+                          }
+                          if (_errs16 === errors) {
+                            if (data4.type !== void 0) {
+                              let data5 = data4.type;
+                              const _errs17 = errors;
+                              if (typeof data5 !== "string") {
+                                const err2 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                if (vErrors === null) {
+                                  vErrors = [err2];
+                                } else {
+                                  vErrors.push(err2);
+                                }
+                                errors++;
+                              }
+                              if ("file" !== data5) {
+                                const err3 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/const", keyword: "const", params: { allowedValue: "file" }, message: "must be equal to constant" };
+                                if (vErrors === null) {
+                                  vErrors = [err3];
+                                } else {
+                                  vErrors.push(err3);
+                                }
+                                errors++;
+                              }
+                              var valid4 = _errs17 === errors;
+                            } else {
+                              var valid4 = true;
+                            }
+                            if (valid4) {
+                              if (data4.file !== void 0) {
+                                const _errs19 = errors;
+                                if (typeof data4.file !== "string") {
+                                  const err4 = { instancePath: instancePath + "/value/file", schemaPath: "#/definitions/BinaryDataFromFile/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                  if (vErrors === null) {
+                                    vErrors = [err4];
+                                  } else {
+                                    vErrors.push(err4);
+                                  }
+                                  errors++;
+                                }
+                                var valid4 = _errs19 === errors;
+                              } else {
+                                var valid4 = true;
+                              }
+                              if (valid4) {
+                                if (data4.offset !== void 0) {
+                                  let data7 = data4.offset;
+                                  const _errs21 = errors;
+                                  if (!(typeof data7 == "number" && isFinite(data7))) {
+                                    const err5 = { instancePath: instancePath + "/value/offset", schemaPath: "#/definitions/BinaryDataFromFile/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                    if (vErrors === null) {
+                                      vErrors = [err5];
+                                    } else {
+                                      vErrors.push(err5);
+                                    }
+                                    errors++;
+                                  }
+                                  var valid4 = _errs21 === errors;
+                                } else {
+                                  var valid4 = true;
+                                }
+                                if (valid4) {
+                                  if (data4.size !== void 0) {
+                                    let data8 = data4.size;
+                                    const _errs23 = errors;
+                                    if (!(typeof data8 == "number" && isFinite(data8))) {
+                                      const err6 = { instancePath: instancePath + "/value/size", schemaPath: "#/definitions/BinaryDataFromFile/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                      if (vErrors === null) {
+                                        vErrors = [err6];
+                                      } else {
+                                        vErrors.push(err6);
+                                      }
+                                      errors++;
+                                    }
+                                    var valid4 = _errs23 === errors;
+                                  } else {
+                                    var valid4 = true;
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      } else {
+                        const err7 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                          vErrors = [err7];
+                        } else {
+                          vErrors.push(err7);
+                        }
+                        errors++;
+                      }
+                    }
+                    var _valid0 = _errs13 === errors;
+                    valid2 = valid2 || _valid0;
+                    if (!valid2) {
+                      const _errs25 = errors;
+                      if (!validate17(data4, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                        vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
+                        errors = vErrors.length;
+                      }
+                      var _valid0 = _errs25 === errors;
+                      valid2 = valid2 || _valid0;
+                      if (!valid2) {
+                        const _errs26 = errors;
+                        const _errs27 = errors;
+                        if (errors === _errs27) {
+                          if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                            let missing2;
+                            if (data4.buffer === void 0 && (missing2 = "buffer") || data4.type === void 0 && (missing2 = "type")) {
+                              const err8 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" };
+                              if (vErrors === null) {
+                                vErrors = [err8];
+                              } else {
+                                vErrors.push(err8);
+                              }
+                              errors++;
+                            } else {
+                              const _errs29 = errors;
+                              for (const key2 in data4) {
+                                if (!(key2 === "type" || key2 === "buffer")) {
+                                  const err9 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                                  if (vErrors === null) {
+                                    vErrors = [err9];
+                                  } else {
+                                    vErrors.push(err9);
+                                  }
+                                  errors++;
+                                  break;
+                                }
+                              }
+                              if (_errs29 === errors) {
+                                if (data4.type !== void 0) {
+                                  let data9 = data4.type;
+                                  const _errs30 = errors;
+                                  if (typeof data9 !== "string") {
+                                    const err10 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                    if (vErrors === null) {
+                                      vErrors = [err10];
+                                    } else {
+                                      vErrors.push(err10);
+                                    }
+                                    errors++;
+                                  }
+                                  if ("buffer" !== data9) {
+                                    const err11 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/const", keyword: "const", params: { allowedValue: "buffer" }, message: "must be equal to constant" };
+                                    if (vErrors === null) {
+                                      vErrors = [err11];
+                                    } else {
+                                      vErrors.push(err11);
+                                    }
+                                    errors++;
+                                  }
+                                  var valid6 = _errs30 === errors;
+                                } else {
+                                  var valid6 = true;
+                                }
+                                if (valid6) {
+                                  if (data4.buffer !== void 0) {
+                                    let data10 = data4.buffer;
+                                    const _errs32 = errors;
+                                    if (!(data10 && typeof data10 == "object" && !Array.isArray(data10))) {
+                                      const err12 = { instancePath: instancePath + "/value/buffer", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/buffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                                      if (vErrors === null) {
+                                        vErrors = [err12];
+                                      } else {
+                                        vErrors.push(err12);
+                                      }
+                                      errors++;
+                                    }
+                                    var valid6 = _errs32 === errors;
+                                  } else {
+                                    var valid6 = true;
+                                  }
+                                }
+                              }
+                            }
+                          } else {
+                            const err13 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                            if (vErrors === null) {
+                              vErrors = [err13];
+                            } else {
+                              vErrors.push(err13);
+                            }
+                            errors++;
+                          }
+                        }
+                        var _valid0 = _errs26 === errors;
+                        valid2 = valid2 || _valid0;
+                        if (!valid2) {
+                          const _errs34 = errors;
+                          const _errs35 = errors;
+                          if (errors === _errs35) {
+                            if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+                              let missing3;
+                              if (data4.type === void 0 && (missing3 = "type")) {
+                                const err14 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryMissingData/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" };
+                                if (vErrors === null) {
+                                  vErrors = [err14];
+                                } else {
+                                  vErrors.push(err14);
+                                }
+                                errors++;
+                              } else {
+                                const _errs37 = errors;
+                                for (const key3 in data4) {
+                                  if (!(key3 === "type" || key3 === "size")) {
+                                    const err15 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryMissingData/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+                                    if (vErrors === null) {
+                                      vErrors = [err15];
+                                    } else {
+                                      vErrors.push(err15);
+                                    }
+                                    errors++;
+                                    break;
+                                  }
+                                }
+                                if (_errs37 === errors) {
+                                  if (data4.type !== void 0) {
+                                    let data11 = data4.type;
+                                    const _errs38 = errors;
+                                    if (typeof data11 !== "string") {
+                                      const err16 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryMissingData/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                      if (vErrors === null) {
+                                        vErrors = [err16];
+                                      } else {
+                                        vErrors.push(err16);
+                                      }
+                                      errors++;
+                                    }
+                                    if ("missing" !== data11) {
+                                      const err17 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryMissingData/properties/type/const", keyword: "const", params: { allowedValue: "missing" }, message: "must be equal to constant" };
+                                      if (vErrors === null) {
+                                        vErrors = [err17];
+                                      } else {
+                                        vErrors.push(err17);
+                                      }
+                                      errors++;
+                                    }
+                                    var valid8 = _errs38 === errors;
+                                  } else {
+                                    var valid8 = true;
+                                  }
+                                  if (valid8) {
+                                    if (data4.size !== void 0) {
+                                      let data12 = data4.size;
+                                      const _errs40 = errors;
+                                      if (!(typeof data12 == "number" && isFinite(data12))) {
+                                        const err18 = { instancePath: instancePath + "/value/size", schemaPath: "#/definitions/BinaryMissingData/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                        if (vErrors === null) {
+                                          vErrors = [err18];
+                                        } else {
+                                          vErrors.push(err18);
+                                        }
+                                        errors++;
+                                      }
+                                      var valid8 = _errs40 === errors;
+                                    } else {
+                                      var valid8 = true;
+                                    }
+                                  }
+                                }
+                              }
+                            } else {
+                              const err19 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryMissingData/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                              if (vErrors === null) {
+                                vErrors = [err19];
+                              } else {
+                                vErrors.push(err19);
+                              }
+                              errors++;
+                            }
+                          }
+                          var _valid0 = _errs34 === errors;
+                          valid2 = valid2 || _valid0;
+                        }
+                      }
+                    }
+                    if (!valid2) {
+                      const err20 = { instancePath: instancePath + "/value", schemaPath: "#/properties/value/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                      if (vErrors === null) {
+                        vErrors = [err20];
+                      } else {
+                        vErrors.push(err20);
+                      }
+                      errors++;
+                      validate16.errors = vErrors;
+                      return false;
+                    } else {
+                      errors = _errs12;
+                      if (vErrors !== null) {
+                        if (_errs12) {
+                          vErrors.length = _errs12;
+                        } else {
+                          vErrors = null;
+                        }
+                      }
+                    }
+                    var valid0 = _errs11 === errors;
+                  } else {
+                    var valid0 = true;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate16.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate16.errors = vErrors;
+  return errors === 0;
+}
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
+        validate20.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "device" || key0 === "value")) {
+            validate20.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate20.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if ("hd-size" !== data0) {
+              validate20.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-size" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.device !== void 0) {
+              const _errs4 = errors;
+              if (typeof data.device !== "string") {
+                validate20.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.value !== void 0) {
+                let data2 = data.value;
+                const _errs6 = errors;
+                if (typeof data2 !== "string" && !(typeof data2 == "number" && isFinite(data2))) {
+                  validate20.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema18.type }, message: "must be string,number" }];
+                  return false;
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate20.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate20.errors = vErrors;
+  return errors === 0;
+}
+const schema26 = { "properties": { "offsetRef": { "enum": ["end", "full", "start"] }, "offset": { "type": ["string", "number"] } } };
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.file === void 0 && (missing0 = "file") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
+        validate22.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        const _errs1 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "device" || key0 === "file" || key0 === "offsetRef" || key0 === "offset" || key0 === "value")) {
+            validate22.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if ("file-data" !== data0) {
+              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-data" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.device !== void 0) {
+              const _errs4 = errors;
+              if (typeof data.device !== "string") {
+                validate22.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.file !== void 0) {
+                const _errs6 = errors;
+                if (typeof data.file !== "string") {
+                  validate22.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
+              if (valid0) {
+                if (data.offsetRef !== void 0) {
+                  let data3 = data.offsetRef;
+                  const _errs8 = errors;
+                  if (typeof data3 !== "string") {
+                    validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                    return false;
+                  }
+                  if (!(data3 === "end" || data3 === "full" || data3 === "start")) {
+                    validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema26.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
+                    return false;
+                  }
+                  var valid0 = _errs8 === errors;
+                } else {
+                  var valid0 = true;
+                }
+                if (valid0) {
+                  if (data.offset !== void 0) {
+                    let data4 = data.offset;
+                    const _errs10 = errors;
+                    if (typeof data4 !== "string" && !(typeof data4 == "number" && isFinite(data4))) {
+                      validate22.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/properties/offset/type", keyword: "type", params: { type: schema26.properties.offset.type }, message: "must be string,number" }];
+                      return false;
+                    }
+                    var valid0 = _errs10 === errors;
+                  } else {
+                    var valid0 = true;
+                  }
+                  if (valid0) {
+                    if (data.value !== void 0) {
+                      let data5 = data.value;
+                      const _errs12 = errors;
+                      const _errs13 = errors;
+                      let valid1 = false;
+                      const _errs14 = errors;
+                      const _errs15 = errors;
+                      if (errors === _errs15) {
+                        if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                          let missing1;
+                          if (data5.file === void 0 && (missing1 = "file") || data5.type === void 0 && (missing1 = "type")) {
+                            const err0 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                            if (vErrors === null) {
+                              vErrors = [err0];
+                            } else {
+                              vErrors.push(err0);
+                            }
+                            errors++;
+                          } else {
+                            const _errs17 = errors;
+                            for (const key1 in data5) {
+                              if (!(key1 === "type" || key1 === "file" || key1 === "offset" || key1 === "size")) {
+                                const err1 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                                if (vErrors === null) {
+                                  vErrors = [err1];
+                                } else {
+                                  vErrors.push(err1);
+                                }
+                                errors++;
+                                break;
+                              }
+                            }
+                            if (_errs17 === errors) {
+                              if (data5.type !== void 0) {
+                                let data6 = data5.type;
+                                const _errs18 = errors;
+                                if (typeof data6 !== "string") {
+                                  const err2 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                  if (vErrors === null) {
+                                    vErrors = [err2];
+                                  } else {
+                                    vErrors.push(err2);
+                                  }
+                                  errors++;
+                                }
+                                if ("file" !== data6) {
+                                  const err3 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/const", keyword: "const", params: { allowedValue: "file" }, message: "must be equal to constant" };
+                                  if (vErrors === null) {
+                                    vErrors = [err3];
+                                  } else {
+                                    vErrors.push(err3);
+                                  }
+                                  errors++;
+                                }
+                                var valid3 = _errs18 === errors;
+                              } else {
+                                var valid3 = true;
+                              }
+                              if (valid3) {
+                                if (data5.file !== void 0) {
+                                  const _errs20 = errors;
+                                  if (typeof data5.file !== "string") {
+                                    const err4 = { instancePath: instancePath + "/value/file", schemaPath: "#/definitions/BinaryDataFromFile/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                    if (vErrors === null) {
+                                      vErrors = [err4];
+                                    } else {
+                                      vErrors.push(err4);
+                                    }
+                                    errors++;
+                                  }
+                                  var valid3 = _errs20 === errors;
+                                } else {
+                                  var valid3 = true;
+                                }
+                                if (valid3) {
+                                  if (data5.offset !== void 0) {
+                                    let data8 = data5.offset;
+                                    const _errs22 = errors;
+                                    if (!(typeof data8 == "number" && isFinite(data8))) {
+                                      const err5 = { instancePath: instancePath + "/value/offset", schemaPath: "#/definitions/BinaryDataFromFile/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                      if (vErrors === null) {
+                                        vErrors = [err5];
+                                      } else {
+                                        vErrors.push(err5);
+                                      }
+                                      errors++;
+                                    }
+                                    var valid3 = _errs22 === errors;
+                                  } else {
+                                    var valid3 = true;
+                                  }
+                                  if (valid3) {
+                                    if (data5.size !== void 0) {
+                                      let data9 = data5.size;
+                                      const _errs24 = errors;
+                                      if (!(typeof data9 == "number" && isFinite(data9))) {
+                                        const err6 = { instancePath: instancePath + "/value/size", schemaPath: "#/definitions/BinaryDataFromFile/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                        if (vErrors === null) {
+                                          vErrors = [err6];
+                                        } else {
+                                          vErrors.push(err6);
+                                        }
+                                        errors++;
+                                      }
+                                      var valid3 = _errs24 === errors;
+                                    } else {
+                                      var valid3 = true;
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        } else {
+                          const err7 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                          if (vErrors === null) {
+                            vErrors = [err7];
+                          } else {
+                            vErrors.push(err7);
+                          }
+                          errors++;
+                        }
+                      }
+                      var _valid0 = _errs14 === errors;
+                      valid1 = valid1 || _valid0;
+                      if (!valid1) {
+                        const _errs26 = errors;
+                        if (!validate17(data5, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                          vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
+                          errors = vErrors.length;
+                        }
+                        var _valid0 = _errs26 === errors;
+                        valid1 = valid1 || _valid0;
+                        if (!valid1) {
+                          const _errs27 = errors;
+                          const _errs28 = errors;
+                          if (errors === _errs28) {
+                            if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                              let missing2;
+                              if (data5.buffer === void 0 && (missing2 = "buffer") || data5.type === void 0 && (missing2 = "type")) {
+                                const err8 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" };
+                                if (vErrors === null) {
+                                  vErrors = [err8];
+                                } else {
+                                  vErrors.push(err8);
+                                }
+                                errors++;
+                              } else {
+                                const _errs30 = errors;
+                                for (const key2 in data5) {
+                                  if (!(key2 === "type" || key2 === "buffer")) {
+                                    const err9 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                                    if (vErrors === null) {
+                                      vErrors = [err9];
+                                    } else {
+                                      vErrors.push(err9);
+                                    }
+                                    errors++;
+                                    break;
+                                  }
+                                }
+                                if (_errs30 === errors) {
+                                  if (data5.type !== void 0) {
+                                    let data10 = data5.type;
+                                    const _errs31 = errors;
+                                    if (typeof data10 !== "string") {
+                                      const err10 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                      if (vErrors === null) {
+                                        vErrors = [err10];
+                                      } else {
+                                        vErrors.push(err10);
+                                      }
+                                      errors++;
+                                    }
+                                    if ("buffer" !== data10) {
+                                      const err11 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/const", keyword: "const", params: { allowedValue: "buffer" }, message: "must be equal to constant" };
+                                      if (vErrors === null) {
+                                        vErrors = [err11];
+                                      } else {
+                                        vErrors.push(err11);
+                                      }
+                                      errors++;
+                                    }
+                                    var valid5 = _errs31 === errors;
+                                  } else {
+                                    var valid5 = true;
+                                  }
+                                  if (valid5) {
+                                    if (data5.buffer !== void 0) {
+                                      let data11 = data5.buffer;
+                                      const _errs33 = errors;
+                                      if (!(data11 && typeof data11 == "object" && !Array.isArray(data11))) {
+                                        const err12 = { instancePath: instancePath + "/value/buffer", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/buffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                                        if (vErrors === null) {
+                                          vErrors = [err12];
+                                        } else {
+                                          vErrors.push(err12);
+                                        }
+                                        errors++;
+                                      }
+                                      var valid5 = _errs33 === errors;
+                                    } else {
+                                      var valid5 = true;
+                                    }
+                                  }
+                                }
+                              }
+                            } else {
+                              const err13 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                              if (vErrors === null) {
+                                vErrors = [err13];
+                              } else {
+                                vErrors.push(err13);
+                              }
+                              errors++;
+                            }
+                          }
+                          var _valid0 = _errs27 === errors;
+                          valid1 = valid1 || _valid0;
+                          if (!valid1) {
+                            const _errs35 = errors;
+                            const _errs36 = errors;
+                            if (errors === _errs36) {
+                              if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+                                let missing3;
+                                if (data5.type === void 0 && (missing3 = "type")) {
+                                  const err14 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryMissingData/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" };
+                                  if (vErrors === null) {
+                                    vErrors = [err14];
+                                  } else {
+                                    vErrors.push(err14);
+                                  }
+                                  errors++;
+                                } else {
+                                  const _errs38 = errors;
+                                  for (const key3 in data5) {
+                                    if (!(key3 === "type" || key3 === "size")) {
+                                      const err15 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryMissingData/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+                                      if (vErrors === null) {
+                                        vErrors = [err15];
+                                      } else {
+                                        vErrors.push(err15);
+                                      }
+                                      errors++;
+                                      break;
+                                    }
+                                  }
+                                  if (_errs38 === errors) {
+                                    if (data5.type !== void 0) {
+                                      let data12 = data5.type;
+                                      const _errs39 = errors;
+                                      if (typeof data12 !== "string") {
+                                        const err16 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryMissingData/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                        if (vErrors === null) {
+                                          vErrors = [err16];
+                                        } else {
+                                          vErrors.push(err16);
+                                        }
+                                        errors++;
+                                      }
+                                      if ("missing" !== data12) {
+                                        const err17 = { instancePath: instancePath + "/value/type", schemaPath: "#/definitions/BinaryMissingData/properties/type/const", keyword: "const", params: { allowedValue: "missing" }, message: "must be equal to constant" };
+                                        if (vErrors === null) {
+                                          vErrors = [err17];
+                                        } else {
+                                          vErrors.push(err17);
+                                        }
+                                        errors++;
+                                      }
+                                      var valid7 = _errs39 === errors;
+                                    } else {
+                                      var valid7 = true;
+                                    }
+                                    if (valid7) {
+                                      if (data5.size !== void 0) {
+                                        let data13 = data5.size;
+                                        const _errs41 = errors;
+                                        if (!(typeof data13 == "number" && isFinite(data13))) {
+                                          const err18 = { instancePath: instancePath + "/value/size", schemaPath: "#/definitions/BinaryMissingData/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                          if (vErrors === null) {
+                                            vErrors = [err18];
+                                          } else {
+                                            vErrors.push(err18);
+                                          }
+                                          errors++;
+                                        }
+                                        var valid7 = _errs41 === errors;
+                                      } else {
+                                        var valid7 = true;
+                                      }
+                                    }
+                                  }
+                                }
+                              } else {
+                                const err19 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryMissingData/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                                if (vErrors === null) {
+                                  vErrors = [err19];
+                                } else {
+                                  vErrors.push(err19);
+                                }
+                                errors++;
+                              }
+                            }
+                            var _valid0 = _errs35 === errors;
+                            valid1 = valid1 || _valid0;
+                          }
+                        }
+                      }
+                      if (!valid1) {
+                        const err20 = { instancePath: instancePath + "/value", schemaPath: "#/properties/value/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                        if (vErrors === null) {
+                          vErrors = [err20];
+                        } else {
+                          vErrors.push(err20);
+                        }
+                        errors++;
+                        validate22.errors = vErrors;
+                        return false;
+                      } else {
+                        errors = _errs13;
+                        if (vErrors !== null) {
+                          if (_errs13) {
+                            vErrors.length = _errs13;
+                          } else {
+                            vErrors = null;
+                          }
+                        }
+                      }
+                      var valid0 = _errs12 === errors;
+                    } else {
+                      var valid0 = true;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate22.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate22.errors = vErrors;
+  return errors === 0;
+}
+function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.file === void 0 && (missing0 = "file") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
+        validate25.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "device" || key0 === "file" || key0 === "value")) {
+            validate25.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if ("file-size" !== data0) {
+              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-size" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.device !== void 0) {
+              const _errs4 = errors;
+              if (typeof data.device !== "string") {
+                validate25.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.file !== void 0) {
+                const _errs6 = errors;
+                if (typeof data.file !== "string") {
+                  validate25.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
+              if (valid0) {
+                if (data.value !== void 0) {
+                  let data3 = data.value;
+                  const _errs8 = errors;
+                  if (typeof data3 !== "string" && !(typeof data3 == "number" && isFinite(data3))) {
+                    validate25.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema18.type }, message: "must be string,number" }];
+                    return false;
+                  }
+                  var valid0 = _errs8 === errors;
+                } else {
+                  var valid0 = true;
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate25.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate25.errors = vErrors;
+  return errors === 0;
+}
+function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const _errs0 = errors;
+  let valid0 = false;
+  const _errs1 = errors;
+  const _errs2 = errors;
+  if (errors === _errs2) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.length === void 0 && (missing0 = "length") || data.type === void 0 && (missing0 = "type")) {
+        const err0 = { instancePath, schemaPath: "#/definitions/HashComponentRandom/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" };
+        if (vErrors === null) {
+          vErrors = [err0];
+        } else {
+          vErrors.push(err0);
+        }
+        errors++;
+      } else {
+        const _errs4 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "length")) {
+            const err1 = { instancePath, schemaPath: "#/definitions/HashComponentRandom/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+              vErrors = [err1];
+            } else {
+              vErrors.push(err1);
+            }
+            errors++;
+            break;
+          }
+        }
+        if (_errs4 === errors) {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs5 = errors;
+            if (typeof data0 !== "string") {
+              const err2 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentRandom/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err2];
+              } else {
+                vErrors.push(err2);
+              }
+              errors++;
+            }
+            if ("random" !== data0) {
+              const err3 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentRandom/properties/type/const", keyword: "const", params: { allowedValue: "random" }, message: "must be equal to constant" };
+              if (vErrors === null) {
+                vErrors = [err3];
+              } else {
+                vErrors.push(err3);
+              }
+              errors++;
+            }
+            var valid2 = _errs5 === errors;
+          } else {
+            var valid2 = true;
+          }
+          if (valid2) {
+            if (data.length !== void 0) {
+              let data1 = data.length;
+              const _errs7 = errors;
+              if (!(typeof data1 == "number" && isFinite(data1))) {
+                const err4 = { instancePath: instancePath + "/length", schemaPath: "#/definitions/HashComponentRandom/properties/length/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                  vErrors = [err4];
+                } else {
+                  vErrors.push(err4);
+                }
+                errors++;
+              }
+              var valid2 = _errs7 === errors;
+            } else {
+              var valid2 = true;
+            }
+          }
+        }
+      }
+    } else {
+      const err5 = { instancePath, schemaPath: "#/definitions/HashComponentRandom/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+      if (vErrors === null) {
+        vErrors = [err5];
+      } else {
+        vErrors.push(err5);
+      }
+      errors++;
+    }
+  }
+  var _valid0 = _errs1 === errors;
+  valid0 = valid0 || _valid0;
+  if (!valid0) {
+    const _errs9 = errors;
+    if (!validate12(data, { instancePath, parentData, parentDataProperty, rootData })) {
+      vErrors = vErrors === null ? validate12.errors : vErrors.concat(validate12.errors);
+      errors = vErrors.length;
+    }
+    var _valid0 = _errs9 === errors;
+    valid0 = valid0 || _valid0;
+    if (!valid0) {
+      const _errs10 = errors;
+      if (!validate16(data, { instancePath, parentData, parentDataProperty, rootData })) {
+        vErrors = vErrors === null ? validate16.errors : vErrors.concat(validate16.errors);
+        errors = vErrors.length;
+      }
+      var _valid0 = _errs10 === errors;
+      valid0 = valid0 || _valid0;
+      if (!valid0) {
+        const _errs11 = errors;
+        if (!validate20(data, { instancePath, parentData, parentDataProperty, rootData })) {
+          vErrors = vErrors === null ? validate20.errors : vErrors.concat(validate20.errors);
+          errors = vErrors.length;
+        }
+        var _valid0 = _errs11 === errors;
+        valid0 = valid0 || _valid0;
+        if (!valid0) {
+          const _errs12 = errors;
+          if (!validate22(data, { instancePath, parentData, parentDataProperty, rootData })) {
+            vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
+            errors = vErrors.length;
+          }
+          var _valid0 = _errs12 === errors;
+          valid0 = valid0 || _valid0;
+          if (!valid0) {
+            const _errs13 = errors;
+            if (!validate25(data, { instancePath, parentData, parentDataProperty, rootData })) {
+              vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
+              errors = vErrors.length;
+            }
+            var _valid0 = _errs13 === errors;
+            valid0 = valid0 || _valid0;
+            if (!valid0) {
+              const _errs14 = errors;
+              const _errs15 = errors;
+              if (errors === _errs15) {
+                if (data && typeof data == "object" && !Array.isArray(data)) {
+                  let missing1;
+                  if (data.type === void 0 && (missing1 = "type") || data.value === void 0 && (missing1 = "value")) {
+                    const err6 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                    if (vErrors === null) {
+                      vErrors = [err6];
+                    } else {
+                      vErrors.push(err6);
+                    }
+                    errors++;
+                  } else {
+                    const _errs17 = errors;
+                    for (const key1 in data) {
+                      if (!(key1 === "type" || key1 === "value")) {
+                        const err7 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                        if (vErrors === null) {
+                          vErrors = [err7];
+                        } else {
+                          vErrors.push(err7);
+                        }
+                        errors++;
+                        break;
+                      }
+                    }
+                    if (_errs17 === errors) {
+                      if (data.type !== void 0) {
+                        let data2 = data.type;
+                        const _errs18 = errors;
+                        if (typeof data2 !== "string") {
+                          const err8 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                          if (vErrors === null) {
+                            vErrors = [err8];
+                          } else {
+                            vErrors.push(err8);
+                          }
+                          errors++;
+                        }
+                        if (!(data2 === "boot-file" || data2 === "boot-hd-device" || data2 === "boot-partition-device")) {
+                          const err9 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/enum", keyword: "enum", params: { allowedValues: schema32.properties.type.enum }, message: "must be equal to one of the allowed values" };
+                          if (vErrors === null) {
+                            vErrors = [err9];
+                          } else {
+                            vErrors.push(err9);
+                          }
+                          errors++;
+                        }
+                        var valid4 = _errs18 === errors;
+                      } else {
+                        var valid4 = true;
+                      }
+                      if (valid4) {
+                        if (data.value !== void 0) {
+                          const _errs20 = errors;
+                          if (typeof data.value !== "string") {
+                            const err10 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/HashComponentMiscStringData/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                            if (vErrors === null) {
+                              vErrors = [err10];
+                            } else {
+                              vErrors.push(err10);
+                            }
+                            errors++;
+                          }
+                          var valid4 = _errs20 === errors;
+                        } else {
+                          var valid4 = true;
+                        }
+                      }
+                    }
+                  }
+                } else {
+                  const err11 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                  if (vErrors === null) {
+                    vErrors = [err11];
+                  } else {
+                    vErrors.push(err11);
+                  }
+                  errors++;
+                }
+              }
+              var _valid0 = _errs14 === errors;
+              valid0 = valid0 || _valid0;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!valid0) {
+    const err12 = { instancePath, schemaPath: "#/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+    if (vErrors === null) {
+      vErrors = [err12];
+    } else {
+      vErrors.push(err12);
+    }
+    errors++;
+    validate11.errors = vErrors;
+    return false;
+  } else {
+    errors = _errs0;
+    if (vErrors !== null) {
+      if (_errs0) {
+        vErrors.length = _errs0;
+      } else {
+        vErrors = null;
+      }
+    }
+  }
+  validate11.errors = vErrors;
+  return errors === 0;
+}
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.inputFile === void 0 && (missing0 = "inputFile")) {
+        validate10.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        const _errs1 = errors;
+        for (const key0 in data) {
+          if (!func2.call(schema11.properties, key0)) {
+            validate10.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.$schema !== void 0) {
+            const _errs2 = errors;
+            if (typeof data.$schema !== "string") {
+              validate10.errors = [{ instancePath: instancePath + "/$schema", schemaPath: "#/properties/%24schema/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.inputFile !== void 0) {
+              const _errs4 = errors;
+              if (typeof data.inputFile !== "string") {
+                validate10.errors = [{ instancePath: instancePath + "/inputFile", schemaPath: "#/properties/inputFile/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.outputFile !== void 0) {
+                const _errs6 = errors;
+                if (typeof data.outputFile !== "string") {
+                  validate10.errors = [{ instancePath: instancePath + "/outputFile", schemaPath: "#/properties/outputFile/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
+              if (valid0) {
+                if (data.skipGenCode !== void 0) {
+                  const _errs8 = errors;
+                  if (typeof data.skipGenCode !== "boolean") {
+                    validate10.errors = [{ instancePath: instancePath + "/skipGenCode", schemaPath: "#/properties/skipGenCode/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                    return false;
+                  }
+                  var valid0 = _errs8 === errors;
+                } else {
+                  var valid0 = true;
+                }
+                if (valid0) {
+                  if (data.skipExtract !== void 0) {
+                    const _errs10 = errors;
+                    if (typeof data.skipExtract !== "boolean") {
+                      validate10.errors = [{ instancePath: instancePath + "/skipExtract", schemaPath: "#/properties/skipExtract/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                      return false;
+                    }
+                    var valid0 = _errs10 === errors;
+                  } else {
+                    var valid0 = true;
+                  }
+                  if (valid0) {
+                    if (data.skipMake !== void 0) {
+                      const _errs12 = errors;
+                      if (typeof data.skipMake !== "boolean") {
+                        validate10.errors = [{ instancePath: instancePath + "/skipMake", schemaPath: "#/properties/skipMake/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                        return false;
+                      }
+                      var valid0 = _errs12 === errors;
+                    } else {
+                      var valid0 = true;
+                    }
+                    if (valid0) {
+                      if (data.buildFolder !== void 0) {
+                        const _errs14 = errors;
+                        if (typeof data.buildFolder !== "string") {
+                          validate10.errors = [{ instancePath: instancePath + "/buildFolder", schemaPath: "#/properties/buildFolder/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                          return false;
+                        }
+                        var valid0 = _errs14 === errors;
+                      } else {
+                        var valid0 = true;
+                      }
+                      if (valid0) {
+                        if (data.hashComponents !== void 0) {
+                          let data7 = data.hashComponents;
+                          const _errs16 = errors;
+                          if (errors === _errs16) {
+                            if (Array.isArray(data7)) {
+                              var valid1 = true;
+                              const len0 = data7.length;
+                              for (let i0 = 0; i0 < len0; i0++) {
+                                const _errs18 = errors;
+                                if (!validate11(data7[i0], { instancePath: instancePath + "/hashComponents/" + i0, parentData: data7, parentDataProperty: i0, rootData })) {
+                                  vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);
+                                  errors = vErrors.length;
+                                }
+                                var valid1 = _errs18 === errors;
+                                if (!valid1) {
+                                  break;
+                                }
+                              }
+                            } else {
+                              validate10.errors = [{ instancePath: instancePath + "/hashComponents", schemaPath: "#/properties/hashComponents/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
+                              return false;
+                            }
+                          }
+                          var valid0 = _errs16 === errors;
+                        } else {
+                          var valid0 = true;
+                        }
+                        if (valid0) {
+                          if (data.smbios !== void 0) {
+                            const _errs19 = errors;
+                            if (typeof data.smbios !== "string") {
+                              validate10.errors = [{ instancePath: instancePath + "/smbios", schemaPath: "#/properties/smbios/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                              return false;
+                            }
+                            var valid0 = _errs19 === errors;
+                          } else {
+                            var valid0 = true;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate10.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate10.errors = vErrors;
+  return errors === 0;
+}
+const spawnProcess = (command, args, options) => new Promise((resolve, reject) => {
+  const child = spawn(command, args, options);
+  child.on("close", (code, signal) => {
+    if (!code && !signal) {
+      resolve();
+    } else {
+      throw new Error("Command failed");
+    }
+  });
+});
+const build = async (config) => {
+  if (!validate(config)) {
+    console.error(validate.errors);
+    throw new Error("Invalid configuration");
+  }
+  if (!config.hashComponents) {
+    config = {
+      ...config,
+      hashComponents: [
+        { type: "random", length: 32 },
+        ...config.smbios ? [
+          { type: "smbios", ref: "system-serial-number" },
+          { type: "smbios", ref: "system-uuid" }
+        ] : []
+      ]
+    };
+  }
+  let useTempFolder = false;
+  if (!config.buildFolder) {
+    useTempFolder = true;
+    config.buildFolder = await mkdtemp(join(tmpdir(), "efiencrypt-"));
+  }
+  try {
+    await mkdir(join(config.buildFolder), { recursive: true });
+    if (!config.skipGenCode) {
+      await genCode(config);
+    }
+    if (!config.skipExtract) {
+      const extract = (await import("./extract-BW1V8DVW.js")).extract;
+      await extract(config.buildFolder);
+    }
+    if (!config.skipMake) {
+      await spawnProcess("make", [], {
+        stdio: "inherit",
+        cwd: config.buildFolder
+      });
+      if (config.outputFile) {
+        await mkdir(dirname(config.outputFile), { recursive: true });
+        await cp(join(config.buildFolder, "bootx64.efi"), config.outputFile);
+      }
+    }
+  } finally {
+    if (useTempFolder) {
+      await rm(config.buildFolder, { recursive: true, force: true });
+    }
+  }
+};
+export {
+  build as b
+};