@peculiar/certificates-viewer 4.0.1 → 4.1.0

package/hydrate/index.js

@@ -5767,379 +5767,379 @@ const cmpModules = new Map, getModule = e => {
  e["s-p"] = [], e["s-rc"] = [], hostRefs.set(e, o);
 }, styles = new Map;
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+/*!
+ * MIT License
+ * 
+ * Copyright (c) 2017-2022 Peculiar Ventures, LLC
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
 
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
+const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
+class BufferSourceConverter {
+    static isArrayBuffer(data) {
+        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
+    }
+    static toArrayBuffer(data) {
+        if (this.isArrayBuffer(data)) {
+            return data;
+        }
+        if (data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        return this.toUint8Array(data.buffer)
+            .slice(data.byteOffset, data.byteOffset + data.byteLength)
+            .buffer;
+    }
+    static toUint8Array(data) {
+        return this.toView(data, Uint8Array);
+    }
+    static toView(data, type) {
+        if (data.constructor === type) {
+            return data;
+        }
+        if (this.isArrayBuffer(data)) {
+            return new type(data);
+        }
+        if (this.isArrayBufferView(data)) {
+            return new type(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+    }
+    static isBufferSource(data) {
+        return this.isArrayBufferView(data)
+            || this.isArrayBuffer(data);
+    }
+    static isArrayBufferView(data) {
+        return ArrayBuffer.isView(data)
+            || (data && this.isArrayBuffer(data.buffer));
+    }
+    static isEqual(a, b) {
+        const aView = BufferSourceConverter.toUint8Array(a);
+        const bView = BufferSourceConverter.toUint8Array(b);
+        if (aView.length !== bView.byteLength) {
+            return false;
+        }
+        for (let i = 0; i < aView.length; i++) {
+            if (aView[i] !== bView[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static concat(...args) {
+        let buffers;
+        if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
+            buffers = args[0];
+        }
+        else if (Array.isArray(args[0]) && args[1] instanceof Function) {
+            buffers = args[0];
+        }
+        else {
+            if (args[args.length - 1] instanceof Function) {
+                buffers = args.slice(0, args.length - 1);
+            }
+            else {
+                buffers = args;
+            }
+        }
+        let size = 0;
+        for (const buffer of buffers) {
+            size += buffer.byteLength;
+        }
+        const res = new Uint8Array(size);
+        let offset = 0;
+        for (const buffer of buffers) {
+            const view = this.toUint8Array(buffer);
+            res.set(view, offset);
+            offset += view.length;
+        }
+        if (args[args.length - 1] instanceof Function) {
+            return this.toView(res, args[args.length - 1]);
+        }
+        return res.buffer;
+    }
 }
 
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+const STRING_TYPE = "string";
+const HEX_REGEX = /^[0-9a-f]+$/i;
+const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
+class Utf8Converter {
+    static fromString(text) {
+        const s = unescape(encodeURIComponent(text));
+        const uintArray = new Uint8Array(s.length);
+        for (let i = 0; i < s.length; i++) {
+            uintArray[i] = s.charCodeAt(i);
+        }
+        return uintArray.buffer;
+    }
+    static toString(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let encodedString = "";
+        for (let i = 0; i < buf.length; i++) {
+            encodedString += String.fromCharCode(buf[i]);
+        }
+        const decodedString = decodeURIComponent(escape(encodedString));
+        return decodedString;
+    }
 }
-
-var build = createCommonjsModule(function (module, exports) {
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
-class BufferSourceConverter {
-    static isArrayBuffer(data) {
-        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
-    }
-    static toArrayBuffer(data) {
-        if (this.isArrayBuffer(data)) {
-            return data;
-        }
-        if (data.byteLength === data.buffer.byteLength) {
-            return data.buffer;
-        }
-        return this.toUint8Array(data).slice().buffer;
-    }
-    static toUint8Array(data) {
-        return this.toView(data, Uint8Array);
-    }
-    static toView(data, type) {
-        if (data.constructor === type) {
-            return data;
-        }
-        if (this.isArrayBuffer(data)) {
-            return new type(data);
-        }
-        if (this.isArrayBufferView(data)) {
-            return new type(data.buffer, data.byteOffset, data.byteLength);
-        }
-        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
-    }
-    static isBufferSource(data) {
-        return this.isArrayBufferView(data)
-            || this.isArrayBuffer(data);
-    }
-    static isArrayBufferView(data) {
-        return ArrayBuffer.isView(data)
-            || (data && this.isArrayBuffer(data.buffer));
-    }
-    static isEqual(a, b) {
-        const aView = BufferSourceConverter.toUint8Array(a);
-        const bView = BufferSourceConverter.toUint8Array(b);
-        if (aView.length !== bView.byteLength) {
-            return false;
-        }
-        for (let i = 0; i < aView.length; i++) {
-            if (aView[i] !== bView[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static concat(...args) {
-        if (Array.isArray(args[0])) {
-            const buffers = args[0];
-            let size = 0;
-            for (const buffer of buffers) {
-                size += buffer.byteLength;
-            }
-            const res = new Uint8Array(size);
-            let offset = 0;
-            for (const buffer of buffers) {
-                const view = this.toUint8Array(buffer);
-                res.set(view, offset);
-                offset += view.length;
-            }
-            if (args[1]) {
-                return this.toView(res, args[1]);
-            }
-            return res.buffer;
-        }
-        else {
-            return this.concat(args);
-        }
-    }
+class Utf16Converter {
+    static toString(buffer, littleEndian = false) {
+        const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
+        const dataView = new DataView(arrayBuffer);
+        let res = "";
+        for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
+            const code = dataView.getUint16(i, littleEndian);
+            res += String.fromCharCode(code);
+        }
+        return res;
+    }
+    static fromString(text, littleEndian = false) {
+        const res = new ArrayBuffer(text.length * 2);
+        const dataView = new DataView(res);
+        for (let i = 0; i < text.length; i++) {
+            dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
+        }
+        return res;
+    }
+}
+class Convert {
+    static isHex(data) {
+        return typeof data === STRING_TYPE
+            && HEX_REGEX.test(data);
+    }
+    static isBase64(data) {
+        return typeof data === STRING_TYPE
+            && BASE64_REGEX.test(data);
+    }
+    static isBase64Url(data) {
+        return typeof data === STRING_TYPE
+            && BASE64URL_REGEX.test(data);
+    }
+    static ToString(buffer, enc = "utf8") {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        switch (enc.toLowerCase()) {
+            case "utf8":
+                return this.ToUtf8String(buf);
+            case "binary":
+                return this.ToBinary(buf);
+            case "hex":
+                return this.ToHex(buf);
+            case "base64":
+                return this.ToBase64(buf);
+            case "base64url":
+                return this.ToBase64Url(buf);
+            case "utf16le":
+                return Utf16Converter.toString(buf, true);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.toString(buf);
+            default:
+                throw new Error(`Unknown type of encoding '${enc}'`);
+        }
+    }
+    static FromString(str, enc = "utf8") {
+        if (!str) {
+            return new ArrayBuffer(0);
+        }
+        switch (enc.toLowerCase()) {
+            case "utf8":
+                return this.FromUtf8String(str);
+            case "binary":
+                return this.FromBinary(str);
+            case "hex":
+                return this.FromHex(str);
+            case "base64":
+                return this.FromBase64(str);
+            case "base64url":
+                return this.FromBase64Url(str);
+            case "utf16le":
+                return Utf16Converter.fromString(str, true);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.fromString(str);
+            default:
+                throw new Error(`Unknown type of encoding '${enc}'`);
+        }
+    }
+    static ToBase64(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        if (typeof btoa !== "undefined") {
+            const binary = this.ToString(buf, "binary");
+            return btoa(binary);
+        }
+        else {
+            return Buffer.from(buf).toString("base64");
+        }
+    }
+    static FromBase64(base64) {
+        const formatted = this.formatString(base64);
+        if (!formatted) {
+            return new ArrayBuffer(0);
+        }
+        if (!Convert.isBase64(formatted)) {
+            throw new TypeError("Argument 'base64Text' is not Base64 encoded");
+        }
+        if (typeof atob !== "undefined") {
+            return this.FromBinary(atob(formatted));
+        }
+        else {
+            return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
+        }
+    }
+    static FromBase64Url(base64url) {
+        const formatted = this.formatString(base64url);
+        if (!formatted) {
+            return new ArrayBuffer(0);
+        }
+        if (!Convert.isBase64Url(formatted)) {
+            throw new TypeError("Argument 'base64url' is not Base64Url encoded");
+        }
+        return this.FromBase64(this.Base64Padding(formatted.replace(/\-/g, "+").replace(/\_/g, "/")));
+    }
+    static ToBase64Url(data) {
+        return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+    }
+    static FromUtf8String(text, encoding = Convert.DEFAULT_UTF8_ENCODING) {
+        switch (encoding) {
+            case "ascii":
+                return this.FromBinary(text);
+            case "utf8":
+                return Utf8Converter.fromString(text);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.fromString(text);
+            case "utf16le":
+            case "usc2":
+                return Utf16Converter.fromString(text, true);
+            default:
+                throw new Error(`Unknown type of encoding '${encoding}'`);
+        }
+    }
+    static ToUtf8String(buffer, encoding = Convert.DEFAULT_UTF8_ENCODING) {
+        switch (encoding) {
+            case "ascii":
+                return this.ToBinary(buffer);
+            case "utf8":
+                return Utf8Converter.toString(buffer);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.toString(buffer);
+            case "utf16le":
+            case "usc2":
+                return Utf16Converter.toString(buffer, true);
+            default:
+                throw new Error(`Unknown type of encoding '${encoding}'`);
+        }
+    }
+    static FromBinary(text) {
+        const stringLength = text.length;
+        const resultView = new Uint8Array(stringLength);
+        for (let i = 0; i < stringLength; i++) {
+            resultView[i] = text.charCodeAt(i);
+        }
+        return resultView.buffer;
+    }
+    static ToBinary(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let res = "";
+        for (let i = 0; i < buf.length; i++) {
+            res += String.fromCharCode(buf[i]);
+        }
+        return res;
+    }
+    static ToHex(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let result = "";
+        const len = buf.length;
+        for (let i = 0; i < len; i++) {
+            const byte = buf[i];
+            if (byte < 16) {
+                result += "0";
+            }
+            result += byte.toString(16);
+        }
+        return result;
+    }
+    static FromHex(hexString) {
+        let formatted = this.formatString(hexString);
+        if (!formatted) {
+            return new ArrayBuffer(0);
+        }
+        if (!Convert.isHex(formatted)) {
+            throw new TypeError("Argument 'hexString' is not HEX encoded");
+        }
+        if (formatted.length % 2) {
+            formatted = `0${formatted}`;
+        }
+        const res = new Uint8Array(formatted.length / 2);
+        for (let i = 0; i < formatted.length; i = i + 2) {
+            const c = formatted.slice(i, i + 2);
+            res[i / 2] = parseInt(c, 16);
+        }
+        return res.buffer;
+    }
+    static ToUtf16String(buffer, littleEndian = false) {
+        return Utf16Converter.toString(buffer, littleEndian);
+    }
+    static FromUtf16String(text, littleEndian = false) {
+        return Utf16Converter.fromString(text, littleEndian);
+    }
+    static Base64Padding(base64) {
+        const padCount = 4 - (base64.length % 4);
+        if (padCount < 4) {
+            for (let i = 0; i < padCount; i++) {
+                base64 += "=";
+            }
+        }
+        return base64;
+    }
+    static formatString(data) {
+        return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
+    }
 }
-
-class Utf8Converter {
-    static fromString(text) {
-        const s = unescape(encodeURIComponent(text));
-        const uintArray = new Uint8Array(s.length);
-        for (let i = 0; i < s.length; i++) {
-            uintArray[i] = s.charCodeAt(i);
-        }
-        return uintArray.buffer;
-    }
-    static toString(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        let encodedString = "";
-        for (let i = 0; i < buf.length; i++) {
-            encodedString += String.fromCharCode(buf[i]);
-        }
-        const decodedString = decodeURIComponent(escape(encodedString));
-        return decodedString;
-    }
-}
-class Utf16Converter {
-    static toString(buffer, littleEndian = false) {
-        const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
-        const dataView = new DataView(arrayBuffer);
-        let res = "";
-        for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
-            const code = dataView.getUint16(i, littleEndian);
-            res += String.fromCharCode(code);
-        }
-        return res;
-    }
-    static fromString(text, littleEndian = false) {
-        const res = new ArrayBuffer(text.length * 2);
-        const dataView = new DataView(res);
-        for (let i = 0; i < text.length; i++) {
-            dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
-        }
-        return res;
-    }
-}
-class Convert {
-    static isHex(data) {
-        return typeof data === "string"
-            && /^[a-z0-9]+$/i.test(data);
-    }
-    static isBase64(data) {
-        return typeof data === "string"
-            && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data);
-    }
-    static isBase64Url(data) {
-        return typeof data === "string"
-            && /^[a-zA-Z0-9-_]+$/i.test(data);
-    }
-    static ToString(buffer, enc = "utf8") {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        switch (enc.toLowerCase()) {
-            case "utf8":
-                return this.ToUtf8String(buf);
-            case "binary":
-                return this.ToBinary(buf);
-            case "hex":
-                return this.ToHex(buf);
-            case "base64":
-                return this.ToBase64(buf);
-            case "base64url":
-                return this.ToBase64Url(buf);
-            case "utf16le":
-                return Utf16Converter.toString(buf, true);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.toString(buf);
-            default:
-                throw new Error(`Unknown type of encoding '${enc}'`);
-        }
-    }
-    static FromString(str, enc = "utf8") {
-        if (!str) {
-            return new ArrayBuffer(0);
-        }
-        switch (enc.toLowerCase()) {
-            case "utf8":
-                return this.FromUtf8String(str);
-            case "binary":
-                return this.FromBinary(str);
-            case "hex":
-                return this.FromHex(str);
-            case "base64":
-                return this.FromBase64(str);
-            case "base64url":
-                return this.FromBase64Url(str);
-            case "utf16le":
-                return Utf16Converter.fromString(str, true);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.fromString(str);
-            default:
-                throw new Error(`Unknown type of encoding '${enc}'`);
-        }
-    }
-    static ToBase64(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        if (typeof btoa !== "undefined") {
-            const binary = this.ToString(buf, "binary");
-            return btoa(binary);
-        }
-        else {
-            return Buffer.from(buf).toString("base64");
-        }
-    }
-    static FromBase64(base64) {
-        const formatted = this.formatString(base64);
-        if (!formatted) {
-            return new ArrayBuffer(0);
-        }
-        if (!Convert.isBase64(formatted)) {
-            throw new TypeError("Argument 'base64Text' is not Base64 encoded");
-        }
-        if (typeof atob !== "undefined") {
-            return this.FromBinary(atob(formatted));
-        }
-        else {
-            return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
-        }
-    }
-    static FromBase64Url(base64url) {
-        const formatted = this.formatString(base64url);
-        if (!formatted) {
-            return new ArrayBuffer(0);
-        }
-        if (!Convert.isBase64Url(formatted)) {
-            throw new TypeError("Argument 'base64url' is not Base64Url encoded");
-        }
-        return this.FromBase64(this.Base64Padding(formatted.replace(/\-/g, "+").replace(/\_/g, "/")));
-    }
-    static ToBase64Url(data) {
-        return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
-    }
-    static FromUtf8String(text, encoding = Convert.DEFAULT_UTF8_ENCODING) {
-        switch (encoding) {
-            case "ascii":
-                return this.FromBinary(text);
-            case "utf8":
-                return Utf8Converter.fromString(text);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.fromString(text);
-            case "utf16le":
-            case "usc2":
-                return Utf16Converter.fromString(text, true);
-            default:
-                throw new Error(`Unknown type of encoding '${encoding}'`);
-        }
-    }
-    static ToUtf8String(buffer, encoding = Convert.DEFAULT_UTF8_ENCODING) {
-        switch (encoding) {
-            case "ascii":
-                return this.ToBinary(buffer);
-            case "utf8":
-                return Utf8Converter.toString(buffer);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.toString(buffer);
-            case "utf16le":
-            case "usc2":
-                return Utf16Converter.toString(buffer, true);
-            default:
-                throw new Error(`Unknown type of encoding '${encoding}'`);
-        }
-    }
-    static FromBinary(text) {
-        const stringLength = text.length;
-        const resultView = new Uint8Array(stringLength);
-        for (let i = 0; i < stringLength; i++) {
-            resultView[i] = text.charCodeAt(i);
-        }
-        return resultView.buffer;
-    }
-    static ToBinary(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        let res = "";
-        for (let i = 0; i < buf.length; i++) {
-            res += String.fromCharCode(buf[i]);
-        }
-        return res;
-    }
-    static ToHex(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        const splitter = "";
-        const res = [];
-        const len = buf.length;
-        for (let i = 0; i < len; i++) {
-            const char = buf[i].toString(16).padStart(2, "0");
-            res.push(char);
-        }
-        return res.join(splitter);
-    }
-    static FromHex(hexString) {
-        let formatted = this.formatString(hexString);
-        if (!formatted) {
-            return new ArrayBuffer(0);
-        }
-        if (!Convert.isHex(formatted)) {
-            throw new TypeError("Argument 'hexString' is not HEX encoded");
-        }
-        if (formatted.length % 2) {
-            formatted = `0${formatted}`;
-        }
-        const res = new Uint8Array(formatted.length / 2);
-        for (let i = 0; i < formatted.length; i = i + 2) {
-            const c = formatted.slice(i, i + 2);
-            res[i / 2] = parseInt(c, 16);
-        }
-        return res.buffer;
-    }
-    static ToUtf16String(buffer, littleEndian = false) {
-        return Utf16Converter.toString(buffer, littleEndian);
-    }
-    static FromUtf16String(text, littleEndian = false) {
-        return Utf16Converter.fromString(text, littleEndian);
-    }
-    static Base64Padding(base64) {
-        const padCount = 4 - (base64.length % 4);
-        if (padCount < 4) {
-            for (let i = 0; i < padCount; i++) {
-                base64 += "=";
-            }
-        }
-        return base64;
-    }
-    static formatString(data) {
-        return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
-    }
-}
 Convert.DEFAULT_UTF8_ENCODING = "utf8";
-
-function assign(target, ...sources) {
-    const res = arguments[0];
-    for (let i = 1; i < arguments.length; i++) {
-        const obj = arguments[i];
-        for (const prop in obj) {
-            res[prop] = obj[prop];
-        }
-    }
-    return res;
-}
-function combine(...buf) {
-    const totalByteLength = buf.map((item) => item.byteLength).reduce((prev, cur) => prev + cur);
-    const res = new Uint8Array(totalByteLength);
-    let currentPos = 0;
-    buf.map((item) => new Uint8Array(item)).forEach((arr) => {
-        for (const item2 of arr) {
-            res[currentPos++] = item2;
-        }
-    });
-    return res.buffer;
-}
-function isEqual(bytes1, bytes2) {
-    if (!(bytes1 && bytes2)) {
-        return false;
-    }
-    if (bytes1.byteLength !== bytes2.byteLength) {
-        return false;
-    }
-    const b1 = new Uint8Array(bytes1);
-    const b2 = new Uint8Array(bytes2);
-    for (let i = 0; i < bytes1.byteLength; i++) {
-        if (b1[i] !== b2[i]) {
-            return false;
-        }
-    }
-    return true;
+function isEqual(bytes1, bytes2) {
+    if (!(bytes1 && bytes2)) {
+        return false;
+    }
+    if (bytes1.byteLength !== bytes2.byteLength) {
+        return false;
+    }
+    const b1 = new Uint8Array(bytes1);
+    const b2 = new Uint8Array(bytes2);
+    for (let i = 0; i < bytes1.byteLength; i++) {
+        if (b1[i] !== b2[i]) {
+            return false;
+        }
+    }
+    return true;
 }
 
-exports.BufferSourceConverter = BufferSourceConverter;
-exports.Convert = Convert;
-exports.assign = assign;
-exports.combine = combine;
-exports.isEqual = isEqual;
-});
+var BufferSourceConverter_1 = BufferSourceConverter;
+var Convert_1 = Convert;
+var isEqual_1 = isEqual;
 
 /*!
  Copyright (c) Peculiar Ventures, LLC
@@ -6398,7 +6398,7 @@ function HexBlock(BaseClass) {
                 super(...args);
                 const params = args[0] || {};
                 this.isHexOnly = (_a = params.isHexOnly) !== null && _a !== void 0 ? _a : false;
-                this.valueHexView = params.valueHex ? build.BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
+                this.valueHexView = params.valueHex ? BufferSourceConverter_1.toUint8Array(params.valueHex) : EMPTY_VIEW;
             }
             get valueHex() {
                 return this.valueHexView.slice().buffer;
@@ -6436,7 +6436,7 @@ function HexBlock(BaseClass) {
                 return {
                     ...super.toJSON(),
                     isHexOnly: this.isHexOnly,
-                    valueHex: build.Convert.ToHex(this.valueHexView),
+                    valueHex: Convert_1.ToHex(this.valueHexView),
                 };
             }
         },
@@ -6449,7 +6449,7 @@ class LocalBaseBlock {
         this.blockLength = blockLength;
         this.error = error;
         this.warnings = warnings;
-        this.valueBeforeDecodeView = build.BufferSourceConverter.toUint8Array(valueBeforeDecode);
+        this.valueBeforeDecodeView = BufferSourceConverter_1.toUint8Array(valueBeforeDecode);
     }
     static blockName() {
         return this.NAME;
@@ -6466,7 +6466,7 @@ class LocalBaseBlock {
             blockLength: this.blockLength,
             error: this.error,
             warnings: this.warnings,
-            valueBeforeDecode: build.Convert.ToHex(this.valueBeforeDecodeView),
+            valueBeforeDecode: Convert_1.ToHex(this.valueBeforeDecodeView),
         };
     }
 }
@@ -6488,7 +6488,7 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
         super();
         if (idBlock) {
             this.isHexOnly = (_a = idBlock.isHexOnly) !== null && _a !== void 0 ? _a : false;
-            this.valueHexView = idBlock.valueHex ? build.BufferSourceConverter.toUint8Array(idBlock.valueHex) : EMPTY_VIEW;
+            this.valueHexView = idBlock.valueHex ? BufferSourceConverter_1.toUint8Array(idBlock.valueHex) : EMPTY_VIEW;
             this.tagClass = (_b = idBlock.tagClass) !== null && _b !== void 0 ? _b : -1;
             this.tagNumber = (_c = idBlock.tagNumber) !== null && _c !== void 0 ? _c : -1;
             this.isConstructed = (_d = idBlock.isConstructed) !== null && _d !== void 0 ? _d : false;
@@ -6554,7 +6554,7 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
         return retView.buffer;
     }
     fromBER(inputBuffer, inputOffset, inputLength) {
-        const inputView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const inputView = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
             return -1;
         }
@@ -6663,7 +6663,7 @@ class LocalLengthBlock extends LocalBaseBlock {
         this.length = (_c = lenBlock.length) !== null && _c !== void 0 ? _c : 0;
     }
     fromBER(inputBuffer, inputOffset, inputLength) {
-        const view = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const view = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, view, inputOffset, inputLength)) {
             return -1;
         }
@@ -6822,10 +6822,10 @@ class BaseBlock extends LocalBaseBlock {
         if (encoding === "ascii") {
             return this.onAsciiEncoding();
         }
-        return build.Convert.ToHex(this.toBER());
+        return Convert_1.ToHex(this.toBER());
     }
     onAsciiEncoding() {
-        return `${this.constructor.NAME} : ${build.Convert.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
+        return `${this.constructor.NAME} : ${Convert_1.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
     }
     isEqual(other) {
         if (this === other) {
@@ -7123,7 +7123,7 @@ function fromBER(inputBuffer) {
             result
         };
     }
-    return localFromBER(build.BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength);
+    return localFromBER(BufferSourceConverter_1.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength);
 }
 
 function checkLen(indefiniteLength, length) {
@@ -7139,7 +7139,7 @@ class LocalConstructedValueBlock extends ValueBlock {
         this.isIndefiniteForm = isIndefiniteForm;
     }
     fromBER(inputBuffer, inputOffset, inputLength) {
-        const view = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const view = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, view, inputOffset, inputLength)) {
             return -1;
         }
@@ -7309,7 +7309,7 @@ class LocalBooleanValueBlock extends HexBlock(ValueBlock) {
     constructor({ value, ...parameters } = {}) {
         super(parameters);
         if (parameters.valueHex) {
-            this.valueHexView = build.BufferSourceConverter.toUint8Array(parameters.valueHex);
+            this.valueHexView = BufferSourceConverter_1.toUint8Array(parameters.valueHex);
         }
         else {
             this.valueHexView = new Uint8Array(1);
@@ -7330,7 +7330,7 @@ class LocalBooleanValueBlock extends HexBlock(ValueBlock) {
         this.valueHexView[0] = value ? 0xFF : 0x00;
     }
     fromBER(inputBuffer, inputOffset, inputLength) {
-        const inputView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const inputView = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
             return -1;
         }
@@ -7477,7 +7477,7 @@ class OctetString$1 extends BaseBlock {
         if (this.valueBlock.isConstructed || (this.valueBlock.value && this.valueBlock.value.length)) {
             return Constructed.prototype.onAsciiEncoding.call(this);
         }
-        return `${this.constructor.NAME} : ${build.Convert.ToHex(this.valueBlock.valueHexView)}`;
+        return `${this.constructor.NAME} : ${Convert_1.ToHex(this.valueBlock.valueHexView)}`;
     }
     getValue() {
         if (!this.idBlock.isConstructed) {
@@ -7489,7 +7489,7 @@ class OctetString$1 extends BaseBlock {
                 array.push(content.valueBlock.valueHexView);
             }
         }
-        return build.BufferSourceConverter.concat(array);
+        return BufferSourceConverter_1.concat(array);
     }
 }
 _a$r = OctetString$1;
@@ -7537,7 +7537,7 @@ class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
             }
             return resultOffset;
         }
-        const inputView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const inputView = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
             return -1;
         }
@@ -7877,13 +7877,13 @@ class Integer extends BaseBlock {
         const bigIntValue = BigInt(value);
         const writer = new ViewWriter();
         const hex = bigIntValue.toString(16).replace(/^-/, "");
-        const view = new Uint8Array(build.Convert.FromHex(hex));
+        const view = new Uint8Array(Convert_1.FromHex(hex));
         if (bigIntValue < 0) {
             const first = new Uint8Array(view.length + (view[0] & 0x80 ? 1 : 0));
             first[0] |= 0x80;
-            const firstInt = BigInt(`0x${build.Convert.ToHex(first)}`);
+            const firstInt = BigInt(`0x${Convert_1.ToHex(first)}`);
             const secondInt = firstInt + bigIntValue;
-            const second = build.BufferSourceConverter.toUint8Array(build.Convert.FromHex(secondInt.toString(16)));
+            const second = BufferSourceConverter_1.toUint8Array(Convert_1.FromHex(secondInt.toString(16)));
             second[0] |= 0x80;
             writer.write(second);
         }
@@ -7944,7 +7944,7 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
         if (!inputLength) {
             return inputOffset;
         }
-        const inputView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const inputView = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
             return -1;
         }
@@ -8016,7 +8016,7 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
     toString() {
         let result = "";
         if (this.isHexOnly)
-            result = build.Convert.ToHex(this.valueHexView);
+            result = Convert_1.ToHex(this.valueHexView);
         else {
             if (this.isFirstSid) {
                 let sidValue = this.valueDec;
@@ -8213,7 +8213,7 @@ class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) {
     fromBER(inputBuffer, inputOffset, inputLength) {
         if (inputLength === 0)
             return inputOffset;
-        const inputView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        const inputView = BufferSourceConverter_1.toUint8Array(inputBuffer);
         if (!checkBufferParams(this, inputView, inputOffset, inputLength))
             return -1;
         const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
@@ -8271,7 +8271,7 @@ class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) {
     toString() {
         let result = "";
         if (this.isHexOnly)
-            result = build.Convert.ToHex(this.valueHexView);
+            result = Convert_1.ToHex(this.valueHexView);
         else {
             result = this.valueDec.toString();
         }
@@ -8453,7 +8453,7 @@ class LocalSimpleStringBlock extends BaseStringBlock {
         super(parameters, LocalSimpleStringValueBlock);
     }
     fromBuffer(inputBuffer) {
-        this.valueBlock.value = String.fromCharCode.apply(null, build.BufferSourceConverter.toUint8Array(inputBuffer));
+        this.valueBlock.value = String.fromCharCode.apply(null, BufferSourceConverter_1.toUint8Array(inputBuffer));
     }
     fromString(inputString) {
         const strLen = inputString.length;
@@ -8467,17 +8467,17 @@ LocalSimpleStringBlock.NAME = "SIMPLE STRING";
 
 class LocalUtf8StringValueBlock extends LocalSimpleStringBlock {
     fromBuffer(inputBuffer) {
-        this.valueBlock.valueHexView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        this.valueBlock.valueHexView = BufferSourceConverter_1.toUint8Array(inputBuffer);
         try {
-            this.valueBlock.value = build.Convert.ToUtf8String(inputBuffer);
+            this.valueBlock.value = Convert_1.ToUtf8String(inputBuffer);
         }
         catch (ex) {
             this.warnings.push(`Error during "decodeURIComponent": ${ex}, using raw string`);
-            this.valueBlock.value = build.Convert.ToBinary(inputBuffer);
+            this.valueBlock.value = Convert_1.ToBinary(inputBuffer);
         }
     }
     fromString(inputString) {
-        this.valueBlock.valueHexView = new Uint8Array(build.Convert.FromUtf8String(inputString));
+        this.valueBlock.valueHexView = new Uint8Array(Convert_1.FromUtf8String(inputString));
         this.valueBlock.value = inputString;
     }
 }
@@ -8499,12 +8499,12 @@ Utf8String.NAME = "UTF8String";
 
 class LocalBmpStringValueBlock extends LocalSimpleStringBlock {
     fromBuffer(inputBuffer) {
-        this.valueBlock.value = build.Convert.ToUtf16String(inputBuffer);
-        this.valueBlock.valueHexView = build.BufferSourceConverter.toUint8Array(inputBuffer);
+        this.valueBlock.value = Convert_1.ToUtf16String(inputBuffer);
+        this.valueBlock.valueHexView = BufferSourceConverter_1.toUint8Array(inputBuffer);
     }
     fromString(inputString) {
         this.valueBlock.value = inputString;
-        this.valueBlock.valueHexView = new Uint8Array(build.Convert.FromUtf16String(inputString));
+        this.valueBlock.valueHexView = new Uint8Array(Convert_1.FromUtf16String(inputString));
     }
 }
 LocalBmpStringValueBlock.NAME = "BmpStringValueBlock";
@@ -8716,7 +8716,7 @@ class UTCTime extends VisibleString {
         this.idBlock.tagNumber = 23;
     }
     fromBuffer(inputBuffer) {
-        this.fromString(String.fromCharCode.apply(null, build.BufferSourceConverter.toUint8Array(inputBuffer)));
+        this.fromString(String.fromCharCode.apply(null, BufferSourceConverter_1.toUint8Array(inputBuffer)));
     }
     toBuffer() {
         const str = this.toString();
@@ -9066,17 +9066,17 @@ class Repeated extends Any {
 
 class RawData {
     constructor({ data = EMPTY_VIEW } = {}) {
-        this.dataView = build.BufferSourceConverter.toUint8Array(data);
+        this.dataView = BufferSourceConverter_1.toUint8Array(data);
     }
     get data() {
         return this.dataView.slice().buffer;
     }
     set data(value) {
-        this.dataView = build.BufferSourceConverter.toUint8Array(value);
+        this.dataView = BufferSourceConverter_1.toUint8Array(value);
     }
     fromBER(inputBuffer, inputOffset, inputLength) {
         const endLength = inputOffset + inputLength;
-        this.dataView = build.BufferSourceConverter.toUint8Array(inputBuffer).subarray(inputOffset, endLength);
+        this.dataView = BufferSourceConverter_1.toUint8Array(inputBuffer).subarray(inputOffset, endLength);
         return endLength;
     }
     toBER(sizeOnly) {
@@ -9395,7 +9395,7 @@ function verifySchema(inputBuffer, inputSchema) {
             result: { error: "Wrong ASN.1 schema type" }
         };
     }
-    const asn1 = localFromBER(build.BufferSourceConverter.toUint8Array(inputBuffer));
+    const asn1 = localFromBER(BufferSourceConverter_1.toUint8Array(inputBuffer));
     if (asn1.offset === -1) {
         return {
             verified: false,
@@ -9498,9 +9498,9 @@ class BitString {
             if (typeof params === "number") {
                 this.fromNumber(params);
             }
-            else if (build.BufferSourceConverter.isBufferSource(params)) {
+            else if (BufferSourceConverter_1.isBufferSource(params)) {
                 this.unusedBits = unusedBits;
-                this.value = build.BufferSourceConverter.toArrayBuffer(params);
+                this.value = BufferSourceConverter_1.toArrayBuffer(params);
             }
             else {
                 throw TypeError("Unsupported type of 'params' argument for BitString");
@@ -9549,13 +9549,19 @@ class BitString {
 }
 
 class OctetString {
+    get byteLength() {
+        return this.buffer.byteLength;
+    }
+    get byteOffset() {
+        return 0;
+    }
     constructor(param) {
         if (typeof param === "number") {
             this.buffer = new ArrayBuffer(param);
         }
         else {
-            if (build.BufferSourceConverter.isBufferSource(param)) {
-                this.buffer = build.BufferSourceConverter.toArrayBuffer(param);
+            if (BufferSourceConverter_1.isBufferSource(param)) {
+                this.buffer = BufferSourceConverter_1.toArrayBuffer(param);
             }
             else if (Array.isArray(param)) {
                 this.buffer = new Uint8Array(param);
@@ -9565,12 +9571,6 @@ class OctetString {
             }
         }
     }
-    get byteLength() {
-        return this.buffer.byteLength;
-    }
-    get byteOffset() {
-        return 0;
-    }
     fromASN(asn) {
         if (!(asn instanceof OctetString$1)) {
             throw new TypeError("Argument 'asn' is not instance of ASN.1 OctetString");
@@ -10257,8 +10257,8 @@ class AsnConvert {
         return AsnParser.parse(data, target);
     }
     static toString(data) {
-        const buf = build.BufferSourceConverter.isBufferSource(data)
-            ? build.BufferSourceConverter.toArrayBuffer(data)
+        const buf = BufferSourceConverter_1.isBufferSource(data)
+            ? BufferSourceConverter_1.toArrayBuffer(data)
             : AsnConvert.serialize(data);
         const asn = fromBER(buf);
         if (asn.offset === -1) {
@@ -10288,6 +10288,27 @@ function __decorate(decorators, target, key, desc) {
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
 }
 
 var ipaddr = createCommonjsModule(function (module) {
@@ -10495,6 +10516,7 @@ var ipaddr = createCommonjsModule(function (module) {
                 [new IPv4([192, 0, 0, 0]), 24],
                 [new IPv4([192, 0, 2, 0]), 24],
                 [new IPv4([192, 88, 99, 0]), 24],
+                [new IPv4([198, 18, 0, 0]), 15],
                 [new IPv4([198, 51, 100, 0]), 24],
                 [new IPv4([203, 0, 113, 0]), 24],
                 [new IPv4([240, 0, 0, 0]), 4]
@@ -10837,7 +10859,12 @@ var ipaddr = createCommonjsModule(function (module) {
             // RFC6052, RFC6146
             teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32],
             // RFC4291
-            reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]]
+            reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]],
+            benchmarking: [new IPv6([0x2001, 0x2, 0, 0, 0, 0, 0, 0]), 48],
+            amt: [new IPv6([0x2001, 0x3, 0, 0, 0, 0, 0, 0]), 32],
+            as112v6: [new IPv6([0x2001, 0x4, 0x112, 0, 0, 0, 0, 0]), 48],
+            deprecated: [new IPv6([0x2001, 0x10, 0, 0, 0, 0, 0, 0]), 28],
+            orchid2: [new IPv6([0x2001, 0x20, 0, 0, 0, 0, 0, 0]), 28]
         };
 
         // Checks if this address is an IPv4-mapped IPv6 address.
@@ -11022,11 +11049,9 @@ var ipaddr = createCommonjsModule(function (module) {
 
         // Returns the address in compact, human-readable format like
         // 2001:db8:8:66::1
-        //
-        // Deprecated: use toRFC5952String() instead.
+        // Calls toRFC5952String under the hood.
         IPv6.prototype.toString = function () {
-            // Replace the first sequence of 1 or more '0' parts with '::'
-            return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::');
+            return this.toRFC5952String();
         };
 
         return IPv6;
@@ -11311,7 +11336,7 @@ class IpConverter {
             const addr = ipaddr.fromByteArray(Array.from(uint8));
             return addr.toString();
         }
-        return this.decodeIP(build.Convert.ToHex(buf));
+        return this.decodeIP(Convert_1.ToHex(buf));
     }
     static fromString(text) {
         const addr = ipaddr.parse(text);
@@ -11353,7 +11378,7 @@ let AttributeValue = class AttributeValue extends DirectoryString {
         Object.assign(this, params);
     }
     toString() {
-        return this.ia5String || (this.anyValue ? build.Convert.ToHex(this.anyValue) : super.toString());
+        return this.ia5String || (this.anyValue ? Convert_1.ToHex(this.anyValue) : super.toString());
     }
 };
 __decorate([
@@ -12147,7 +12172,7 @@ class AlgorithmIdentifier {
         return data instanceof AlgorithmIdentifier
             && data.algorithm == this.algorithm
             && ((data.parameters && this.parameters
-                && build.isEqual(data.parameters, this.parameters))
+                && isEqual_1(data.parameters, this.parameters))
                 ||
                     (data.parameters === this.parameters));
     }
@@ -12266,16 +12291,16 @@ Extensions$1 = Extensions_1 = __decorate([
     AsnType({ type: AsnTypeTypes.Sequence, itemType: Extension$1 })
 ], Extensions$1);
 
-var Version$3;
+var Version$4;
 (function (Version) {
     Version[Version["v1"] = 0] = "v1";
     Version[Version["v2"] = 1] = "v2";
     Version[Version["v3"] = 2] = "v3";
-})(Version$3 || (Version$3 = {}));
+})(Version$4 || (Version$4 = {}));
 
 class TBSCertificate {
     constructor(params = {}) {
-        this.version = Version$3.v1;
+        this.version = Version$4.v1;
         this.serialNumber = new ArrayBuffer(0);
         this.signature = new AlgorithmIdentifier();
         this.issuer = new Name$1();
@@ -12289,7 +12314,7 @@ __decorate([
     AsnProp({
         type: AsnPropTypes.Integer,
         context: 0,
-        defaultValue: Version$3.v1,
+        defaultValue: Version$4.v1,
     })
 ], TBSCertificate.prototype, "version", void 0);
 __decorate([
@@ -12719,10 +12744,10 @@ __decorate([
 ], EncryptedPrivateKeyInfo$1.prototype, "encryptedData", void 0);
 
 var Attributes_1$1;
-var Version$2;
+var Version$3;
 (function (Version) {
     Version[Version["v1"] = 0] = "v1";
-})(Version$2 || (Version$2 = {}));
+})(Version$3 || (Version$3 = {}));
 class PrivateKey extends OctetString {
 }
 let Attributes$2 = Attributes_1$1 = class Attributes extends AsnArray {
@@ -12736,7 +12761,7 @@ Attributes$2 = Attributes_1$1 = __decorate([
 ], Attributes$2);
 class PrivateKeyInfo$1 {
     constructor(params = {}) {
-        this.version = Version$2.v1;
+        this.version = Version$3.v1;
         this.privateKeyAlgorithm = new AlgorithmIdentifier();
         this.privateKey = new PrivateKey();
         Object.assign(this, params);
@@ -12756,11 +12781,11 @@ __decorate([
 ], PrivateKeyInfo$1.prototype, "attributes", void 0);
 
 var AsymmetricKeyPackage_1;
-var Version$1;
+var Version$2;
 (function (Version) {
     Version[Version["v1"] = 0] = "v1";
     Version[Version["v2"] = 1] = "v2";
-})(Version$1 || (Version$1 = {}));
+})(Version$2 || (Version$2 = {}));
 let PrivateKeyAlgorithmIdentifier = class PrivateKeyAlgorithmIdentifier extends AlgorithmIdentifier {
 };
 PrivateKeyAlgorithmIdentifier = __decorate([
@@ -12768,7 +12793,7 @@ PrivateKeyAlgorithmIdentifier = __decorate([
 ], PrivateKeyAlgorithmIdentifier);
 let OneAsymmetricKey = class OneAsymmetricKey {
     constructor() {
-        this.version = Version$1.v1;
+        this.version = Version$2.v1;
         this.privateKeyAlgorithm = new AlgorithmIdentifier();
         this.privateKey = new ArrayBuffer(0);
     }
@@ -13114,34 +13139,34 @@ class Download {
 }
 Download.cert = {
   asPEM: (pem, name) => {
-    downloadFromBuffer(build.Convert.FromString(pem), name, 'cer', 'application/pkix-cert');
+    downloadFromBuffer(Convert_1.FromString(pem), name, 'cer', 'application/pkix-cert');
   },
   asDER: (hex, name) => {
-    downloadFromBuffer(build.Convert.FromString(hex), name, 'cer', 'application/pkix-cert');
+    downloadFromBuffer(Convert_1.FromString(hex), name, 'cer', 'application/pkix-cert');
   },
 };
 Download.attrCert = {
   asPEM: (pem, name) => {
-    downloadFromBuffer(build.Convert.FromString(pem), name, 'cer', 'application/pkix-attr-cert');
+    downloadFromBuffer(Convert_1.FromString(pem), name, 'cer', 'application/pkix-attr-cert');
   },
   asDER: (hex, name) => {
-    downloadFromBuffer(build.Convert.FromString(hex), name, 'cer', 'application/pkix-attr-cert');
+    downloadFromBuffer(Convert_1.FromString(hex), name, 'cer', 'application/pkix-attr-cert');
   },
 };
 Download.csr = {
   asPEM: (pem, name) => {
-    downloadFromBuffer(build.Convert.FromString(pem), name, 'csr', 'application/pkcs10');
+    downloadFromBuffer(Convert_1.FromString(pem), name, 'csr', 'application/pkcs10');
   },
   asDER: (hex, name) => {
-    downloadFromBuffer(build.Convert.FromString(hex), name, 'csr', 'application/pkcs10');
+    downloadFromBuffer(Convert_1.FromString(hex), name, 'csr', 'application/pkcs10');
   },
 };
 Download.crl = {
   asPEM: (pem, name) => {
-    downloadFromBuffer(build.Convert.FromString(pem), name, 'crl', 'application/pkix-crl');
+    downloadFromBuffer(Convert_1.FromString(pem), name, 'crl', 'application/pkix-crl');
   },
   asDER: (hex, name) => {
-    downloadFromBuffer(build.Convert.FromString(hex), name, 'crl', 'application/pkix-crl');
+    downloadFromBuffer(Convert_1.FromString(hex), name, 'crl', 'application/pkix-crl');
   },
 };
 
@@ -15448,6 +15473,7 @@ const OIDs = {
   '1.3.6.1.4.1.4329.7': 'Siemens Public Key Infrastructure',
   '1.3.6.1.4.1.52266.1': 'Legal Entity Identifier',
   '1.3.6.1.4.1.52266.2': 'Role',
+  '1.3.6.1.4.1.11129.2.1.17': 'Android Key Attestation',
   // https://ec.europa.eu/futurium/sites/futurium/files/ntqwac_pilot.pdf
   '0.4.0.9496.1': 'Domain Name Beneficiary',
   '0.4.0.9496.2': 'DNB Legal representative',
@@ -15485,6 +15511,18 @@ function getStringByOID(value) {
   return value;
 }
 
+/**
+ * @license
+ * Copyright (c) Peculiar Ventures, LLC.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function camelCaseToWords(value) {
+  const result = value.replace(/([A-Z])/g, ' $1');
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}
+
 /**
  * @license
  * Copyright (c) Peculiar Ventures, LLC.
@@ -15507,7 +15545,7 @@ var _Name_asn;
 class Name {
   constructor(data) {
     _Name_asn.set(this, new Name$1());
-    if (build.BufferSourceConverter.isBufferSource(data)) {
+    if (BufferSourceConverter_1.isBufferSource(data)) {
       __classPrivateFieldSet$1(this, _Name_asn, AsnParser.parse(data, Name$1), "f");
     }
     else {
@@ -15715,8 +15753,8 @@ let CaVersion = class CaVersion {
             data.set(new Uint8Array(this.value), 4 - this.value.byteLength);
         }
         return {
-            keyIndex: parseInt(build.Convert.ToHex(data.slice(0, 2)), 16),
-            certificateIndex: parseInt(build.Convert.ToHex(data.slice(2)), 16),
+            keyIndex: parseInt(Convert_1.ToHex(data.slice(0, 2)), 16),
+            certificateIndex: parseInt(Convert_1.ToHex(data.slice(2)), 16),
         };
     }
 };
@@ -16062,11 +16100,6 @@ Lei = __decorate([
     AsnType({ type: AsnTypeTypes.Sequence })
 ], Lei);
 let BaseLeiChoice = class BaseLeiChoice {
-    constructor(value) {
-        if (value) {
-            this.text = value;
-        }
-    }
     get text() {
         if (this.bmpString !== undefined) {
             return this.bmpString;
@@ -16088,6 +16121,11 @@ let BaseLeiChoice = class BaseLeiChoice {
     set text(value) {
         this.printableString = value;
     }
+    constructor(value) {
+        if (value) {
+            this.text = value;
+        }
+    }
 };
 __decorate([
     AsnProp({ type: AsnPropTypes.IA5String })
@@ -16132,13 +16170,13 @@ LeiRole = __decorate([
 ], LeiRole);
 
 class ByteStream {
-    constructor(bytes) {
-        this.offset = 0;
-        this.view = build.BufferSourceConverter.toUint8Array(bytes);
-    }
     get position() {
         return this.offset;
     }
+    constructor(bytes) {
+        this.offset = 0;
+        this.view = BufferSourceConverter_1.toUint8Array(bytes);
+    }
     read(size = 1) {
         const res = this.view.slice(this.offset, this.offset + size);
         this.offset = this.offset + res.length;
@@ -16153,7 +16191,7 @@ class ByteStream {
     }
     readNumber(size) {
         const bytes = this.read(size);
-        const hex = build.Convert.ToHex(bytes);
+        const hex = Convert_1.ToHex(bytes);
         return parseInt(hex, 16);
     }
     readEnd() {
@@ -16166,7 +16204,7 @@ class ByteStream {
 
 class Structure {
     static createStream(bytes) {
-        const view = build.BufferSourceConverter.toUint8Array(bytes);
+        const view = BufferSourceConverter_1.toUint8Array(bytes);
         return new ByteStream(view);
     }
 }
@@ -16210,7 +16248,7 @@ class SignedCertificateTimestamp extends Structure {
     parse(stream) {
         this.version = stream.readByte();
         stream.read(2);
-        this.logId = build.BufferSourceConverter.toArrayBuffer(stream.read(32));
+        this.logId = BufferSourceConverter_1.toArrayBuffer(stream.read(32));
         this.timestamp = new Date(stream.readNumber(8));
         const extLen = stream.readNumber(2);
         this.extensions = stream.read(extLen).buffer;
@@ -16221,12 +16259,12 @@ class SignedCertificateTimestamp extends Structure {
     toJSON() {
         return {
             version: this.version,
-            logId: build.Convert.ToHex(this.logId),
+            logId: Convert_1.ToHex(this.logId),
             timestamp: this.timestamp,
-            extensions: build.Convert.ToBase64(this.extensions),
+            extensions: Convert_1.ToBase64(this.extensions),
             hashAlgorithm: HashAlgorithm[this.hashAlgorithm] || "undefined",
             signatureAlgorithm: SignatureAlgorithm[this.signatureAlgorithm] || "undefined",
-            signature: build.Convert.ToBase64(this.signature),
+            signature: Convert_1.ToBase64(this.signature),
         };
     }
 }
@@ -16252,15 +16290,15 @@ class CertificateTransparency extends OctetString {
     }
 }
 
-var Version;
+var Version$1;
 (function (Version) {
     Version[Version["v1"] = 1] = "v1";
-})(Version || (Version = {}));
+})(Version$1 || (Version$1 = {}));
 
 const id_adbe_archiveRevInfo = "1.2.840.113583.1.1.9.2";
 class ArchiveRevInfo {
     constructor(params = {}) {
-        this.version = Version.v1;
+        this.version = Version$1.v1;
         Object.assign(this, params);
     }
 }
@@ -16271,7 +16309,7 @@ __decorate([
 const id_adbe_timestamp = "1.2.840.113583.1.1.9.1";
 class Timestamp {
     constructor(params = {}) {
-        this.version = Version.v1;
+        this.version = Version$1.v1;
         this.location = new GeneralName();
         this.requiresAuth = false;
         Object.assign(this, params);
@@ -16616,6 +16654,302 @@ TNAuthorizationList = TNAuthorizationList_1 = __decorate([
     })
 ], TNAuthorizationList);
 
+var IntegerSet_1;
+const id_ce_keyDescription = "1.3.6.1.4.1.11129.2.1.17";
+var VerifiedBootState;
+(function (VerifiedBootState) {
+    VerifiedBootState[VerifiedBootState["verified"] = 0] = "verified";
+    VerifiedBootState[VerifiedBootState["selfSigned"] = 1] = "selfSigned";
+    VerifiedBootState[VerifiedBootState["unverified"] = 2] = "unverified";
+    VerifiedBootState[VerifiedBootState["failed"] = 3] = "failed";
+})(VerifiedBootState || (VerifiedBootState = {}));
+class RootOfTrust {
+    constructor(params = {}) {
+        this.verifiedBootKey = new OctetString();
+        this.deviceLocked = false;
+        this.verifiedBootState = VerifiedBootState.verified;
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: OctetString })
+], RootOfTrust.prototype, "verifiedBootKey", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Boolean })
+], RootOfTrust.prototype, "deviceLocked", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Enumerated })
+], RootOfTrust.prototype, "verifiedBootState", void 0);
+__decorate([
+    AsnProp({ type: OctetString, optional: true })
+], RootOfTrust.prototype, "verifiedBootHash", void 0);
+let IntegerSet = IntegerSet_1 = class IntegerSet extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, IntegerSet_1.prototype);
+    }
+};
+IntegerSet = IntegerSet_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Set, itemType: AsnPropTypes.Integer })
+], IntegerSet);
+class AuthorizationList {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ context: 1, type: IntegerSet, optional: true })
+], AuthorizationList.prototype, "purpose", void 0);
+__decorate([
+    AsnProp({ context: 2, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "algorithm", void 0);
+__decorate([
+    AsnProp({ context: 3, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "keySize", void 0);
+__decorate([
+    AsnProp({ context: 5, type: IntegerSet, optional: true })
+], AuthorizationList.prototype, "digest", void 0);
+__decorate([
+    AsnProp({ context: 6, type: IntegerSet, optional: true })
+], AuthorizationList.prototype, "padding", void 0);
+__decorate([
+    AsnProp({ context: 10, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "ecCurve", void 0);
+__decorate([
+    AsnProp({ context: 200, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "rsaPublicExponent", void 0);
+__decorate([
+    AsnProp({ context: 303, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "rollbackResistance", void 0);
+__decorate([
+    AsnProp({ context: 305, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "earlyBootOnly", void 0);
+__decorate([
+    AsnProp({ context: 400, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "activeDateTime", void 0);
+__decorate([
+    AsnProp({ context: 401, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "originationExpireDateTime", void 0);
+__decorate([
+    AsnProp({ context: 402, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "usageExpireDateTime", void 0);
+__decorate([
+    AsnProp({ context: 503, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "noAuthRequired", void 0);
+__decorate([
+    AsnProp({ context: 504, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "userAuthType", void 0);
+__decorate([
+    AsnProp({ context: 505, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "authTimeout", void 0);
+__decorate([
+    AsnProp({ context: 506, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "allowWhileOnBody", void 0);
+__decorate([
+    AsnProp({ context: 507, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "trustedUserPresenceRequired", void 0);
+__decorate([
+    AsnProp({ context: 508, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "trustedConfirmationRequired", void 0);
+__decorate([
+    AsnProp({ context: 509, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "unlockedDeviceRequired", void 0);
+__decorate([
+    AsnProp({ context: 600, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "allApplications", void 0);
+__decorate([
+    AsnProp({ context: 601, type: OctetString, optional: true })
+], AuthorizationList.prototype, "applicationId", void 0);
+__decorate([
+    AsnProp({ context: 701, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "creationDateTime", void 0);
+__decorate([
+    AsnProp({ context: 702, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "origin", void 0);
+__decorate([
+    AsnProp({ context: 703, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "rollbackResistant", void 0);
+__decorate([
+    AsnProp({ context: 704, type: RootOfTrust, optional: true })
+], AuthorizationList.prototype, "rootOfTrust", void 0);
+__decorate([
+    AsnProp({ context: 705, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "osVersion", void 0);
+__decorate([
+    AsnProp({ context: 706, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "osPatchLevel", void 0);
+__decorate([
+    AsnProp({ context: 709, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationApplicationId", void 0);
+__decorate([
+    AsnProp({ context: 710, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdBrand", void 0);
+__decorate([
+    AsnProp({ context: 711, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdDevice", void 0);
+__decorate([
+    AsnProp({ context: 712, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdProduct", void 0);
+__decorate([
+    AsnProp({ context: 713, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdSerial", void 0);
+__decorate([
+    AsnProp({ context: 714, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdImei", void 0);
+__decorate([
+    AsnProp({ context: 715, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdMeid", void 0);
+__decorate([
+    AsnProp({ context: 716, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdManufacturer", void 0);
+__decorate([
+    AsnProp({ context: 717, type: OctetString, optional: true })
+], AuthorizationList.prototype, "attestationIdModel", void 0);
+__decorate([
+    AsnProp({ context: 718, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "vendorPatchLevel", void 0);
+__decorate([
+    AsnProp({ context: 719, type: AsnPropTypes.Integer, optional: true })
+], AuthorizationList.prototype, "bootPatchLevel", void 0);
+__decorate([
+    AsnProp({ context: 720, type: AsnPropTypes.Null, optional: true })
+], AuthorizationList.prototype, "deviceUniqueAttestation", void 0);
+var SecurityLevel;
+(function (SecurityLevel) {
+    SecurityLevel[SecurityLevel["software"] = 0] = "software";
+    SecurityLevel[SecurityLevel["trustedEnvironment"] = 1] = "trustedEnvironment";
+    SecurityLevel[SecurityLevel["strongBox"] = 2] = "strongBox";
+})(SecurityLevel || (SecurityLevel = {}));
+var Version;
+(function (Version) {
+    Version[Version["KM2"] = 1] = "KM2";
+    Version[Version["KM3"] = 2] = "KM3";
+    Version[Version["KM4"] = 3] = "KM4";
+    Version[Version["KM4_1"] = 4] = "KM4_1";
+    Version[Version["keyMint1"] = 100] = "keyMint1";
+    Version[Version["keyMint2"] = 200] = "keyMint2";
+})(Version || (Version = {}));
+class KeyDescription {
+    constructor(params = {}) {
+        this.attestationVersion = Version.KM4;
+        this.attestationSecurityLevel = SecurityLevel.software;
+        this.keymasterVersion = 0;
+        this.keymasterSecurityLevel = SecurityLevel.software;
+        this.attestationChallenge = new OctetString();
+        this.uniqueId = new OctetString();
+        this.softwareEnforced = new AuthorizationList();
+        this.teeEnforced = new AuthorizationList();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], KeyDescription.prototype, "attestationVersion", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Enumerated })
+], KeyDescription.prototype, "attestationSecurityLevel", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], KeyDescription.prototype, "keymasterVersion", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Enumerated })
+], KeyDescription.prototype, "keymasterSecurityLevel", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], KeyDescription.prototype, "attestationChallenge", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], KeyDescription.prototype, "uniqueId", void 0);
+__decorate([
+    AsnProp({ type: AuthorizationList })
+], KeyDescription.prototype, "softwareEnforced", void 0);
+__decorate([
+    AsnProp({ type: AuthorizationList })
+], KeyDescription.prototype, "teeEnforced", void 0);
+
+var NonStandardAuthorizationList_1;
+let NonStandardAuthorization = class NonStandardAuthorization extends AuthorizationList {
+};
+NonStandardAuthorization = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], NonStandardAuthorization);
+let NonStandardAuthorizationList = NonStandardAuthorizationList_1 = class NonStandardAuthorizationList extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, NonStandardAuthorizationList_1.prototype);
+    }
+    findProperty(key) {
+        const prop = this.find((o => key in o));
+        if (prop) {
+            return prop[key];
+        }
+        return undefined;
+    }
+};
+NonStandardAuthorizationList = NonStandardAuthorizationList_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence, itemType: NonStandardAuthorization })
+], NonStandardAuthorizationList);
+class NonStandardKeyDescription {
+    constructor(params = {}) {
+        this.attestationVersion = Version.KM4;
+        this.attestationSecurityLevel = SecurityLevel.software;
+        this.keymasterVersion = 0;
+        this.keymasterSecurityLevel = SecurityLevel.software;
+        this.attestationChallenge = new OctetString();
+        this.uniqueId = new OctetString();
+        this.softwareEnforced = new NonStandardAuthorizationList();
+        this.teeEnforced = new NonStandardAuthorizationList();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], NonStandardKeyDescription.prototype, "attestationVersion", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Enumerated })
+], NonStandardKeyDescription.prototype, "attestationSecurityLevel", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], NonStandardKeyDescription.prototype, "keymasterVersion", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Enumerated })
+], NonStandardKeyDescription.prototype, "keymasterSecurityLevel", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], NonStandardKeyDescription.prototype, "attestationChallenge", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], NonStandardKeyDescription.prototype, "uniqueId", void 0);
+__decorate([
+    AsnProp({ type: NonStandardAuthorizationList })
+], NonStandardKeyDescription.prototype, "softwareEnforced", void 0);
+__decorate([
+    AsnProp({ type: NonStandardAuthorizationList })
+], NonStandardKeyDescription.prototype, "teeEnforced", void 0);
+
+class AttestationPackageInfo {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.OctetString })
+], AttestationPackageInfo.prototype, "packageName", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], AttestationPackageInfo.prototype, "version", void 0);
+class AttestationApplicationId {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AttestationPackageInfo, repeated: "set" })
+], AttestationApplicationId.prototype, "packageInfos", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.OctetString, repeated: "set" })
+], AttestationApplicationId.prototype, "signatureDigests", void 0);
+
 /**
  * @license
  * Copyright (c) Peculiar Ventures, LLC.
@@ -16648,7 +16982,7 @@ class AsnData {
     else {
       // raw, type
       __classPrivateFieldSet(this, _AsnData_asn, AsnConvert.parse(args[0], args[1]), "f");
-      __classPrivateFieldSet(this, _AsnData_raw, build.BufferSourceConverter.toArrayBuffer(args[0]), "f");
+      __classPrivateFieldSet(this, _AsnData_raw, BufferSourceConverter_1.toArrayBuffer(args[0]), "f");
     }
   }
   get asn() {
@@ -16792,14 +17126,17 @@ class Extension extends AsnData {
         case id_ce_deltaCRLIndicator:
           this.value = AsnParser.parse(asnExtnValue, BaseCRLNumber);
           break;
+        case id_ce_keyDescription:
+          this.value = AsnParser.parse(asnExtnValue, NonStandardKeyDescription);
+          break;
         default:
           console.warn(`Didn't detect parser for "${this.asn.extnID}" extension.`);
-          this.value = build.Convert.ToHex(asnExtnValue);
+          this.value = Convert_1.ToHex(asnExtnValue);
       }
     }
     catch (error) {
       console.error(`Error parse "${this.asn.extnID}" extension:`, error.message);
-      this.value = build.Convert.ToHex(asnExtnValue);
+      this.value = Convert_1.ToHex(asnExtnValue);
     }
   }
 }
@@ -16861,13 +17198,13 @@ const certificateRawToBuffer = (raw) => {
   const rawClarified = base64Clarify(raw);
   let buffer;
   if (isHex(rawClarified)) {
-    buffer = build.Convert.FromHex(rawClarified);
+    buffer = Convert_1.FromHex(rawClarified);
   }
   else if (isBase64(rawClarified) || isPem(rawClarified)) {
-    buffer = build.Convert.FromBase64(rawClarified);
+    buffer = Convert_1.FromBase64(rawClarified);
   }
   else {
-    buffer = build.Convert.FromBinary(raw);
+    buffer = Convert_1.FromBinary(raw);
   }
   return buffer;
 };
@@ -16892,7 +17229,7 @@ class X509Certificate extends AsnData {
     this.thumbprints = {};
     this.type = 'X.509 Certificate';
     const { tbsCertificate } = this.asn;
-    this.serialNumber = build.Convert.ToHex(tbsCertificate.serialNumber);
+    this.serialNumber = Convert_1.ToHex(tbsCertificate.serialNumber);
     this.subject = new Name(tbsCertificate.subject).toJSON();
     this.issuer = new Name(tbsCertificate.issuer).toJSON();
     this.version = tbsCertificate.version + 1;
@@ -16955,10 +17292,10 @@ class X509Certificate extends AsnData {
     };
   }
   exportAsBase64() {
-    return build.Convert.ToBase64(this.raw);
+    return Convert_1.ToBase64(this.raw);
   }
   exportAsHexFormatted() {
-    return hexFormat(build.Convert.ToHex(this.raw));
+    return hexFormat(Convert_1.ToHex(this.raw));
   }
   exportAsPemFormatted() {
     return `-----BEGIN CERTIFICATE-----\n${base64Format(this.exportAsBase64())}\n-----END CERTIFICATE-----`;
@@ -16967,7 +17304,7 @@ class X509Certificate extends AsnData {
     try {
       const thumbprint = await getCertificateThumbprint(algorithm, this.raw);
       if (thumbprint) {
-        this.thumbprints[algorithm] = build.Convert.ToHex(thumbprint);
+        this.thumbprints[algorithm] = Convert_1.ToHex(thumbprint);
       }
     }
     catch (error) {
@@ -17584,6 +17921,75 @@ WebGDPR = __decorate([
     AsnType({ type: AsnTypeTypes.Sequence })
 ], WebGDPR);
 
+class IssuerAndSerialNumber {
+    constructor(params = {}) {
+        this.issuer = new Name$1;
+        this.serialNumber = new ArrayBuffer(0);
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: Name$1 })
+], IssuerAndSerialNumber.prototype, "issuer", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter })
+], IssuerAndSerialNumber.prototype, "serialNumber", void 0);
+
+let SignerIdentifier = class SignerIdentifier {
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+};
+__decorate([
+    AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true })
+], SignerIdentifier.prototype, "subjectKeyIdentifier", void 0);
+__decorate([
+    AsnProp({ type: IssuerAndSerialNumber })
+], SignerIdentifier.prototype, "issuerAndSerialNumber", void 0);
+SignerIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], SignerIdentifier);
+
+var CMSVersion;
+(function (CMSVersion) {
+    CMSVersion[CMSVersion["v0"] = 0] = "v0";
+    CMSVersion[CMSVersion["v1"] = 1] = "v1";
+    CMSVersion[CMSVersion["v2"] = 2] = "v2";
+    CMSVersion[CMSVersion["v3"] = 3] = "v3";
+    CMSVersion[CMSVersion["v4"] = 4] = "v4";
+    CMSVersion[CMSVersion["v5"] = 5] = "v5";
+})(CMSVersion || (CMSVersion = {}));
+let DigestAlgorithmIdentifier = class DigestAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+DigestAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], DigestAlgorithmIdentifier);
+let SignatureAlgorithmIdentifier = class SignatureAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+SignatureAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], SignatureAlgorithmIdentifier);
+let KeyEncryptionAlgorithmIdentifier = class KeyEncryptionAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+KeyEncryptionAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], KeyEncryptionAlgorithmIdentifier);
+let ContentEncryptionAlgorithmIdentifier = class ContentEncryptionAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+ContentEncryptionAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], ContentEncryptionAlgorithmIdentifier);
+let MessageAuthenticationCodeAlgorithm = class MessageAuthenticationCodeAlgorithm extends AlgorithmIdentifier {
+};
+MessageAuthenticationCodeAlgorithm = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], MessageAuthenticationCodeAlgorithm);
+let KeyDerivationAlgorithmIdentifier = class KeyDerivationAlgorithmIdentifier extends AlgorithmIdentifier {
+};
+KeyDerivationAlgorithmIdentifier = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], KeyDerivationAlgorithmIdentifier);
+
 class Attribute$1 {
     constructor(params = {}) {
         this.attrType = "";
@@ -17598,6 +18004,59 @@ __decorate([
     AsnProp({ type: AsnPropTypes.Any, repeated: "set" })
 ], Attribute$1.prototype, "attrValues", void 0);
 
+var SignerInfos_1;
+class SignerInfo {
+    constructor(params = {}) {
+        this.version = CMSVersion.v0;
+        this.sid = new SignerIdentifier();
+        this.digestAlgorithm = new DigestAlgorithmIdentifier();
+        this.signatureAlgorithm = new SignatureAlgorithmIdentifier();
+        this.signature = new OctetString();
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.Integer })
+], SignerInfo.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: SignerIdentifier })
+], SignerInfo.prototype, "sid", void 0);
+__decorate([
+    AsnProp({ type: DigestAlgorithmIdentifier })
+], SignerInfo.prototype, "digestAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: Attribute$1, repeated: "set", context: 0, implicit: true, optional: true })
+], SignerInfo.prototype, "signedAttrs", void 0);
+__decorate([
+    AsnProp({ type: SignatureAlgorithmIdentifier })
+], SignerInfo.prototype, "signatureAlgorithm", void 0);
+__decorate([
+    AsnProp({ type: OctetString })
+], SignerInfo.prototype, "signature", void 0);
+__decorate([
+    AsnProp({ type: Attribute$1, repeated: "set", context: 1, implicit: true, optional: true })
+], SignerInfo.prototype, "unsignedAttrs", void 0);
+let SignerInfos = SignerInfos_1 = class SignerInfos extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, SignerInfos_1.prototype);
+    }
+};
+SignerInfos = SignerInfos_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Set, itemType: SignerInfo })
+], SignerInfos);
+
+let SigningTime$1 = class SigningTime extends Time {
+};
+SigningTime$1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], SigningTime$1);
+let CounterSignature$1 = class CounterSignature extends SignerInfo {
+};
+CounterSignature$1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], CounterSignature$1);
+
 var CertificateSet_1;
 class OtherCertificateFormat {
     constructor(params = {}) {
@@ -17680,46 +18139,6 @@ __decorate([
     AsnProp({ type: EncapsulatedContent, context: 0, optional: true })
 ], EncapsulatedContentInfo.prototype, "eContent", void 0);
 
-var CMSVersion;
-(function (CMSVersion) {
-    CMSVersion[CMSVersion["v0"] = 0] = "v0";
-    CMSVersion[CMSVersion["v1"] = 1] = "v1";
-    CMSVersion[CMSVersion["v2"] = 2] = "v2";
-    CMSVersion[CMSVersion["v3"] = 3] = "v3";
-    CMSVersion[CMSVersion["v4"] = 4] = "v4";
-    CMSVersion[CMSVersion["v5"] = 5] = "v5";
-})(CMSVersion || (CMSVersion = {}));
-let DigestAlgorithmIdentifier = class DigestAlgorithmIdentifier extends AlgorithmIdentifier {
-};
-DigestAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], DigestAlgorithmIdentifier);
-let SignatureAlgorithmIdentifier = class SignatureAlgorithmIdentifier extends AlgorithmIdentifier {
-};
-SignatureAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], SignatureAlgorithmIdentifier);
-let KeyEncryptionAlgorithmIdentifier = class KeyEncryptionAlgorithmIdentifier extends AlgorithmIdentifier {
-};
-KeyEncryptionAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], KeyEncryptionAlgorithmIdentifier);
-let ContentEncryptionAlgorithmIdentifier = class ContentEncryptionAlgorithmIdentifier extends AlgorithmIdentifier {
-};
-ContentEncryptionAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], ContentEncryptionAlgorithmIdentifier);
-let MessageAuthenticationCodeAlgorithm = class MessageAuthenticationCodeAlgorithm extends AlgorithmIdentifier {
-};
-MessageAuthenticationCodeAlgorithm = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], MessageAuthenticationCodeAlgorithm);
-let KeyDerivationAlgorithmIdentifier = class KeyDerivationAlgorithmIdentifier extends AlgorithmIdentifier {
-};
-KeyDerivationAlgorithmIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Sequence })
-], KeyDerivationAlgorithmIdentifier);
-
 let EncryptedContent = class EncryptedContent {
     constructor(params = {}) {
         Object.assign(this, params);
@@ -17751,20 +18170,6 @@ __decorate([
     AsnProp({ type: EncryptedContent, optional: true })
 ], EncryptedContentInfo.prototype, "encryptedContent", void 0);
 
-class IssuerAndSerialNumber {
-    constructor(params = {}) {
-        this.issuer = new Name$1;
-        this.serialNumber = new ArrayBuffer(0);
-        Object.assign(this, params);
-    }
-}
-__decorate([
-    AsnProp({ type: Name$1 })
-], IssuerAndSerialNumber.prototype, "issuer", void 0);
-__decorate([
-    AsnProp({ type: AsnPropTypes.Integer, converter: AsnIntegerArrayBufferConverter })
-], IssuerAndSerialNumber.prototype, "serialNumber", void 0);
-
 class OtherKeyAttribute {
     constructor(params = {}) {
         this.keyAttrId = "";
@@ -18109,63 +18514,6 @@ __decorate([
     AsnProp({ type: UnprotectedAttributes, context: 1, implicit: true, optional: true })
 ], EnvelopedData.prototype, "unprotectedAttrs", void 0);
 
-let SignerIdentifier = class SignerIdentifier {
-    constructor(params = {}) {
-        Object.assign(this, params);
-    }
-};
-__decorate([
-    AsnProp({ type: SubjectKeyIdentifier, context: 0, implicit: true })
-], SignerIdentifier.prototype, "subjectKeyIdentifier", void 0);
-__decorate([
-    AsnProp({ type: IssuerAndSerialNumber })
-], SignerIdentifier.prototype, "issuerAndSerialNumber", void 0);
-SignerIdentifier = __decorate([
-    AsnType({ type: AsnTypeTypes.Choice })
-], SignerIdentifier);
-
-var SignerInfos_1;
-class SignerInfo {
-    constructor(params = {}) {
-        this.version = CMSVersion.v0;
-        this.sid = new SignerIdentifier();
-        this.digestAlgorithm = new DigestAlgorithmIdentifier();
-        this.signatureAlgorithm = new SignatureAlgorithmIdentifier();
-        this.signature = new OctetString();
-        Object.assign(this, params);
-    }
-}
-__decorate([
-    AsnProp({ type: AsnPropTypes.Integer })
-], SignerInfo.prototype, "version", void 0);
-__decorate([
-    AsnProp({ type: SignerIdentifier })
-], SignerInfo.prototype, "sid", void 0);
-__decorate([
-    AsnProp({ type: DigestAlgorithmIdentifier })
-], SignerInfo.prototype, "digestAlgorithm", void 0);
-__decorate([
-    AsnProp({ type: Attribute$1, repeated: "set", context: 0, implicit: true, optional: true })
-], SignerInfo.prototype, "signedAttrs", void 0);
-__decorate([
-    AsnProp({ type: SignatureAlgorithmIdentifier })
-], SignerInfo.prototype, "signatureAlgorithm", void 0);
-__decorate([
-    AsnProp({ type: OctetString })
-], SignerInfo.prototype, "signature", void 0);
-__decorate([
-    AsnProp({ type: Attribute$1, repeated: "set", context: 1, implicit: true, optional: true })
-], SignerInfo.prototype, "unsignedAttrs", void 0);
-let SignerInfos = SignerInfos_1 = class SignerInfos extends AsnArray {
-    constructor(items) {
-        super(items);
-        Object.setPrototypeOf(this, SignerInfos_1.prototype);
-    }
-};
-SignerInfos = SignerInfos_1 = __decorate([
-    AsnType({ type: AsnTypeTypes.Set, itemType: SignerInfo })
-], SignerInfos);
-
 var DigestAlgorithmIdentifiers_1;
 let DigestAlgorithmIdentifiers = DigestAlgorithmIdentifiers_1 = class DigestAlgorithmIdentifiers extends AsnArray {
     constructor(items) {
@@ -18615,7 +18963,7 @@ class Attribute extends AsnData {
         break;
       }
       default:
-        this.value = build.Convert.ToHex(asnExtnValue);
+        this.value = Convert_1.ToHex(asnExtnValue);
     }
   }
 }
@@ -18634,7 +18982,7 @@ class X509AttributeCertificate extends AsnData {
     this.thumbprints = {};
     this.type = 'X.509 Attribute Certificate';
     const { acinfo } = this.asn;
-    this.serialNumber = build.Convert.ToHex(acinfo.serialNumber);
+    this.serialNumber = Convert_1.ToHex(acinfo.serialNumber);
     this.version = acinfo.version;
     const notBefore = acinfo.attrCertValidityPeriod.notBeforeTime;
     if (!notBefore) {
@@ -18675,7 +19023,7 @@ class X509AttributeCertificate extends AsnData {
     try {
       const thumbprint = await getCertificateThumbprint(algorithm, this.raw);
       if (thumbprint) {
-        this.thumbprints[algorithm] = build.Convert.ToHex(thumbprint);
+        this.thumbprints[algorithm] = Convert_1.ToHex(thumbprint);
       }
     }
     catch (error) {
@@ -18683,10 +19031,10 @@ class X509AttributeCertificate extends AsnData {
     }
   }
   exportAsBase64() {
-    return build.Convert.ToBase64(this.raw);
+    return Convert_1.ToBase64(this.raw);
   }
   exportAsHexFormatted() {
-    return hexFormat(build.Convert.ToHex(this.raw));
+    return hexFormat(Convert_1.ToHex(this.raw));
   }
   exportAsPemFormatted() {
     return `-----BEGIN ATTRIBUTE CERTIFICATE-----\n${base64Format(this.exportAsBase64())}\n-----END ATTRIBUTE CERTIFICATE-----`;
@@ -18808,7 +19156,7 @@ class CSR extends AsnData {
     try {
       const thumbprint = await getCertificateThumbprint(algorithm, this.raw);
       if (thumbprint) {
-        this.thumbprints[algorithm] = build.Convert.ToHex(thumbprint);
+        this.thumbprints[algorithm] = Convert_1.ToHex(thumbprint);
       }
     }
     catch (error) {
@@ -18823,10 +19171,10 @@ class CSR extends AsnData {
     }
   }
   exportAsBase64() {
-    return build.Convert.ToBase64(this.raw);
+    return Convert_1.ToBase64(this.raw);
   }
   exportAsHexFormatted() {
-    return hexFormat(build.Convert.ToHex(this.raw));
+    return hexFormat(Convert_1.ToHex(this.raw));
   }
   exportAsPemFormatted() {
     return `-----BEGIN CERTIFICATE REQUEST-----\n${base64Format(this.exportAsBase64())}\n-----END CERTIFICATE REQUEST-----`;
@@ -18870,7 +19218,7 @@ class CRL extends AsnData {
     try {
       const thumbprint = await getCertificateThumbprint(algorithm, this.raw);
       if (thumbprint) {
-        this.thumbprints[algorithm] = build.Convert.ToHex(thumbprint);
+        this.thumbprints[algorithm] = Convert_1.ToHex(thumbprint);
       }
     }
     catch (error) {
@@ -18904,10 +19252,10 @@ class CRL extends AsnData {
     }
   }
   exportAsBase64() {
-    return build.Convert.ToBase64(this.raw);
+    return Convert_1.ToBase64(this.raw);
   }
   exportAsHexFormatted() {
-    return hexFormat(build.Convert.ToHex(this.raw));
+    return hexFormat(Convert_1.ToHex(this.raw));
   }
   exportAsPemFormatted() {
     return `-----BEGIN X509 CRL-----\n${base64Format(this.exportAsBase64())}\n-----END X509 CRL-----`;
@@ -19109,7 +19457,7 @@ const PublicKey = (props) => {
       hAsync(RowValue, { name: l10n.getString('namedCurve'), value: getStringByOID((key.params && 'namedCurve' in key.params) ? key.params.namedCurve : undefined) }),
       hAsync(RowValue, { name: l10n.getString('exponent'), value: getPublicKeyExponent(key) }),
       hAsync(RowValue, { name: l10n.getString('modulus'), value: getPublicKeyModulus(key) }),
-      hAsync(RowValue, { name: l10n.getString('value'), value: build.Convert.ToHex(key.value), monospace: true, collapse: true }),
+      hAsync(RowValue, { name: l10n.getString('value'), value: Convert_1.ToHex(key.value), monospace: true, collapse: true }),
     ];
   }
   return [
@@ -19165,7 +19513,7 @@ const Signature = (props) => {
   function renderSignatureDetails(data) {
     return [
       hAsync(RowValue, { name: l10n.getString('algorithm'), value: getStringByOID(data.algorithm) }),
-      hAsync(RowValue, { name: l10n.getString('value'), value: build.Convert.ToHex(data.value), monospace: true, collapse: true }),
+      hAsync(RowValue, { name: l10n.getString('value'), value: Convert_1.ToHex(data.value), monospace: true, collapse: true }),
     ];
   }
   return [
@@ -19268,7 +19616,7 @@ const ExtendedKeyUsageExtension = (props) => {
  */
 const SubjectKeyIdentifierExtension = (props) => {
   const { extension, getSubjectKeyIdChildrenLink, getSubjectKeyIdSiblingsLink } = props;
-  const keyId = build.Convert.ToHex(extension.value.buffer);
+  const keyId = Convert_1.ToHex(extension.value.buffer);
   const childrenLink = getSubjectKeyIdChildrenLink(keyId);
   const siblingsLink = getSubjectKeyIdSiblingsLink(keyId);
   return (hAsync(BasicExtension, { extension: extension },
@@ -19293,7 +19641,7 @@ const SubjectKeyIdentifierExtension = (props) => {
  */
 const AuthorityKeyIdentifierExtension = (props) => {
   const { extension, getAuthKeyIdParentLink, getAuthKeyIdSiblingsLink } = props;
-  const keyId = build.Convert.ToHex(extension.value.keyIdentifier.buffer);
+  const keyId = Convert_1.ToHex(extension.value.keyIdentifier.buffer);
   const parentLink = getAuthKeyIdParentLink(keyId);
   const siblingsLink = getAuthKeyIdSiblingsLink(keyId);
   return (hAsync(BasicExtension, { extension: extension },
@@ -19357,10 +19705,10 @@ const GeneralNamePart = (props) => {
       catch (error) {
         //
       }
-      return (hAsync(RowValue, { name: OIDs[value.typeId] || value.typeId, value: build.Convert.ToHex(value.value), monospace: true }));
+      return (hAsync(RowValue, { name: OIDs[value.typeId] || value.typeId, value: Convert_1.ToHex(value.value), monospace: true }));
     }
-    if (build.BufferSourceConverter.isBufferSource(value)) {
-      return (hAsync(RowValue, { name: names[name] || name, value: build.Convert.ToString(value) }));
+    if (BufferSourceConverter_1.isBufferSource(value)) {
+      return (hAsync(RowValue, { name: names[name] || name, value: Convert_1.ToString(value) }));
     }
     if (value instanceof EDIPartyName) {
       return (hAsync(RowValue, { name: names[name] || name, value: value.partyName.toString() }));
@@ -19766,7 +20114,7 @@ const QCStatementsExtension = (props) => {
           hAsync(RowValue, { name: "Language", value: location.language })))),
       ]);
     }
-    return (hAsync(RowValue, { name: "Info", value: build.Convert.ToHex(statementInfo), monospace: true }));
+    return (hAsync(RowValue, { name: "Info", value: Convert_1.ToHex(statementInfo), monospace: true }));
   }
   return (hAsync(BasicExtension, { extension: extension }, Boolean(extension.value.length) && ([
     hAsync(RowValue, { name: "Statements", value: "" }),
@@ -19877,7 +20225,7 @@ const CRLReasonExtension = (props) => {
  * LICENSE file in the root directory of this source tree.
  */
 function getAttributeValue(attribute) {
-  return build.Convert.ToString(attribute.values[0]);
+  return Convert_1.ToString(attribute.values[0]);
 }
 
 /**
@@ -19953,7 +20301,7 @@ const BiometricSyntaxExtension = (props) => {
       hAsync(RowValue, { name: "OID", value: getStringByOID(data.typeOfBiometricData.biometricDataOid) }),
       hAsync(RowValue, { name: "Type", value: data.typeOfBiometricData.predefinedBiometricType }),
       hAsync(RowValue, { name: "Algorithm", value: getStringByOID(data.hashAlgorithm.algorithm) }),
-      hAsync(RowValue, { name: "Hash", value: build.Convert.ToHex(data.biometricDataHash.buffer), monospace: true }),
+      hAsync(RowValue, { name: "Hash", value: Convert_1.ToHex(data.biometricDataHash.buffer), monospace: true }),
       hAsync(RowValue, { name: "Source Uri", value: data.sourceDataUri })))),
   ])));
 };
@@ -19975,7 +20323,7 @@ const LogotypeExtension = (props) => {
       const { imageDetails } = img;
       return [
         hAsync(RowValue, { name: "Image Type", value: imageDetails.mediaType }),
-        hAsync(RowValue, { name: "Image Hash", value: build.Convert.ToHex(imageDetails.logotypeHash[0].hashValue), monospace: true }),
+        hAsync(RowValue, { name: "Image Hash", value: Convert_1.ToHex(imageDetails.logotypeHash[0].hashValue), monospace: true }),
         hAsync(RowValue, { name: "Image URL", value: imageDetails.logotypeURI[0], monospace: true, collapse: true }),
         hAsync(RowValue, { name: "Image Hash Algorithm", value: getStringByOID(imageDetails.logotypeHash[0].hashAlg.algorithm) }),
       ];
@@ -19989,7 +20337,7 @@ const LogotypeExtension = (props) => {
       const { audioDetails } = aud;
       return [
         hAsync(RowValue, { name: "Audio Type", value: audioDetails.mediaType }),
-        hAsync(RowValue, { name: "Audio Hash", value: build.Convert.ToHex(audioDetails.logotypeHash[0].hashValue), monospace: true }),
+        hAsync(RowValue, { name: "Audio Hash", value: Convert_1.ToHex(audioDetails.logotypeHash[0].hashValue), monospace: true }),
         hAsync(RowValue, { name: "Audio URL", value: audioDetails.logotypeURI[0], monospace: true, collapse: true }),
         hAsync(RowValue, { name: "Audio Hash Algorithm", value: getStringByOID(audioDetails.logotypeHash[0].hashAlg.algorithm) }),
       ];
@@ -20094,6 +20442,85 @@ const IssuingDistributionPointExtension = (props) => {
     extension.value.onlyContainsCACerts && (hAsync(RowValue, { name: l10n.getString('onlyCACertificates'), value: l10n.getString('yes') }))));
 };
 
+/**
+ * @license
+ * Copyright (c) Peculiar Ventures, LLC.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const KeyDescriptionExtension = (props) => {
+  const { extension } = props;
+  const renderRowValue = (data) => Object.keys(data).map((keyName) => {
+    const keyValue = data[keyName];
+    let value = '';
+    switch (true) {
+      case typeof keyValue === 'string' || typeof keyValue === 'number':
+        value = keyValue;
+        break;
+      case keyValue instanceof IntegerSet:
+        value = keyValue.join(', ');
+        break;
+      case typeof keyValue === 'boolean':
+        value = keyValue
+          ? l10n.getString('yes')
+          : l10n.getString('no');
+        break;
+      case Object.is(keyValue, null):
+        value = 'NULL';
+        break;
+      case keyValue instanceof RootOfTrust:
+        return [
+          hAsync(RowValue, { name: camelCaseToWords(keyName), value: "" }),
+          hAsync(TableRowTable, null, renderRowValue(keyValue)),
+        ];
+      case BufferSourceConverter_1.isBufferSource(keyValue):
+        if (keyName === 'attestationApplicationId') {
+          try {
+            const parsed = AsnParser.parse(keyValue, AttestationApplicationId);
+            if (parsed.packageInfos.length || parsed.signatureDigests.length) {
+              return [
+                hAsync(RowValue, { name: camelCaseToWords(keyName), value: "" }),
+                Boolean(parsed.packageInfos) && (hAsync(TableRowTable, null,
+                  hAsync(RowValue, { name: camelCaseToWords('packageInfos'), value: "" }),
+                  parsed.packageInfos.map((attestationPackageInfo) => (hAsync(TableRowTable, null, renderRowValue(attestationPackageInfo)))))),
+              ];
+            }
+          }
+          catch (error) {
+            //
+          }
+        }
+        try {
+          value = Convert_1.ToString(keyValue);
+        }
+        catch (error) {
+          value = Convert_1.ToHex(keyValue);
+        }
+        break;
+    }
+    return (hAsync(RowValue, { name: camelCaseToWords(keyName), value: value }));
+  });
+  const renderAuthorizationList = (title, authorizationList) => {
+    if (authorizationList.length === 0) {
+      return null;
+    }
+    return [
+      hAsync(RowValue, { name: title, value: "" }),
+      hAsync(TableRowTable, null, authorizationList.map(renderRowValue)),
+    ];
+  };
+  return (hAsync(BasicExtension, { extension: extension },
+    hAsync(RowValue, { name: camelCaseToWords('attestationVersion'), value: extension.value.attestationVersion }),
+    hAsync(RowValue, { name: camelCaseToWords('attestationSecurityLevel'), value: extension.value.attestationSecurityLevel }),
+    hAsync(RowValue, { name: camelCaseToWords('keymasterVersion'), value: extension.value.keymasterVersion }),
+    hAsync(RowValue, { name: camelCaseToWords('keymasterSecurityLevel'), value: extension.value.keymasterSecurityLevel }),
+    hAsync(RowValue, { name: camelCaseToWords('attestationChallenge'), value: Convert_1.ToString(extension.value.attestationChallenge) }),
+    hAsync(RowValue, { name: camelCaseToWords('uniqueId'), value: Convert_1.ToString(extension.value.uniqueId) || undefined }),
+    renderAuthorizationList(camelCaseToWords('softwareEnforced'), extension.value.softwareEnforced),
+    renderAuthorizationList(camelCaseToWords('teeEnforced'), extension.value.teeEnforced)));
+};
+
 /**
  * @license
  * Copyright (c) Peculiar Ventures, LLC.
@@ -20207,6 +20634,9 @@ const Extensions = (props) => {
         if (extension.value instanceof IssuingDistributionPoint) {
           return (hAsync(IssuingDistributionPointExtension, Object.assign({ extension: extension }, props)));
         }
+        if (extension.value instanceof NonStandardKeyDescription) {
+          return (hAsync(KeyDescriptionExtension, Object.assign({ extension: extension }, props)));
+        }
         if (typeof extension.value === 'string') {
           return (hAsync(AsStringExtension, { extension: extension }));
         }
@@ -20596,7 +21026,7 @@ const RevokedCertificates = (props) => {
   return [
     hAsync(RowTitle, { value: l10n.getString('revokedCertificates') }),
     revokedCertificates.map((certificate) => ([
-      hAsync(RowValue, { name: l10n.getString('serialNumber'), value: build.Convert.ToHex(certificate.userCertificate), monospace: true }),
+      hAsync(RowValue, { name: l10n.getString('serialNumber'), value: Convert_1.ToHex(certificate.userCertificate), monospace: true }),
       hAsync(RowValue, { name: l10n.getString('revocationDate'), value: dateShort(certificate.revocationDate.getTime()) }),
       (certificate.crlEntryExtensions && certificate.crlEntryExtensions.length && ([
         hAsync(RowValue, { name: `${l10n.getString('crlEntryExtensions')}:`, value: "" }),
@@ -20614,7 +21044,7 @@ const RevokedCertificates = (props) => {
                 hAsync(GeneralNamePart, { generalName: gn, getDNSNameLink: getDNSNameLink, getIPAddressLink: getIPAddressLink })))),
             ]);
           }
-          return (hAsync(RowValue, { name: getStringByOID(extension.asn.extnID), value: build.Convert.ToHex(extension.asn.extnValue), monospace: true }));
+          return (hAsync(RowValue, { name: getStringByOID(extension.asn.extnID), value: Convert_1.ToHex(extension.asn.extnValue), monospace: true }));
         })),
       ])),
       hAsync("tr", null,
@@ -20644,7 +21074,7 @@ const Holder = (props) => {
       hAsync("tr", null,
         hAsync("td", null),
         hAsync("td", null)),
-      hAsync(RowValue, { name: l10n.getString('serialNumber'), value: build.Convert.ToHex(baseCertificateID.serial), monospace: true }),
+      hAsync(RowValue, { name: l10n.getString('serialNumber'), value: Convert_1.ToHex(baseCertificateID.serial), monospace: true }),
       hAsync("tr", null,
         hAsync("td", null),
         hAsync("td", null)),
@@ -20652,7 +21082,7 @@ const Holder = (props) => {
     objectDigestInfo && ([
       hAsync(RowValue, { name: l10n.getString('digestInfo'), value: "" }),
       hAsync(RowValue, { name: l10n.getString('algorithm'), value: getStringByOID(objectDigestInfo.digestAlgorithm.algorithm) }),
-      hAsync(RowValue, { name: l10n.getString('value'), value: build.Convert.ToHex(objectDigestInfo.objectDigest), monospace: true }),
+      hAsync(RowValue, { name: l10n.getString('value'), value: Convert_1.ToHex(objectDigestInfo.objectDigest), monospace: true }),
       hAsync(RowValue, { name: l10n.getString('type'), value: objectDigestInfo.digestedObjectType }),
     ]),
   ];