edockit 0.4.0-dev.1 → 0.4.1

package/dist/index.cjs.js

@@ -8,16 +8,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var fflate = require('fflate');
 var x509 = require('@peculiar/x509');
-var certificate = require('./certificate-c7123a37.js');
-var identity = require('./identity-c9e5052e.js');
-var normalize = require('./normalize-9626be7c.js');
+var certificate = require('./certificate-e6d074b8.js');
+var identity = require('./identity-d8910151.js');
 var asn1Schema = require('@peculiar/asn1-schema');
+var asn1X509 = require('@peculiar/asn1-x509');
+var normalize = require('./normalize-9626be7c.js');
 var asn1Cms = require('@peculiar/asn1-cms');
 var asn1Tsp = require('@peculiar/asn1-tsp');
 require('@xmldom/xmldom');
 require('xpath');
 require('@peculiar/asn1-ocsp');
-require('@peculiar/asn1-x509');
 
 // Canonicalization method URIs
 const CANONICALIZATION_METHODS = {
@@ -614,7 +614,7 @@ function parseSignatureFile(xmlContent, filename) {
                 // Look for Signature elements as direct children
                 const directSignature = certificate.querySelector(rootElement, "ds\\:Signature, Signature");
                 if (directSignature) {
-                    let signatureInfo = parseSignatureElement(directSignature, xmlDoc);
+                    let signatureInfo = parseSignatureElement(directSignature);
                     signatureInfo.rawXml = text;
                     return signatureInfo;
                 }
@@ -631,7 +631,7 @@ function parseSignatureFile(xmlContent, filename) {
         return null;
     }
     // Parse the signature and add the raw XML
-    let signatureInfo = parseSignatureElement(signatureElements[0], xmlDoc);
+    let signatureInfo = parseSignatureElement(signatureElements[0]);
     signatureInfo.rawXml = text;
     return signatureInfo;
 }
@@ -699,7 +699,7 @@ function parseSignatureElement(signatureElement, xmlDoc) {
     let signatureTimestamp;
     let signatureTimestampCanonicalizationMethod;
     let signatureTimestampInclusiveNamespacePrefixList;
-    const signatureTimestampElement = certificate.querySelector(xmlDoc, "xades\\:SignatureTimeStamp, SignatureTimeStamp");
+    const signatureTimestampElement = certificate.querySelector(signatureElement, "xades\\:SignatureTimeStamp, SignatureTimeStamp");
     if (signatureTimestampElement) {
         const timestampC14nMethodEl = certificate.querySelector(signatureTimestampElement, "ds\\:CanonicalizationMethod, CanonicalizationMethod");
         signatureTimestampCanonicalizationMethod =
@@ -758,7 +758,7 @@ function parseSignatureElement(signatureElement, xmlDoc) {
         }
     }
     // Also look for XAdES CertificateValues (contains full chain excluding signer)
-    const certValues = certificate.querySelector(xmlDoc, "xades\\:CertificateValues, CertificateValues");
+    const certValues = certificate.querySelector(signatureElement, "xades\\:CertificateValues, CertificateValues");
     if (certValues) {
         const encapsulatedCerts = certificate.querySelectorAll(certValues, "xades\\:EncapsulatedX509Certificate, EncapsulatedX509Certificate");
         for (const encCert of encapsulatedCerts) {
@@ -772,6 +772,29 @@ function parseSignatureElement(signatureElement, xmlDoc) {
             }
         }
     }
+    // Extract embedded XAdES LTV revocation material (OCSP responses / CRLs) captured
+    // at signing time. This lets "not revoked at signing time" be answered offline.
+    let revocationValues;
+    const revocationValuesEl = certificate.querySelector(signatureElement, "xades\\:RevocationValues, RevocationValues");
+    if (revocationValuesEl) {
+        const ocsp = [];
+        const crl = [];
+        for (const el of certificate.querySelectorAll(revocationValuesEl, "xades\\:EncapsulatedOCSPValue, EncapsulatedOCSPValue")) {
+            const value = el.textContent?.replace(/\s+/g, "");
+            if (value) {
+                ocsp.push(value);
+            }
+        }
+        for (const el of certificate.querySelectorAll(revocationValuesEl, "xades\\:EncapsulatedCRLValue, EncapsulatedCRLValue")) {
+            const value = el.textContent?.replace(/\s+/g, "");
+            if (value) {
+                crl.push(value);
+            }
+        }
+        if (ocsp.length > 0 || crl.length > 0) {
+            revocationValues = { ocsp, crl };
+        }
+    }
     if (certificate$1) {
         certificatePEM = formatPEM(certificate$1);
         // Extract public key and signer info
@@ -795,7 +818,7 @@ function parseSignatureElement(signatureElement, xmlDoc) {
         }
     }
     // Get signing time
-    const signingTimeElement = certificate.querySelector(xmlDoc, "xades\\:SigningTime, SigningTime");
+    const signingTimeElement = certificate.querySelector(signatureElement, "xades\\:SigningTime, SigningTime");
     const signingTime = signingTimeElement && signingTimeElement.textContent
         ? new Date(signingTimeElement.textContent.trim())
         : new Date();
@@ -853,6 +876,7 @@ function parseSignatureElement(signatureElement, xmlDoc) {
         signedInfoXml,
         canonicalizationMethod,
         signatureTimestamp,
+        revocationValues,
     };
 }
 /**
@@ -998,200 +1022,3529 @@ function fixRSAModulusPadding(publicKeyData) {
     if (keyBytes[0] !== 0x30) {
         return publicKeyData;
     }
-    // Look for RSA OID to confirm it's an RSA key
-    const RSA_OID = [0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01];
-    let oidPosition = -1;
-    for (let i = 0; i <= keyBytes.length - RSA_OID.length; i++) {
-        let match = true;
-        for (let j = 0; j < RSA_OID.length; j++) {
-            if (keyBytes[i + j] !== RSA_OID[j]) {
-                match = false;
-                break;
-            }
+    // Look for RSA OID to confirm it's an RSA key
+    const RSA_OID = [0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01];
+    let oidPosition = -1;
+    for (let i = 0; i <= keyBytes.length - RSA_OID.length; i++) {
+        let match = true;
+        for (let j = 0; j < RSA_OID.length; j++) {
+            if (keyBytes[i + j] !== RSA_OID[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            oidPosition = i;
+            break;
+        }
+    }
+    if (oidPosition === -1) {
+        return publicKeyData;
+    }
+    // Find the BitString that contains the key
+    let bitStringPosition = -1;
+    for (let i = oidPosition + RSA_OID.length; i < keyBytes.length; i++) {
+        if (keyBytes[i] === 0x03) {
+            // BIT STRING tag
+            bitStringPosition = i;
+            break;
+        }
+    }
+    if (bitStringPosition === -1) {
+        return publicKeyData;
+    }
+    // Skip BIT STRING tag and length bytes to find unused bits byte
+    let bitStringLengthBytes = 0;
+    if ((keyBytes[bitStringPosition + 1] & 0x80) === 0) {
+        // Short form length
+        bitStringLengthBytes = 1;
+    }
+    else {
+        // Long form length
+        bitStringLengthBytes = 1 + (keyBytes[bitStringPosition + 1] & 0x7f);
+    }
+    // The unused bits byte follows the length bytes
+    const unusedBitsPosition = bitStringPosition + 1 + bitStringLengthBytes;
+    if (unusedBitsPosition >= keyBytes.length) {
+        return publicKeyData;
+    }
+    // The inner SEQUENCE (RSA key) should follow the unused bits byte
+    const innerSequencePosition = unusedBitsPosition + 1;
+    if (innerSequencePosition >= keyBytes.length || keyBytes[innerSequencePosition] !== 0x30) {
+        return publicKeyData;
+    }
+    // Skip the inner SEQUENCE tag and length bytes to find the modulus
+    let innerSequenceLengthBytes = 0;
+    if ((keyBytes[innerSequencePosition + 1] & 0x80) === 0) {
+        // Short form length
+        innerSequenceLengthBytes = 1;
+    }
+    else {
+        // Long form length
+        innerSequenceLengthBytes = 1 + (keyBytes[innerSequencePosition + 1] & 0x7f);
+    }
+    // The modulus should be an INTEGER (tag 0x02) after the inner SEQUENCE
+    const modulusPosition = innerSequencePosition + 1 + innerSequenceLengthBytes;
+    if (modulusPosition >= keyBytes.length || keyBytes[modulusPosition] !== 0x02) {
+        return publicKeyData;
+    }
+    // Skip the INTEGER tag and parse its length to find the modulus value
+    let modulusLengthBytes = 0;
+    let modulusLength = 0;
+    if ((keyBytes[modulusPosition + 1] & 0x80) === 0) {
+        // Short form length
+        modulusLength = keyBytes[modulusPosition + 1];
+        modulusLengthBytes = 1;
+    }
+    else {
+        // Long form length
+        const numLengthBytes = keyBytes[modulusPosition + 1] & 0x7f;
+        modulusLengthBytes = 1 + numLengthBytes;
+        // Calculate multi-byte length
+        modulusLength = 0;
+        for (let i = 0; i < numLengthBytes; i++) {
+            modulusLength = (modulusLength << 8) | keyBytes[modulusPosition + 2 + i];
+        }
+    }
+    // The first byte of the modulus value
+    const modulusValuePosition = modulusPosition + 1 + modulusLengthBytes;
+    if (modulusValuePosition >= keyBytes.length) {
+        return publicKeyData;
+    }
+    // Check if the high bit is set and padding is needed
+    if ((keyBytes[modulusValuePosition] & 0x80) !== 0) {
+        // Create a new key buffer with room for the padding byte
+        const fixedKey = new Uint8Array(keyBytes.length + 1);
+        // Copy bytes up to the modulus value
+        fixedKey.set(keyBytes.slice(0, modulusValuePosition));
+        // Add the padding byte
+        fixedKey[modulusValuePosition] = 0x00;
+        // Copy the rest of the original key after the padding
+        fixedKey.set(keyBytes.slice(modulusValuePosition), modulusValuePosition + 1);
+        // Now fix all the length fields that need to be incremented
+        // 1. Fix modulus length field
+        if ((keyBytes[modulusPosition + 1] & 0x80) === 0) {
+            // Short form
+            fixedKey[modulusPosition + 1] = keyBytes[modulusPosition + 1] + 1;
+        }
+        else {
+            // Long form
+            const numLengthBytes = keyBytes[modulusPosition + 1] & 0x7f;
+            let lengthValue = 0;
+            for (let i = 0; i < numLengthBytes; i++) {
+                lengthValue = (lengthValue << 8) | keyBytes[modulusPosition + 2 + i];
+            }
+            lengthValue += 1;
+            for (let i = numLengthBytes - 1; i >= 0; i--) {
+                fixedKey[modulusPosition + 2 + i] = lengthValue & 0xff;
+                lengthValue >>= 8;
+            }
+        }
+        // 2. Fix inner SEQUENCE length field
+        if ((keyBytes[innerSequencePosition + 1] & 0x80) === 0) {
+            // Short form
+            fixedKey[innerSequencePosition + 1] = keyBytes[innerSequencePosition + 1] + 1;
+        }
+        else {
+            // Long form
+            const numLengthBytes = keyBytes[innerSequencePosition + 1] & 0x7f;
+            let lengthValue = 0;
+            for (let i = 0; i < numLengthBytes; i++) {
+                lengthValue = (lengthValue << 8) | keyBytes[innerSequencePosition + 2 + i];
+            }
+            lengthValue += 1;
+            for (let i = numLengthBytes - 1; i >= 0; i--) {
+                fixedKey[innerSequencePosition + 2 + i] = lengthValue & 0xff;
+                lengthValue >>= 8;
+            }
+        }
+        // 3. Fix BIT STRING length field
+        if ((keyBytes[bitStringPosition + 1] & 0x80) === 0) {
+            // Short form
+            fixedKey[bitStringPosition + 1] = keyBytes[bitStringPosition + 1] + 1;
+        }
+        else {
+            // Long form
+            const numLengthBytes = keyBytes[bitStringPosition + 1] & 0x7f;
+            let lengthValue = 0;
+            for (let i = 0; i < numLengthBytes; i++) {
+                lengthValue = (lengthValue << 8) | keyBytes[bitStringPosition + 2 + i];
+            }
+            lengthValue += 1;
+            for (let i = numLengthBytes - 1; i >= 0; i--) {
+                fixedKey[bitStringPosition + 2 + i] = lengthValue & 0xff;
+                lengthValue >>= 8;
+            }
+        }
+        // 4. Fix outer SEQUENCE length field
+        if ((keyBytes[1] & 0x80) === 0) {
+            // Short form
+            fixedKey[1] = keyBytes[1] + 1;
+        }
+        else {
+            // Long form
+            const numLengthBytes = keyBytes[1] & 0x7f;
+            let lengthValue = 0;
+            for (let i = 0; i < numLengthBytes; i++) {
+                lengthValue = (lengthValue << 8) | keyBytes[1 + 1 + i];
+            }
+            lengthValue += 1;
+            for (let i = numLengthBytes - 1; i >= 0; i--) {
+                fixedKey[1 + 1 + i] = lengthValue & 0xff;
+                lengthValue >>= 8;
+            }
+        }
+        log("Fixed key length: " + fixedKey.length);
+        return fixedKey.buffer;
+    }
+    return publicKeyData;
+}
+
+// src/core/revocation/types.ts
+/**
+ * Default options for revocation checking
+ */
+const DEFAULT_REVOCATION_OPTIONS = {
+    ocspEnabled: true,
+    crlEnabled: true,
+    ocspTimeout: 5000,
+    crlTimeout: 10000,
+};
+
+/*!
+ * MIT License
+ * 
+ * Copyright (c) 2017-2024 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.
+ * 
+ */
+
+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;
+    }
+}
+
+const STRING_TYPE = "string";
+const HEX_REGEX = /^[0-9a-f\s]+$/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;
+    }
+}
+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, "")) || "";
+    }
+}
+Convert.DEFAULT_UTF8_ENCODING = "utf8";
+
+/*!
+ Copyright (c) Peculiar Ventures, LLC
+*/
+function utilFromBase(inputBuffer, inputBase) {
+    let result = 0;
+    if (inputBuffer.length === 1) {
+        return inputBuffer[0];
+    }
+    for (let i = (inputBuffer.length - 1); i >= 0; i--) {
+        result += inputBuffer[(inputBuffer.length - 1) - i] * Math.pow(2, inputBase * i);
+    }
+    return result;
+}
+function utilToBase(value, base, reserved = (-1)) {
+    const internalReserved = reserved;
+    let internalValue = value;
+    let result = 0;
+    let biggest = Math.pow(2, base);
+    for (let i = 1; i < 8; i++) {
+        if (value < biggest) {
+            let retBuf;
+            if (internalReserved < 0) {
+                retBuf = new ArrayBuffer(i);
+                result = i;
+            }
+            else {
+                if (internalReserved < i) {
+                    return (new ArrayBuffer(0));
+                }
+                retBuf = new ArrayBuffer(internalReserved);
+                result = internalReserved;
+            }
+            const retView = new Uint8Array(retBuf);
+            for (let j = (i - 1); j >= 0; j--) {
+                const basis = Math.pow(2, j * base);
+                retView[result - j - 1] = Math.floor(internalValue / basis);
+                internalValue -= (retView[result - j - 1]) * basis;
+            }
+            return retBuf;
+        }
+        biggest *= Math.pow(2, base);
+    }
+    return new ArrayBuffer(0);
+}
+function utilConcatView(...views) {
+    let outputLength = 0;
+    let prevLength = 0;
+    for (const view of views) {
+        outputLength += view.length;
+    }
+    const retBuf = new ArrayBuffer(outputLength);
+    const retView = new Uint8Array(retBuf);
+    for (const view of views) {
+        retView.set(view, prevLength);
+        prevLength += view.length;
+    }
+    return retView;
+}
+function utilDecodeTC() {
+    const buf = new Uint8Array(this.valueHex);
+    if (this.valueHex.byteLength >= 2) {
+        const condition1 = (buf[0] === 0xFF) && (buf[1] & 0x80);
+        const condition2 = (buf[0] === 0x00) && ((buf[1] & 0x80) === 0x00);
+        if (condition1 || condition2) {
+            this.warnings.push("Needlessly long format");
+        }
+    }
+    const bigIntBuffer = new ArrayBuffer(this.valueHex.byteLength);
+    const bigIntView = new Uint8Array(bigIntBuffer);
+    for (let i = 0; i < this.valueHex.byteLength; i++) {
+        bigIntView[i] = 0;
+    }
+    bigIntView[0] = (buf[0] & 0x80);
+    const bigInt = utilFromBase(bigIntView, 8);
+    const smallIntBuffer = new ArrayBuffer(this.valueHex.byteLength);
+    const smallIntView = new Uint8Array(smallIntBuffer);
+    for (let j = 0; j < this.valueHex.byteLength; j++) {
+        smallIntView[j] = buf[j];
+    }
+    smallIntView[0] &= 0x7F;
+    const smallInt = utilFromBase(smallIntView, 8);
+    return (smallInt - bigInt);
+}
+function utilEncodeTC(value) {
+    const modValue = (value < 0) ? (value * (-1)) : value;
+    let bigInt = 128;
+    for (let i = 1; i < 8; i++) {
+        if (modValue <= bigInt) {
+            if (value < 0) {
+                const smallInt = bigInt - modValue;
+                const retBuf = utilToBase(smallInt, 8, i);
+                const retView = new Uint8Array(retBuf);
+                retView[0] |= 0x80;
+                return retBuf;
+            }
+            let retBuf = utilToBase(modValue, 8, i);
+            let retView = new Uint8Array(retBuf);
+            if (retView[0] & 0x80) {
+                const tempBuf = retBuf.slice(0);
+                const tempView = new Uint8Array(tempBuf);
+                retBuf = new ArrayBuffer(retBuf.byteLength + 1);
+                retView = new Uint8Array(retBuf);
+                for (let k = 0; k < tempBuf.byteLength; k++) {
+                    retView[k + 1] = tempView[k];
+                }
+                retView[0] = 0x00;
+            }
+            return retBuf;
+        }
+        bigInt *= Math.pow(2, 8);
+    }
+    return (new ArrayBuffer(0));
+}
+function isEqualBuffer(inputBuffer1, inputBuffer2) {
+    if (inputBuffer1.byteLength !== inputBuffer2.byteLength) {
+        return false;
+    }
+    const view1 = new Uint8Array(inputBuffer1);
+    const view2 = new Uint8Array(inputBuffer2);
+    for (let i = 0; i < view1.length; i++) {
+        if (view1[i] !== view2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function padNumber(inputNumber, fullLength) {
+    const str = inputNumber.toString(10);
+    if (fullLength < str.length) {
+        return "";
+    }
+    const dif = fullLength - str.length;
+    const padding = new Array(dif);
+    for (let i = 0; i < dif; i++) {
+        padding[i] = "0";
+    }
+    const paddingString = padding.join("");
+    return paddingString.concat(str);
+}
+
+/*!
+ * Copyright (c) 2014, GMO GlobalSign
+ * Copyright (c) 2015-2022, Peculiar Ventures
+ * All rights reserved.
+ * 
+ * Author 2014-2019, Yury Strozhevsky
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright notice, this
+ *   list of conditions and the following disclaimer in the documentation and/or
+ *   other materials provided with the distribution.
+ * 
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+function assertBigInt() {
+    if (typeof BigInt === "undefined") {
+        throw new Error("BigInt is not defined. Your environment doesn't implement BigInt.");
+    }
+}
+function concat(buffers) {
+    let outputLength = 0;
+    let prevLength = 0;
+    for (let i = 0; i < buffers.length; i++) {
+        const buffer = buffers[i];
+        outputLength += buffer.byteLength;
+    }
+    const retView = new Uint8Array(outputLength);
+    for (let i = 0; i < buffers.length; i++) {
+        const buffer = buffers[i];
+        retView.set(new Uint8Array(buffer), prevLength);
+        prevLength += buffer.byteLength;
+    }
+    return retView.buffer;
+}
+function checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength) {
+    if (!(inputBuffer instanceof Uint8Array)) {
+        baseBlock.error = "Wrong parameter: inputBuffer must be 'Uint8Array'";
+        return false;
+    }
+    if (!inputBuffer.byteLength) {
+        baseBlock.error = "Wrong parameter: inputBuffer has zero length";
+        return false;
+    }
+    if (inputOffset < 0) {
+        baseBlock.error = "Wrong parameter: inputOffset less than zero";
+        return false;
+    }
+    if (inputLength < 0) {
+        baseBlock.error = "Wrong parameter: inputLength less than zero";
+        return false;
+    }
+    if ((inputBuffer.byteLength - inputOffset - inputLength) < 0) {
+        baseBlock.error = "End of input reached before message was fully decoded (inconsistent offset and length values)";
+        return false;
+    }
+    return true;
+}
+
+class ViewWriter {
+    constructor() {
+        this.items = [];
+    }
+    write(buf) {
+        this.items.push(buf);
+    }
+    final() {
+        return concat(this.items);
+    }
+}
+
+const powers2 = [new Uint8Array([1])];
+const digitsString = "0123456789";
+const EMPTY_STRING = "";
+const EMPTY_BUFFER = new ArrayBuffer(0);
+const EMPTY_VIEW = new Uint8Array(0);
+const END_OF_CONTENT_NAME = "EndOfContent";
+const OCTET_STRING_NAME = "OCTET STRING";
+const BIT_STRING_NAME = "BIT STRING";
+
+function HexBlock(BaseClass) {
+    var _a;
+    return _a = class Some extends BaseClass {
+            get valueHex() {
+                return this.valueHexView.slice().buffer;
+            }
+            set valueHex(value) {
+                this.valueHexView = new Uint8Array(value);
+            }
+            constructor(...args) {
+                var _b;
+                super(...args);
+                const params = args[0] || {};
+                this.isHexOnly = (_b = params.isHexOnly) !== null && _b !== void 0 ? _b : false;
+                this.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
+            }
+            fromBER(inputBuffer, inputOffset, inputLength, _context) {
+                const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
+                if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+                    return -1;
+                }
+                const endLength = inputOffset + inputLength;
+                this.valueHexView = view.subarray(inputOffset, endLength);
+                if (!this.valueHexView.length) {
+                    this.warnings.push("Zero buffer length");
+                    return inputOffset;
+                }
+                this.blockLength = inputLength;
+                return endLength;
+            }
+            toBER(sizeOnly = false) {
+                if (!this.isHexOnly) {
+                    this.error = "Flag 'isHexOnly' is not set, abort";
+                    return EMPTY_BUFFER;
+                }
+                if (sizeOnly) {
+                    return new ArrayBuffer(this.valueHexView.byteLength);
+                }
+                return (this.valueHexView.byteLength === this.valueHexView.buffer.byteLength)
+                    ? this.valueHexView.buffer
+                    : this.valueHexView.slice().buffer;
+            }
+            toJSON() {
+                return {
+                    ...super.toJSON(),
+                    isHexOnly: this.isHexOnly,
+                    valueHex: Convert.ToHex(this.valueHexView),
+                };
+            }
+        },
+        _a.NAME = "hexBlock",
+        _a;
+}
+
+class LocalBaseBlock {
+    static blockName() {
+        return this.NAME;
+    }
+    get valueBeforeDecode() {
+        return this.valueBeforeDecodeView.slice().buffer;
+    }
+    set valueBeforeDecode(value) {
+        this.valueBeforeDecodeView = new Uint8Array(value);
+    }
+    constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW, } = {}) {
+        this.blockLength = blockLength;
+        this.error = error;
+        this.warnings = warnings;
+        this.valueBeforeDecodeView = BufferSourceConverter.toUint8Array(valueBeforeDecode);
+    }
+    toJSON() {
+        return {
+            blockName: this.constructor.NAME,
+            blockLength: this.blockLength,
+            error: this.error,
+            warnings: this.warnings,
+            valueBeforeDecode: Convert.ToHex(this.valueBeforeDecodeView),
+        };
+    }
+}
+LocalBaseBlock.NAME = "baseBlock";
+
+class ValueBlock extends LocalBaseBlock {
+    fromBER(_inputBuffer, _inputOffset, _inputLength, _context) {
+        throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
+    }
+    toBER(_sizeOnly, _writer) {
+        throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
+    }
+}
+ValueBlock.NAME = "valueBlock";
+
+class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
+    constructor({ idBlock = {} } = {}) {
+        var _a, _b, _c, _d;
+        super();
+        if (idBlock) {
+            this.isHexOnly = (_a = idBlock.isHexOnly) !== null && _a !== void 0 ? _a : false;
+            this.valueHexView = idBlock.valueHex
+                ? BufferSourceConverter.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;
+        }
+        else {
+            this.tagClass = -1;
+            this.tagNumber = -1;
+            this.isConstructed = false;
+        }
+    }
+    toBER(sizeOnly = false) {
+        let firstOctet = 0;
+        switch (this.tagClass) {
+            case 1:
+                firstOctet |= 0x00;
+                break;
+            case 2:
+                firstOctet |= 0x40;
+                break;
+            case 3:
+                firstOctet |= 0x80;
+                break;
+            case 4:
+                firstOctet |= 0xC0;
+                break;
+            default:
+                this.error = "Unknown tag class";
+                return EMPTY_BUFFER;
+        }
+        if (this.isConstructed)
+            firstOctet |= 0x20;
+        if (this.tagNumber < 31 && !this.isHexOnly) {
+            const retView = new Uint8Array(1);
+            if (!sizeOnly) {
+                let number = this.tagNumber;
+                number &= 0x1F;
+                firstOctet |= number;
+                retView[0] = firstOctet;
+            }
+            return retView.buffer;
+        }
+        if (!this.isHexOnly) {
+            const encodedBuf = utilToBase(this.tagNumber, 7);
+            const encodedView = new Uint8Array(encodedBuf);
+            const size = encodedBuf.byteLength;
+            const retView = new Uint8Array(size + 1);
+            retView[0] = (firstOctet | 0x1F);
+            if (!sizeOnly) {
+                for (let i = 0; i < (size - 1); i++)
+                    retView[i + 1] = encodedView[i] | 0x80;
+                retView[size] = encodedView[size - 1];
+            }
+            return retView.buffer;
+        }
+        const retView = new Uint8Array(this.valueHexView.byteLength + 1);
+        retView[0] = (firstOctet | 0x1F);
+        if (!sizeOnly) {
+            const curView = this.valueHexView;
+            for (let i = 0; i < (curView.length - 1); i++)
+                retView[i + 1] = curView[i] | 0x80;
+            retView[this.valueHexView.byteLength] = curView[curView.length - 1];
+        }
+        return retView.buffer;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
+        if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+            return -1;
+        }
+        const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+        if (intBuffer.length === 0) {
+            this.error = "Zero buffer length";
+            return -1;
+        }
+        const tagClassMask = intBuffer[0] & 0xC0;
+        switch (tagClassMask) {
+            case 0x00:
+                this.tagClass = (1);
+                break;
+            case 0x40:
+                this.tagClass = (2);
+                break;
+            case 0x80:
+                this.tagClass = (3);
+                break;
+            case 0xC0:
+                this.tagClass = (4);
+                break;
+            default:
+                this.error = "Unknown tag class";
+                return -1;
+        }
+        this.isConstructed = (intBuffer[0] & 0x20) === 0x20;
+        this.isHexOnly = false;
+        const tagNumberMask = intBuffer[0] & 0x1F;
+        if (tagNumberMask !== 0x1F) {
+            this.tagNumber = (tagNumberMask);
+            this.blockLength = 1;
+        }
+        else {
+            let count = 0;
+            while (true) {
+                const tagByteIndex = count + 1;
+                if (tagByteIndex >= intBuffer.length) {
+                    this.error = "End of input reached before message was fully decoded";
+                    return -1;
+                }
+                count++;
+                if ((intBuffer[tagByteIndex] & 0x80) === 0x00)
+                    break;
+            }
+            this.blockLength = (count + 1);
+            const intTagNumberBuffer = this.valueHexView = new Uint8Array(count);
+            for (let i = 0; i < count; i++)
+                intTagNumberBuffer[i] = intBuffer[i + 1] & 0x7F;
+            if (this.blockLength <= 9)
+                this.tagNumber = utilFromBase(intTagNumberBuffer, 7);
+            else {
+                this.isHexOnly = true;
+                this.warnings.push("Tag too long, represented as hex-coded");
+            }
+        }
+        if (((this.tagClass === 1))
+            && (this.isConstructed)) {
+            switch (this.tagNumber) {
+                case 1:
+                case 2:
+                case 5:
+                case 6:
+                case 9:
+                case 13:
+                case 14:
+                case 23:
+                case 24:
+                case 31:
+                case 32:
+                case 33:
+                case 34:
+                    this.error = "Constructed encoding used for primitive type";
+                    return -1;
+            }
+        }
+        return (inputOffset + this.blockLength);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            tagClass: this.tagClass,
+            tagNumber: this.tagNumber,
+            isConstructed: this.isConstructed,
+        };
+    }
+}
+LocalIdentificationBlock.NAME = "identificationBlock";
+
+class LocalLengthBlock extends LocalBaseBlock {
+    constructor({ lenBlock = {} } = {}) {
+        var _a, _b, _c;
+        super();
+        this.isIndefiniteForm = (_a = lenBlock.isIndefiniteForm) !== null && _a !== void 0 ? _a : false;
+        this.longFormUsed = (_b = lenBlock.longFormUsed) !== null && _b !== void 0 ? _b : false;
+        this.length = (_c = lenBlock.length) !== null && _c !== void 0 ? _c : 0;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        const view = BufferSourceConverter.toUint8Array(inputBuffer);
+        if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+            return -1;
+        }
+        const intBuffer = view.subarray(inputOffset, inputOffset + inputLength);
+        if (intBuffer.length === 0) {
+            this.error = "Zero buffer length";
+            return -1;
+        }
+        if (intBuffer[0] === 0xFF) {
+            this.error = "Length block 0xFF is reserved by standard";
+            return -1;
+        }
+        this.isIndefiniteForm = intBuffer[0] === 0x80;
+        if (this.isIndefiniteForm) {
+            this.blockLength = 1;
+            return (inputOffset + this.blockLength);
+        }
+        this.longFormUsed = !!(intBuffer[0] & 0x80);
+        if (this.longFormUsed === false) {
+            this.length = (intBuffer[0]);
+            this.blockLength = 1;
+            return (inputOffset + this.blockLength);
+        }
+        const count = intBuffer[0] & 0x7F;
+        if (count > 8) {
+            this.error = "Too big integer";
+            return -1;
+        }
+        if ((count + 1) > intBuffer.length) {
+            this.error = "End of input reached before message was fully decoded";
+            return -1;
+        }
+        const lenOffset = inputOffset + 1;
+        const lengthBufferView = view.subarray(lenOffset, lenOffset + count);
+        if (lengthBufferView[count - 1] === 0x00)
+            this.warnings.push("Needlessly long encoded length");
+        this.length = utilFromBase(lengthBufferView, 8);
+        if (this.longFormUsed && (this.length <= 127))
+            this.warnings.push("Unnecessary usage of long length form");
+        this.blockLength = count + 1;
+        return (inputOffset + this.blockLength);
+    }
+    toBER(sizeOnly = false) {
+        let retBuf;
+        let retView;
+        if (this.length > 127)
+            this.longFormUsed = true;
+        if (this.isIndefiniteForm) {
+            retBuf = new ArrayBuffer(1);
+            if (sizeOnly === false) {
+                retView = new Uint8Array(retBuf);
+                retView[0] = 0x80;
+            }
+            return retBuf;
+        }
+        if (this.longFormUsed) {
+            const encodedBuf = utilToBase(this.length, 8);
+            if (encodedBuf.byteLength > 127) {
+                this.error = "Too big length";
+                return (EMPTY_BUFFER);
+            }
+            retBuf = new ArrayBuffer(encodedBuf.byteLength + 1);
+            if (sizeOnly)
+                return retBuf;
+            const encodedView = new Uint8Array(encodedBuf);
+            retView = new Uint8Array(retBuf);
+            retView[0] = encodedBuf.byteLength | 0x80;
+            for (let i = 0; i < encodedBuf.byteLength; i++)
+                retView[i + 1] = encodedView[i];
+            return retBuf;
+        }
+        retBuf = new ArrayBuffer(1);
+        if (sizeOnly === false) {
+            retView = new Uint8Array(retBuf);
+            retView[0] = this.length;
+        }
+        return retBuf;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            isIndefiniteForm: this.isIndefiniteForm,
+            longFormUsed: this.longFormUsed,
+            length: this.length,
+        };
+    }
+}
+LocalLengthBlock.NAME = "lengthBlock";
+
+const typeStore = {};
+
+class BaseBlock extends LocalBaseBlock {
+    constructor({ name = EMPTY_STRING, optional = false, primitiveSchema, ...parameters } = {}, valueBlockType) {
+        super(parameters);
+        this.name = name;
+        this.optional = optional;
+        if (primitiveSchema) {
+            this.primitiveSchema = primitiveSchema;
+        }
+        this.idBlock = new LocalIdentificationBlock(parameters);
+        this.lenBlock = new LocalLengthBlock(parameters);
+        this.valueBlock = valueBlockType ? new valueBlockType(parameters) : new ValueBlock(parameters);
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm)
+            ? inputLength
+            : this.lenBlock.length, context);
+        if (resultOffset === -1) {
+            this.error = this.valueBlock.error;
+            return resultOffset;
+        }
+        if (!this.idBlock.error.length)
+            this.blockLength += this.idBlock.blockLength;
+        if (!this.lenBlock.error.length)
+            this.blockLength += this.lenBlock.blockLength;
+        if (!this.valueBlock.error.length)
+            this.blockLength += this.valueBlock.blockLength;
+        return resultOffset;
+    }
+    toBER(sizeOnly, writer) {
+        const _writer = writer || new ViewWriter();
+        if (!writer) {
+            prepareIndefiniteForm(this);
+        }
+        const idBlockBuf = this.idBlock.toBER(sizeOnly);
+        _writer.write(idBlockBuf);
+        if (this.lenBlock.isIndefiniteForm) {
+            _writer.write(new Uint8Array([0x80]).buffer);
+            this.valueBlock.toBER(sizeOnly, _writer);
+            _writer.write(new ArrayBuffer(2));
+        }
+        else {
+            const valueBlockBuf = this.valueBlock.toBER(sizeOnly);
+            this.lenBlock.length = valueBlockBuf.byteLength;
+            const lenBlockBuf = this.lenBlock.toBER(sizeOnly);
+            _writer.write(lenBlockBuf);
+            _writer.write(valueBlockBuf);
+        }
+        if (!writer) {
+            return _writer.final();
+        }
+        return EMPTY_BUFFER;
+    }
+    toJSON() {
+        const object = {
+            ...super.toJSON(),
+            idBlock: this.idBlock.toJSON(),
+            lenBlock: this.lenBlock.toJSON(),
+            valueBlock: this.valueBlock.toJSON(),
+            name: this.name,
+            optional: this.optional,
+        };
+        if (this.primitiveSchema)
+            object.primitiveSchema = this.primitiveSchema.toJSON();
+        return object;
+    }
+    toString(encoding = "ascii") {
+        if (encoding === "ascii") {
+            return this.onAsciiEncoding();
+        }
+        return Convert.ToHex(this.toBER());
+    }
+    onAsciiEncoding() {
+        const name = this.constructor.NAME;
+        const value = Convert.ToHex(this.valueBlock.valueBeforeDecodeView);
+        return `${name} : ${value}`;
+    }
+    isEqual(other) {
+        if (this === other) {
+            return true;
+        }
+        if (!(other instanceof this.constructor)) {
+            return false;
+        }
+        const thisRaw = this.toBER();
+        const otherRaw = other.toBER();
+        return isEqualBuffer(thisRaw, otherRaw);
+    }
+}
+BaseBlock.NAME = "BaseBlock";
+function prepareIndefiniteForm(baseBlock) {
+    var _a;
+    if (baseBlock instanceof typeStore.Constructed) {
+        for (const value of baseBlock.valueBlock.value) {
+            if (prepareIndefiniteForm(value)) {
+                baseBlock.lenBlock.isIndefiniteForm = true;
+            }
+        }
+    }
+    return !!((_a = baseBlock.lenBlock) === null || _a === void 0 ? void 0 : _a.isIndefiniteForm);
+}
+
+class BaseStringBlock extends BaseBlock {
+    getValue() {
+        return this.valueBlock.value;
+    }
+    setValue(value) {
+        this.valueBlock.value = value;
+    }
+    constructor({ value = EMPTY_STRING, ...parameters } = {}, stringValueBlockType) {
+        super(parameters, stringValueBlockType);
+        if (value) {
+            this.fromString(value);
+        }
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm)
+            ? inputLength
+            : this.lenBlock.length);
+        if (resultOffset === -1) {
+            this.error = this.valueBlock.error;
+            return resultOffset;
+        }
+        this.fromBuffer(this.valueBlock.valueHexView);
+        if (!this.idBlock.error.length)
+            this.blockLength += this.idBlock.blockLength;
+        if (!this.lenBlock.error.length)
+            this.blockLength += this.lenBlock.blockLength;
+        if (!this.valueBlock.error.length)
+            this.blockLength += this.valueBlock.blockLength;
+        return resultOffset;
+    }
+    onAsciiEncoding() {
+        return `${this.constructor.NAME} : '${this.valueBlock.value}'`;
+    }
+}
+BaseStringBlock.NAME = "BaseStringBlock";
+
+class LocalPrimitiveValueBlock extends HexBlock(ValueBlock) {
+    constructor({ isHexOnly = true, ...parameters } = {}) {
+        super(parameters);
+        this.isHexOnly = isHexOnly;
+    }
+}
+LocalPrimitiveValueBlock.NAME = "PrimitiveValueBlock";
+
+var _a$w;
+class Primitive extends BaseBlock {
+    constructor(parameters = {}) {
+        super(parameters, LocalPrimitiveValueBlock);
+        this.idBlock.isConstructed = false;
+    }
+}
+_a$w = Primitive;
+(() => {
+    typeStore.Primitive = _a$w;
+})();
+Primitive.NAME = "PRIMITIVE";
+
+const DEFAULT_MAX_DEPTH = 100;
+const DEFAULT_MAX_NODES = 10000;
+const DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024;
+const MAX_DEPTH_EXCEEDED_ERROR = "Maximum ASN.1 nesting depth exceeded";
+const MAX_NODES_EXCEEDED_ERROR = "Maximum ASN.1 node count exceeded";
+const MAX_CONTENT_LENGTH_EXCEEDED_ERROR = "Maximum ASN.1 content length exceeded";
+function createFromBerContext(options = {}) {
+    var _a, _b, _c;
+    return {
+        depth: 0,
+        maxDepth: (_a = options.maxDepth) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DEPTH,
+        nodesCount: 0,
+        maxNodes: (_b = options.maxNodes) !== null && _b !== void 0 ? _b : DEFAULT_MAX_NODES,
+        maxContentLength: (_c = options.maxContentLength) !== null && _c !== void 0 ? _c : DEFAULT_MAX_CONTENT_LENGTH,
+    };
+}
+function createErrorResult(error) {
+    const result = new BaseBlock({}, ValueBlock);
+    result.error = error;
+    return {
+        offset: -1,
+        result,
+    };
+}
+function checkNodesLimit(context) {
+    context.nodesCount += 1;
+    if (context.nodesCount > context.maxNodes) {
+        return MAX_NODES_EXCEEDED_ERROR;
+    }
+    return undefined;
+}
+function checkContentLengthLimit(inputLength, context) {
+    if (inputLength > context.maxContentLength) {
+        return MAX_CONTENT_LENGTH_EXCEEDED_ERROR;
+    }
+    return undefined;
+}
+function localFromBERWithChildContext(inputBuffer, inputOffset, inputLength, context) {
+    const childDepth = context.depth + 1;
+    if (childDepth > context.maxDepth) {
+        return createErrorResult(MAX_DEPTH_EXCEEDED_ERROR);
+    }
+    context.depth = childDepth;
+    try {
+        return localFromBER(inputBuffer, inputOffset, inputLength, context);
+    }
+    finally {
+        context.depth -= 1;
+    }
+}
+function localChangeType(inputObject, newType) {
+    if (inputObject instanceof newType) {
+        return inputObject;
+    }
+    const newObject = new newType();
+    newObject.idBlock = inputObject.idBlock;
+    newObject.lenBlock = inputObject.lenBlock;
+    newObject.warnings = inputObject.warnings;
+    newObject.valueBeforeDecodeView = inputObject.valueBeforeDecodeView;
+    return newObject;
+}
+function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.length, context = createFromBerContext()) {
+    const incomingOffset = inputOffset;
+    let returnObject = new BaseBlock({}, ValueBlock);
+    const baseBlock = new LocalBaseBlock();
+    if (!checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength)) {
+        returnObject.error = baseBlock.error;
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    const intBuffer = inputBuffer.subarray(inputOffset, inputOffset + inputLength);
+    if (!intBuffer.length) {
+        returnObject.error = "Zero buffer length";
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    const nodesLimitError = checkNodesLimit(context);
+    if (nodesLimitError) {
+        returnObject.error = nodesLimitError;
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    let resultOffset = returnObject.idBlock.fromBER(inputBuffer, inputOffset, inputLength);
+    if (returnObject.idBlock.warnings.length) {
+        returnObject.warnings.concat(returnObject.idBlock.warnings);
+    }
+    if (resultOffset === -1) {
+        returnObject.error = returnObject.idBlock.error;
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    inputOffset = resultOffset;
+    inputLength -= returnObject.idBlock.blockLength;
+    resultOffset = returnObject.lenBlock.fromBER(inputBuffer, inputOffset, inputLength);
+    if (returnObject.lenBlock.warnings.length) {
+        returnObject.warnings.concat(returnObject.lenBlock.warnings);
+    }
+    if (resultOffset === -1) {
+        returnObject.error = returnObject.lenBlock.error;
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    inputOffset = resultOffset;
+    inputLength -= returnObject.lenBlock.blockLength;
+    const valueLength = returnObject.lenBlock.isIndefiniteForm ? inputLength : returnObject.lenBlock.length;
+    const contentLengthError = checkContentLengthLimit(valueLength, context);
+    if (contentLengthError) {
+        returnObject.error = contentLengthError;
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    if (!returnObject.idBlock.isConstructed
+        && returnObject.lenBlock.isIndefiniteForm) {
+        returnObject.error = "Indefinite length form used for primitive encoding form";
+        return {
+            offset: -1,
+            result: returnObject,
+        };
+    }
+    let newASN1Type = BaseBlock;
+    switch (returnObject.idBlock.tagClass) {
+        case 1:
+            if ((returnObject.idBlock.tagNumber >= 37)
+                && (returnObject.idBlock.isHexOnly === false)) {
+                returnObject.error = "UNIVERSAL 37 and upper tags are reserved by ASN.1 standard";
+                return {
+                    offset: -1,
+                    result: returnObject,
+                };
+            }
+            switch (returnObject.idBlock.tagNumber) {
+                case 0:
+                    if ((returnObject.idBlock.isConstructed)
+                        && (returnObject.lenBlock.length > 0)) {
+                        returnObject.error = "Type [UNIVERSAL 0] is reserved";
+                        return {
+                            offset: -1,
+                            result: returnObject,
+                        };
+                    }
+                    newASN1Type = typeStore.EndOfContent;
+                    break;
+                case 1:
+                    newASN1Type = typeStore.Boolean;
+                    break;
+                case 2:
+                    newASN1Type = typeStore.Integer;
+                    break;
+                case 3:
+                    newASN1Type = typeStore.BitString;
+                    break;
+                case 4:
+                    newASN1Type = typeStore.OctetString;
+                    break;
+                case 5:
+                    newASN1Type = typeStore.Null;
+                    break;
+                case 6:
+                    newASN1Type = typeStore.ObjectIdentifier;
+                    break;
+                case 10:
+                    newASN1Type = typeStore.Enumerated;
+                    break;
+                case 12:
+                    newASN1Type = typeStore.Utf8String;
+                    break;
+                case 13:
+                    newASN1Type = typeStore.RelativeObjectIdentifier;
+                    break;
+                case 14:
+                    newASN1Type = typeStore.TIME;
+                    break;
+                case 15:
+                    returnObject.error = "[UNIVERSAL 15] is reserved by ASN.1 standard";
+                    return {
+                        offset: -1,
+                        result: returnObject,
+                    };
+                case 16:
+                    newASN1Type = typeStore.Sequence;
+                    break;
+                case 17:
+                    newASN1Type = typeStore.Set;
+                    break;
+                case 18:
+                    newASN1Type = typeStore.NumericString;
+                    break;
+                case 19:
+                    newASN1Type = typeStore.PrintableString;
+                    break;
+                case 20:
+                    newASN1Type = typeStore.TeletexString;
+                    break;
+                case 21:
+                    newASN1Type = typeStore.VideotexString;
+                    break;
+                case 22:
+                    newASN1Type = typeStore.IA5String;
+                    break;
+                case 23:
+                    newASN1Type = typeStore.UTCTime;
+                    break;
+                case 24:
+                    newASN1Type = typeStore.GeneralizedTime;
+                    break;
+                case 25:
+                    newASN1Type = typeStore.GraphicString;
+                    break;
+                case 26:
+                    newASN1Type = typeStore.VisibleString;
+                    break;
+                case 27:
+                    newASN1Type = typeStore.GeneralString;
+                    break;
+                case 28:
+                    newASN1Type = typeStore.UniversalString;
+                    break;
+                case 29:
+                    newASN1Type = typeStore.CharacterString;
+                    break;
+                case 30:
+                    newASN1Type = typeStore.BmpString;
+                    break;
+                case 31:
+                    newASN1Type = typeStore.DATE;
+                    break;
+                case 32:
+                    newASN1Type = typeStore.TimeOfDay;
+                    break;
+                case 33:
+                    newASN1Type = typeStore.DateTime;
+                    break;
+                case 34:
+                    newASN1Type = typeStore.Duration;
+                    break;
+                default: {
+                    const newObject = returnObject.idBlock.isConstructed
+                        ? new typeStore.Constructed()
+                        : new typeStore.Primitive();
+                    newObject.idBlock = returnObject.idBlock;
+                    newObject.lenBlock = returnObject.lenBlock;
+                    newObject.warnings = returnObject.warnings;
+                    returnObject = newObject;
+                }
+            }
+            break;
+        case 2:
+        case 3:
+        case 4:
+        default: {
+            newASN1Type = returnObject.idBlock.isConstructed
+                ? typeStore.Constructed
+                : typeStore.Primitive;
+        }
+    }
+    returnObject = localChangeType(returnObject, newASN1Type);
+    resultOffset = returnObject.fromBER(inputBuffer, inputOffset, valueLength, context);
+    returnObject.valueBeforeDecodeView = inputBuffer.subarray(incomingOffset, incomingOffset + returnObject.blockLength);
+    return {
+        offset: resultOffset,
+        result: returnObject,
+    };
+}
+function fromBER(inputBuffer, options = {}) {
+    if (!inputBuffer.byteLength) {
+        const result = new BaseBlock({}, ValueBlock);
+        result.error = "Input buffer has zero length";
+        return {
+            offset: -1,
+            result,
+        };
+    }
+    return localFromBER(BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength, createFromBerContext(options));
+}
+
+function checkLen(indefiniteLength, length) {
+    if (indefiniteLength) {
+        return 1;
+    }
+    return length;
+}
+class LocalConstructedValueBlock extends ValueBlock {
+    constructor({ value = [], isIndefiniteForm = false, ...parameters } = {}) {
+        super(parameters);
+        this.value = value;
+        this.isIndefiniteForm = isIndefiniteForm;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        const view = BufferSourceConverter.toUint8Array(inputBuffer);
+        const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
+        if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+            return -1;
+        }
+        this.valueBeforeDecodeView = view.subarray(inputOffset, inputOffset + inputLength);
+        if (this.valueBeforeDecodeView.length === 0) {
+            this.warnings.push("Zero buffer length");
+            return inputOffset;
+        }
+        let currentOffset = inputOffset;
+        while (checkLen(this.isIndefiniteForm, inputLength) > 0) {
+            const returnObject = localFromBERWithChildContext(view, currentOffset, inputLength, parseContext);
+            if (returnObject.offset === -1) {
+                this.error = returnObject.result.error;
+                this.warnings.concat(returnObject.result.warnings);
+                return -1;
+            }
+            currentOffset = returnObject.offset;
+            this.blockLength += returnObject.result.blockLength;
+            inputLength -= returnObject.result.blockLength;
+            this.value.push(returnObject.result);
+            if (this.isIndefiniteForm && returnObject.result.constructor.NAME === END_OF_CONTENT_NAME) {
+                break;
+            }
+        }
+        if (this.isIndefiniteForm) {
+            if (this.value[this.value.length - 1].constructor.NAME === END_OF_CONTENT_NAME) {
+                this.value.pop();
+            }
+            else {
+                this.warnings.push("No EndOfContent block encoded");
+            }
+        }
+        return currentOffset;
+    }
+    toBER(sizeOnly, writer) {
+        const _writer = writer || new ViewWriter();
+        for (let i = 0; i < this.value.length; i++) {
+            this.value[i].toBER(sizeOnly, _writer);
+        }
+        if (!writer) {
+            return _writer.final();
+        }
+        return EMPTY_BUFFER;
+    }
+    toJSON() {
+        const object = {
+            ...super.toJSON(),
+            isIndefiniteForm: this.isIndefiniteForm,
+            value: [],
+        };
+        for (const value of this.value) {
+            object.value.push(value.toJSON());
+        }
+        return object;
+    }
+}
+LocalConstructedValueBlock.NAME = "ConstructedValueBlock";
+
+var _a$v;
+class Constructed extends BaseBlock {
+    constructor(parameters = {}) {
+        super(parameters, LocalConstructedValueBlock);
+        this.idBlock.isConstructed = true;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm) ? inputLength : this.lenBlock.length, context);
+        if (resultOffset === -1) {
+            this.error = this.valueBlock.error;
+            return resultOffset;
+        }
+        if (!this.idBlock.error.length)
+            this.blockLength += this.idBlock.blockLength;
+        if (!this.lenBlock.error.length)
+            this.blockLength += this.lenBlock.blockLength;
+        if (!this.valueBlock.error.length)
+            this.blockLength += this.valueBlock.blockLength;
+        return resultOffset;
+    }
+    onAsciiEncoding() {
+        const values = [];
+        for (const value of this.valueBlock.value) {
+            values.push(value.toString("ascii").split("\n").map((o) => `  ${o}`).join("\n"));
+        }
+        const blockName = this.idBlock.tagClass === 3
+            ? `[${this.idBlock.tagNumber}]`
+            : this.constructor.NAME;
+        return values.length
+            ? `${blockName} :\n${values.join("\n")}`
+            : `${blockName} :`;
+    }
+}
+_a$v = Constructed;
+(() => {
+    typeStore.Constructed = _a$v;
+})();
+Constructed.NAME = "CONSTRUCTED";
+
+class LocalEndOfContentValueBlock extends ValueBlock {
+    fromBER(inputBuffer, inputOffset, _inputLength) {
+        return inputOffset;
+    }
+    toBER(_sizeOnly) {
+        return EMPTY_BUFFER;
+    }
+}
+LocalEndOfContentValueBlock.override = "EndOfContentValueBlock";
+
+var _a$u;
+class EndOfContent extends BaseBlock {
+    constructor(parameters = {}) {
+        super(parameters, LocalEndOfContentValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 0;
+    }
+}
+_a$u = EndOfContent;
+(() => {
+    typeStore.EndOfContent = _a$u;
+})();
+EndOfContent.NAME = END_OF_CONTENT_NAME;
+
+var _a$t;
+class Null extends BaseBlock {
+    constructor(parameters = {}) {
+        super(parameters, ValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 5;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        if (this.lenBlock.length > 0)
+            this.warnings.push("Non-zero length of value block for Null type");
+        if (!this.idBlock.error.length)
+            this.blockLength += this.idBlock.blockLength;
+        if (!this.lenBlock.error.length)
+            this.blockLength += this.lenBlock.blockLength;
+        this.blockLength += inputLength;
+        if ((inputOffset + inputLength) > inputBuffer.byteLength) {
+            this.error = "End of input reached before message was fully decoded (inconsistent offset and length values)";
+            return -1;
+        }
+        return (inputOffset + inputLength);
+    }
+    toBER(sizeOnly, writer) {
+        const retBuf = new ArrayBuffer(2);
+        if (!sizeOnly) {
+            const retView = new Uint8Array(retBuf);
+            retView[0] = 0x05;
+            retView[1] = 0x00;
+        }
+        if (writer) {
+            writer.write(retBuf);
+        }
+        return retBuf;
+    }
+    onAsciiEncoding() {
+        return `${this.constructor.NAME}`;
+    }
+}
+_a$t = Null;
+(() => {
+    typeStore.Null = _a$t;
+})();
+Null.NAME = "NULL";
+
+class LocalBooleanValueBlock extends HexBlock(ValueBlock) {
+    get value() {
+        for (const octet of this.valueHexView) {
+            if (octet > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    set value(value) {
+        this.valueHexView[0] = value ? 0xFF : 0x00;
+    }
+    constructor({ value, ...parameters } = {}) {
+        super(parameters);
+        if (parameters.valueHex) {
+            this.valueHexView = BufferSourceConverter.toUint8Array(parameters.valueHex);
+        }
+        else {
+            this.valueHexView = new Uint8Array(1);
+        }
+        if (value) {
+            this.value = value;
+        }
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
+        if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+            return -1;
+        }
+        this.valueHexView = inputView.subarray(inputOffset, inputOffset + inputLength);
+        if (inputLength > 1)
+            this.warnings.push("Boolean value encoded in more then 1 octet");
+        this.isHexOnly = true;
+        utilDecodeTC.call(this);
+        this.blockLength = inputLength;
+        return (inputOffset + inputLength);
+    }
+    toBER() {
+        return this.valueHexView.slice();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            value: this.value,
+        };
+    }
+}
+LocalBooleanValueBlock.NAME = "BooleanValueBlock";
+
+var _a$s;
+class Boolean$1 extends BaseBlock {
+    getValue() {
+        return this.valueBlock.value;
+    }
+    setValue(value) {
+        this.valueBlock.value = value;
+    }
+    constructor(parameters = {}) {
+        super(parameters, LocalBooleanValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 1;
+    }
+    onAsciiEncoding() {
+        return `${this.constructor.NAME} : ${this.getValue}`;
+    }
+}
+_a$s = Boolean$1;
+(() => {
+    typeStore.Boolean = _a$s;
+})();
+Boolean$1.NAME = "BOOLEAN";
+
+class LocalOctetStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
+    constructor({ isConstructed = false, ...parameters } = {}) {
+        super(parameters);
+        this.isConstructed = isConstructed;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        let resultOffset = 0;
+        if (this.isConstructed) {
+            this.isHexOnly = false;
+            resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength, context);
+            if (resultOffset === -1)
+                return resultOffset;
+            for (let i = 0; i < this.value.length; i++) {
+                const currentBlockName = this.value[i].constructor.NAME;
+                if (currentBlockName === END_OF_CONTENT_NAME) {
+                    if (this.isIndefiniteForm)
+                        break;
+                    else {
+                        this.error = "EndOfContent is unexpected, OCTET STRING may consists of OCTET STRINGs only";
+                        return -1;
+                    }
+                }
+                if (currentBlockName !== OCTET_STRING_NAME) {
+                    this.error = "OCTET STRING may consists of OCTET STRINGs only";
+                    return -1;
+                }
+            }
+        }
+        else {
+            this.isHexOnly = true;
+            resultOffset = super.fromBER(inputBuffer, inputOffset, inputLength);
+            this.blockLength = inputLength;
+        }
+        return resultOffset;
+    }
+    toBER(sizeOnly, writer) {
+        if (this.isConstructed)
+            return LocalConstructedValueBlock.prototype.toBER.call(this, sizeOnly, writer);
+        return sizeOnly
+            ? new ArrayBuffer(this.valueHexView.byteLength)
+            : this.valueHexView.slice().buffer;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            isConstructed: this.isConstructed,
+        };
+    }
+}
+LocalOctetStringValueBlock.NAME = "OctetStringValueBlock";
+
+var _a$r;
+class OctetString extends BaseBlock {
+    constructor({ idBlock = {}, lenBlock = {}, ...parameters } = {}) {
+        var _b, _c;
+        (_b = parameters.isConstructed) !== null && _b !== void 0 ? _b : (parameters.isConstructed = !!((_c = parameters.value) === null || _c === void 0 ? void 0 : _c.length));
+        super({
+            idBlock: {
+                isConstructed: parameters.isConstructed,
+                ...idBlock,
+            },
+            lenBlock: {
+                ...lenBlock,
+                isIndefiniteForm: !!parameters.isIndefiniteForm,
+            },
+            ...parameters,
+        }, LocalOctetStringValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 4;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        this.valueBlock.isConstructed = this.idBlock.isConstructed;
+        this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
+        if (inputLength === 0) {
+            if (this.idBlock.error.length === 0)
+                this.blockLength += this.idBlock.blockLength;
+            if (this.lenBlock.error.length === 0)
+                this.blockLength += this.lenBlock.blockLength;
+            return inputOffset;
+        }
+        if (!this.valueBlock.isConstructed) {
+            const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
+            const buf = view.subarray(inputOffset, inputOffset + inputLength);
+            try {
+                if (buf.byteLength) {
+                    const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
+                    const asn = localFromBERWithChildContext(buf, 0, buf.byteLength, parseContext);
+                    if (asn.offset !== -1 && asn.offset === inputLength) {
+                        this.valueBlock.value = [asn.result];
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        return super.fromBER(inputBuffer, inputOffset, inputLength, context);
+    }
+    onAsciiEncoding() {
+        if (this.valueBlock.isConstructed || (this.valueBlock.value && this.valueBlock.value.length)) {
+            return Constructed.prototype.onAsciiEncoding.call(this);
+        }
+        const name = this.constructor.NAME;
+        const value = Convert.ToHex(this.valueBlock.valueHexView);
+        return `${name} : ${value}`;
+    }
+    getValue() {
+        if (!this.idBlock.isConstructed) {
+            return this.valueBlock.valueHexView.slice().buffer;
+        }
+        const array = [];
+        for (const content of this.valueBlock.value) {
+            if (content instanceof _a$r) {
+                array.push(content.valueBlock.valueHexView);
+            }
+        }
+        return BufferSourceConverter.concat(array);
+    }
+}
+_a$r = OctetString;
+(() => {
+    typeStore.OctetString = _a$r;
+})();
+OctetString.NAME = OCTET_STRING_NAME;
+
+class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
+    constructor({ unusedBits = 0, isConstructed = false, ...parameters } = {}) {
+        super(parameters);
+        this.unusedBits = unusedBits;
+        this.isConstructed = isConstructed;
+        this.blockLength = this.valueHexView.byteLength;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        if (!inputLength) {
+            return inputOffset;
+        }
+        let resultOffset = -1;
+        if (this.isConstructed) {
+            resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength, context);
+            if (resultOffset === -1)
+                return resultOffset;
+            for (const value of this.value) {
+                const currentBlockName = value.constructor.NAME;
+                if (currentBlockName === END_OF_CONTENT_NAME) {
+                    if (this.isIndefiniteForm)
+                        break;
+                    else {
+                        this.error = "EndOfContent is unexpected, BIT STRING may consists of BIT STRINGs only";
+                        return -1;
+                    }
+                }
+                if (currentBlockName !== BIT_STRING_NAME) {
+                    this.error = "BIT STRING may consists of BIT STRINGs only";
+                    return -1;
+                }
+                const valueBlock = value.valueBlock;
+                if ((this.unusedBits > 0) && (valueBlock.unusedBits > 0)) {
+                    this.error = "Using of \"unused bits\" inside constructive BIT STRING allowed for least one only";
+                    return -1;
+                }
+                this.unusedBits = valueBlock.unusedBits;
+            }
+            return resultOffset;
+        }
+        const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
+        if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+            return -1;
+        }
+        const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+        this.unusedBits = intBuffer[0];
+        if (this.unusedBits > 7) {
+            this.error = "Unused bits for BitString must be in range 0-7";
+            return -1;
+        }
+        if (!this.unusedBits) {
+            const buf = intBuffer.subarray(1);
+            try {
+                if (buf.byteLength) {
+                    const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
+                    const asn = localFromBERWithChildContext(buf, 0, buf.byteLength, parseContext);
+                    if (asn.offset !== -1 && asn.offset === (inputLength - 1)) {
+                        this.value = [asn.result];
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        this.valueHexView = intBuffer.subarray(1);
+        this.blockLength = intBuffer.length;
+        return (inputOffset + inputLength);
+    }
+    toBER(sizeOnly, writer) {
+        if (this.isConstructed) {
+            return LocalConstructedValueBlock.prototype.toBER.call(this, sizeOnly, writer);
+        }
+        if (sizeOnly) {
+            return new ArrayBuffer(this.valueHexView.byteLength + 1);
+        }
+        if (!this.valueHexView.byteLength) {
+            const empty = new Uint8Array(1);
+            empty[0] = 0;
+            return empty.buffer;
+        }
+        const retView = new Uint8Array(this.valueHexView.length + 1);
+        retView[0] = this.unusedBits;
+        retView.set(this.valueHexView, 1);
+        return retView.buffer;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            unusedBits: this.unusedBits,
+            isConstructed: this.isConstructed,
+        };
+    }
+}
+LocalBitStringValueBlock.NAME = "BitStringValueBlock";
+
+var _a$q;
+class BitString extends BaseBlock {
+    constructor({ idBlock = {}, lenBlock = {}, ...parameters } = {}) {
+        var _b, _c;
+        (_b = parameters.isConstructed) !== null && _b !== void 0 ? _b : (parameters.isConstructed = !!((_c = parameters.value) === null || _c === void 0 ? void 0 : _c.length));
+        super({
+            idBlock: {
+                isConstructed: parameters.isConstructed,
+                ...idBlock,
+            },
+            lenBlock: {
+                ...lenBlock,
+                isIndefiniteForm: !!parameters.isIndefiniteForm,
+            },
+            ...parameters,
+        }, LocalBitStringValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 3;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength, context) {
+        this.valueBlock.isConstructed = this.idBlock.isConstructed;
+        this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
+        return super.fromBER(inputBuffer, inputOffset, inputLength, context);
+    }
+    onAsciiEncoding() {
+        if (this.valueBlock.isConstructed || (this.valueBlock.value && this.valueBlock.value.length)) {
+            return Constructed.prototype.onAsciiEncoding.call(this);
+        }
+        else {
+            const bits = [];
+            const valueHex = this.valueBlock.valueHexView;
+            for (const byte of valueHex) {
+                bits.push(byte.toString(2).padStart(8, "0"));
+            }
+            const bitsStr = bits.join("");
+            const name = this.constructor.NAME;
+            const value = bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits);
+            return `${name} : ${value}`;
+        }
+    }
+}
+_a$q = BitString;
+(() => {
+    typeStore.BitString = _a$q;
+})();
+BitString.NAME = BIT_STRING_NAME;
+
+var _a$p;
+function viewAdd(first, second) {
+    const c = new Uint8Array([0]);
+    const firstView = new Uint8Array(first);
+    const secondView = new Uint8Array(second);
+    let firstViewCopy = firstView.slice(0);
+    const firstViewCopyLength = firstViewCopy.length - 1;
+    const secondViewCopy = secondView.slice(0);
+    const secondViewCopyLength = secondViewCopy.length - 1;
+    let value = 0;
+    const max = (secondViewCopyLength < firstViewCopyLength) ? firstViewCopyLength : secondViewCopyLength;
+    let counter = 0;
+    for (let i = max; i >= 0; i--, counter++) {
+        switch (true) {
+            case (counter < secondViewCopy.length):
+                value = firstViewCopy[firstViewCopyLength - counter] + secondViewCopy[secondViewCopyLength - counter] + c[0];
+                break;
+            default:
+                value = firstViewCopy[firstViewCopyLength - counter] + c[0];
+        }
+        c[0] = value / 10;
+        switch (true) {
+            case (counter >= firstViewCopy.length):
+                firstViewCopy = utilConcatView(new Uint8Array([value % 10]), firstViewCopy);
+                break;
+            default:
+                firstViewCopy[firstViewCopyLength - counter] = value % 10;
+        }
+    }
+    if (c[0] > 0)
+        firstViewCopy = utilConcatView(c, firstViewCopy);
+    return firstViewCopy;
+}
+function power2(n) {
+    if (n >= powers2.length) {
+        for (let p = powers2.length; p <= n; p++) {
+            const c = new Uint8Array([0]);
+            let digits = (powers2[p - 1]).slice(0);
+            for (let i = (digits.length - 1); i >= 0; i--) {
+                const newValue = new Uint8Array([(digits[i] << 1) + c[0]]);
+                c[0] = newValue[0] / 10;
+                digits[i] = newValue[0] % 10;
+            }
+            if (c[0] > 0)
+                digits = utilConcatView(c, digits);
+            powers2.push(digits);
+        }
+    }
+    return powers2[n];
+}
+function viewSub(first, second) {
+    let b = 0;
+    const firstView = new Uint8Array(first);
+    const secondView = new Uint8Array(second);
+    const firstViewCopy = firstView.slice(0);
+    const firstViewCopyLength = firstViewCopy.length - 1;
+    const secondViewCopy = secondView.slice(0);
+    const secondViewCopyLength = secondViewCopy.length - 1;
+    let value;
+    let counter = 0;
+    for (let i = secondViewCopyLength; i >= 0; i--, counter++) {
+        value = firstViewCopy[firstViewCopyLength - counter] - secondViewCopy[secondViewCopyLength - counter] - b;
+        switch (true) {
+            case (value < 0):
+                b = 1;
+                firstViewCopy[firstViewCopyLength - counter] = value + 10;
+                break;
+            default:
+                b = 0;
+                firstViewCopy[firstViewCopyLength - counter] = value;
+        }
+    }
+    if (b > 0) {
+        for (let i = (firstViewCopyLength - secondViewCopyLength + 1); i >= 0; i--, counter++) {
+            value = firstViewCopy[firstViewCopyLength - counter] - b;
+            if (value < 0) {
+                b = 1;
+                firstViewCopy[firstViewCopyLength - counter] = value + 10;
+            }
+            else {
+                b = 0;
+                firstViewCopy[firstViewCopyLength - counter] = value;
+                break;
+            }
+        }
+    }
+    return firstViewCopy.slice();
+}
+class LocalIntegerValueBlock extends HexBlock(ValueBlock) {
+    setValueHex() {
+        if (this.valueHexView.length >= 4) {
+            this.warnings.push("Too big Integer for decoding, hex only");
+            this.isHexOnly = true;
+            this._valueDec = 0;
+        }
+        else {
+            this.isHexOnly = false;
+            if (this.valueHexView.length > 0) {
+                this._valueDec = utilDecodeTC.call(this);
+            }
+        }
+    }
+    constructor({ value, ...parameters } = {}) {
+        super(parameters);
+        this._valueDec = 0;
+        if (parameters.valueHex) {
+            this.setValueHex();
+        }
+        if (value !== undefined) {
+            this.valueDec = value;
+        }
+    }
+    set valueDec(v) {
+        this._valueDec = v;
+        this.isHexOnly = false;
+        this.valueHexView = new Uint8Array(utilEncodeTC(v));
+    }
+    get valueDec() {
+        return this._valueDec;
+    }
+    fromDER(inputBuffer, inputOffset, inputLength, expectedLength = 0) {
+        const offset = this.fromBER(inputBuffer, inputOffset, inputLength);
+        if (offset === -1)
+            return offset;
+        const view = this.valueHexView;
+        if ((view[0] === 0x00) && ((view[1] & 0x80) !== 0)) {
+            this.valueHexView = view.subarray(1);
+        }
+        else {
+            if (expectedLength !== 0) {
+                if (view.length < expectedLength) {
+                    if ((expectedLength - view.length) > 1)
+                        expectedLength = view.length + 1;
+                    this.valueHexView = view.subarray(expectedLength - view.length);
+                }
+            }
+        }
+        return offset;
+    }
+    toDER(sizeOnly = false) {
+        const view = this.valueHexView;
+        switch (true) {
+            case ((view[0] & 0x80) !== 0):
+                {
+                    const updatedView = new Uint8Array(this.valueHexView.length + 1);
+                    updatedView[0] = 0x00;
+                    updatedView.set(view, 1);
+                    this.valueHexView = updatedView;
+                }
+                break;
+            case ((view[0] === 0x00) && ((view[1] & 0x80) === 0)):
+                {
+                    this.valueHexView = this.valueHexView.subarray(1);
+                }
+                break;
+        }
+        return this.toBER(sizeOnly);
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        const resultOffset = super.fromBER(inputBuffer, inputOffset, inputLength);
+        if (resultOffset === -1) {
+            return resultOffset;
+        }
+        this.setValueHex();
+        return resultOffset;
+    }
+    toBER(sizeOnly) {
+        return sizeOnly
+            ? new ArrayBuffer(this.valueHexView.length)
+            : this.valueHexView.slice().buffer;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            valueDec: this.valueDec,
+        };
+    }
+    toString() {
+        const firstBit = (this.valueHexView.length * 8) - 1;
+        let digits = new Uint8Array((this.valueHexView.length * 8) / 3);
+        let bitNumber = 0;
+        let currentByte;
+        const asn1View = this.valueHexView;
+        let result = "";
+        let flag = false;
+        for (let byteNumber = (asn1View.byteLength - 1); byteNumber >= 0; byteNumber--) {
+            currentByte = asn1View[byteNumber];
+            for (let i = 0; i < 8; i++) {
+                if ((currentByte & 1) === 1) {
+                    switch (bitNumber) {
+                        case firstBit:
+                            digits = viewSub(power2(bitNumber), digits);
+                            result = "-";
+                            break;
+                        default:
+                            digits = viewAdd(digits, power2(bitNumber));
+                    }
+                }
+                bitNumber++;
+                currentByte >>= 1;
+            }
+        }
+        for (let i = 0; i < digits.length; i++) {
+            if (digits[i])
+                flag = true;
+            if (flag)
+                result += digitsString.charAt(digits[i]);
+        }
+        if (flag === false)
+            result += digitsString.charAt(0);
+        return result;
+    }
+}
+_a$p = LocalIntegerValueBlock;
+LocalIntegerValueBlock.NAME = "IntegerValueBlock";
+(() => {
+    Object.defineProperty(_a$p.prototype, "valueHex", {
+        set: function (v) {
+            this.valueHexView = new Uint8Array(v);
+            this.setValueHex();
+        },
+        get: function () {
+            return this.valueHexView.slice().buffer;
+        },
+    });
+})();
+
+var _a$o;
+class Integer extends BaseBlock {
+    constructor(parameters = {}) {
+        super(parameters, LocalIntegerValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 2;
+    }
+    toBigInt() {
+        assertBigInt();
+        return BigInt(this.valueBlock.toString());
+    }
+    static fromBigInt(value) {
+        assertBigInt();
+        const bigIntValue = BigInt(value);
+        const writer = new ViewWriter();
+        const hex = bigIntValue.toString(16).replace(/^-/, "");
+        const view = new Uint8Array(Convert.FromHex(hex));
+        if (bigIntValue < 0) {
+            const first = new Uint8Array(view.length + (view[0] & 0x80 ? 1 : 0));
+            first[0] |= 0x80;
+            const firstInt = BigInt(`0x${Convert.ToHex(first)}`);
+            const secondInt = firstInt + bigIntValue;
+            const second = BufferSourceConverter.toUint8Array(Convert.FromHex(secondInt.toString(16)));
+            second[0] |= 0x80;
+            writer.write(second);
+        }
+        else {
+            if (view[0] & 0x80) {
+                writer.write(new Uint8Array([0]));
+            }
+            writer.write(view);
+        }
+        const res = new _a$o({ valueHex: writer.final() });
+        return res;
+    }
+    convertToDER() {
+        const integer = new _a$o({ valueHex: this.valueBlock.valueHexView });
+        integer.valueBlock.toDER();
+        return integer;
+    }
+    convertFromDER() {
+        return new _a$o({
+            valueHex: this.valueBlock.valueHexView[0] === 0
+                ? this.valueBlock.valueHexView.subarray(1)
+                : this.valueBlock.valueHexView,
+        });
+    }
+    onAsciiEncoding() {
+        return `${this.constructor.NAME} : ${this.valueBlock.toString()}`;
+    }
+}
+_a$o = Integer;
+(() => {
+    typeStore.Integer = _a$o;
+})();
+Integer.NAME = "INTEGER";
+
+var _a$n;
+class Enumerated extends Integer {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 10;
+    }
+}
+_a$n = Enumerated;
+(() => {
+    typeStore.Enumerated = _a$n;
+})();
+Enumerated.NAME = "ENUMERATED";
+
+class LocalSidValueBlock extends HexBlock(ValueBlock) {
+    constructor({ valueDec = -1, isFirstSid = false, ...parameters } = {}) {
+        super(parameters);
+        this.valueDec = valueDec;
+        this.isFirstSid = isFirstSid;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        if (!inputLength) {
+            return inputOffset;
+        }
+        const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
+        if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+            return -1;
+        }
+        const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+        this.valueHexView = new Uint8Array(inputLength);
+        for (let i = 0; i < inputLength; i++) {
+            this.valueHexView[i] = intBuffer[i] & 0x7F;
+            this.blockLength++;
+            if ((intBuffer[i] & 0x80) === 0x00)
+                break;
+        }
+        const tempView = new Uint8Array(this.blockLength);
+        for (let i = 0; i < this.blockLength; i++) {
+            tempView[i] = this.valueHexView[i];
+        }
+        this.valueHexView = tempView;
+        if ((intBuffer[this.blockLength - 1] & 0x80) !== 0x00) {
+            this.error = "End of input reached before message was fully decoded";
+            return -1;
+        }
+        if (this.valueHexView[0] === 0x00)
+            this.warnings.push("Needlessly long format of SID encoding");
+        if (this.blockLength <= 8)
+            this.valueDec = utilFromBase(this.valueHexView, 7);
+        else {
+            this.isHexOnly = true;
+            this.warnings.push("Too big SID for decoding, hex only");
+        }
+        return (inputOffset + this.blockLength);
+    }
+    set valueBigInt(value) {
+        assertBigInt();
+        let bits = BigInt(value).toString(2);
+        while (bits.length % 7) {
+            bits = "0" + bits;
+        }
+        const bytes = new Uint8Array(bits.length / 7);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = parseInt(bits.slice(i * 7, i * 7 + 7), 2) + (i + 1 < bytes.length ? 0x80 : 0);
+        }
+        this.fromBER(bytes.buffer, 0, bytes.length);
+    }
+    toBER(sizeOnly) {
+        if (this.isHexOnly) {
+            if (sizeOnly)
+                return (new ArrayBuffer(this.valueHexView.byteLength));
+            const curView = this.valueHexView;
+            const retView = new Uint8Array(this.blockLength);
+            for (let i = 0; i < (this.blockLength - 1); i++)
+                retView[i] = curView[i] | 0x80;
+            retView[this.blockLength - 1] = curView[this.blockLength - 1];
+            return retView.buffer;
+        }
+        const encodedBuf = utilToBase(this.valueDec, 7);
+        if (encodedBuf.byteLength === 0) {
+            this.error = "Error during encoding SID value";
+            return EMPTY_BUFFER;
+        }
+        const retView = new Uint8Array(encodedBuf.byteLength);
+        if (!sizeOnly) {
+            const encodedView = new Uint8Array(encodedBuf);
+            const len = encodedBuf.byteLength - 1;
+            for (let i = 0; i < len; i++)
+                retView[i] = encodedView[i] | 0x80;
+            retView[len] = encodedView[len];
+        }
+        return retView;
+    }
+    toString() {
+        let result = "";
+        if (this.isHexOnly)
+            result = Convert.ToHex(this.valueHexView);
+        else {
+            if (this.isFirstSid) {
+                let sidValue = this.valueDec;
+                if (this.valueDec <= 39)
+                    result = "0.";
+                else {
+                    if (this.valueDec <= 79) {
+                        result = "1.";
+                        sidValue -= 40;
+                    }
+                    else {
+                        result = "2.";
+                        sidValue -= 80;
+                    }
+                }
+                result += sidValue.toString();
+            }
+            else
+                result = this.valueDec.toString();
+        }
+        return result;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            valueDec: this.valueDec,
+            isFirstSid: this.isFirstSid,
+        };
+    }
+}
+LocalSidValueBlock.NAME = "sidBlock";
+
+class LocalObjectIdentifierValueBlock extends ValueBlock {
+    constructor({ value = EMPTY_STRING, ...parameters } = {}) {
+        super(parameters);
+        this.value = [];
+        if (value) {
+            this.fromString(value);
+        }
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        let resultOffset = inputOffset;
+        while (inputLength > 0) {
+            const sidBlock = new LocalSidValueBlock();
+            resultOffset = sidBlock.fromBER(inputBuffer, resultOffset, inputLength);
+            if (resultOffset === -1) {
+                this.blockLength = 0;
+                this.error = sidBlock.error;
+                return resultOffset;
+            }
+            if (this.value.length === 0)
+                sidBlock.isFirstSid = true;
+            this.blockLength += sidBlock.blockLength;
+            inputLength -= sidBlock.blockLength;
+            this.value.push(sidBlock);
+        }
+        return resultOffset;
+    }
+    toBER(sizeOnly) {
+        const retBuffers = [];
+        for (let i = 0; i < this.value.length; i++) {
+            const valueBuf = this.value[i].toBER(sizeOnly);
+            if (valueBuf.byteLength === 0) {
+                this.error = this.value[i].error;
+                return EMPTY_BUFFER;
+            }
+            retBuffers.push(valueBuf);
+        }
+        return concat(retBuffers);
+    }
+    fromString(string) {
+        this.value = [];
+        let pos1 = 0;
+        let pos2 = 0;
+        let sid = "";
+        let flag = false;
+        do {
+            pos2 = string.indexOf(".", pos1);
+            if (pos2 === -1)
+                sid = string.substring(pos1);
+            else
+                sid = string.substring(pos1, pos2);
+            pos1 = pos2 + 1;
+            if (flag) {
+                const sidBlock = this.value[0];
+                let plus = 0;
+                switch (sidBlock.valueDec) {
+                    case 0:
+                        break;
+                    case 1:
+                        plus = 40;
+                        break;
+                    case 2:
+                        plus = 80;
+                        break;
+                    default:
+                        this.value = [];
+                        return;
+                }
+                const parsedSID = parseInt(sid, 10);
+                if (isNaN(parsedSID))
+                    return;
+                sidBlock.valueDec = parsedSID + plus;
+                flag = false;
+            }
+            else {
+                const sidBlock = new LocalSidValueBlock();
+                if (sid > Number.MAX_SAFE_INTEGER) {
+                    assertBigInt();
+                    const sidValue = BigInt(sid);
+                    sidBlock.valueBigInt = sidValue;
+                }
+                else {
+                    sidBlock.valueDec = parseInt(sid, 10);
+                    if (isNaN(sidBlock.valueDec))
+                        return;
+                }
+                if (!this.value.length) {
+                    sidBlock.isFirstSid = true;
+                    flag = true;
+                }
+                this.value.push(sidBlock);
+            }
+        } while (pos2 !== -1);
+    }
+    toString() {
+        let result = "";
+        let isHexOnly = false;
+        for (let i = 0; i < this.value.length; i++) {
+            isHexOnly = this.value[i].isHexOnly;
+            let sidStr = this.value[i].toString();
+            if (i !== 0)
+                result = `${result}.`;
+            if (isHexOnly) {
+                sidStr = `{${sidStr}}`;
+                if (this.value[i].isFirstSid)
+                    result = `2.{${sidStr} - 80}`;
+                else
+                    result += sidStr;
+            }
+            else
+                result += sidStr;
+        }
+        return result;
+    }
+    toJSON() {
+        const object = {
+            ...super.toJSON(),
+            value: this.toString(),
+            sidArray: [],
+        };
+        for (let i = 0; i < this.value.length; i++) {
+            object.sidArray.push(this.value[i].toJSON());
+        }
+        return object;
+    }
+}
+LocalObjectIdentifierValueBlock.NAME = "ObjectIdentifierValueBlock";
+
+var _a$m;
+class ObjectIdentifier extends BaseBlock {
+    getValue() {
+        return this.valueBlock.toString();
+    }
+    setValue(value) {
+        this.valueBlock.fromString(value);
+    }
+    constructor(parameters = {}) {
+        super(parameters, LocalObjectIdentifierValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 6;
+    }
+    onAsciiEncoding() {
+        return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            value: this.getValue(),
+        };
+    }
+}
+_a$m = ObjectIdentifier;
+(() => {
+    typeStore.ObjectIdentifier = _a$m;
+})();
+ObjectIdentifier.NAME = "OBJECT IDENTIFIER";
+
+class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) {
+    constructor({ valueDec = 0, ...parameters } = {}) {
+        super(parameters);
+        this.valueDec = valueDec;
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        if (inputLength === 0)
+            return inputOffset;
+        const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
+        if (!checkBufferParams(this, inputView, inputOffset, inputLength))
+            return -1;
+        const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+        this.valueHexView = new Uint8Array(inputLength);
+        for (let i = 0; i < inputLength; i++) {
+            this.valueHexView[i] = intBuffer[i] & 0x7F;
+            this.blockLength++;
+            if ((intBuffer[i] & 0x80) === 0x00)
+                break;
+        }
+        const tempView = new Uint8Array(this.blockLength);
+        for (let i = 0; i < this.blockLength; i++)
+            tempView[i] = this.valueHexView[i];
+        this.valueHexView = tempView;
+        if ((intBuffer[this.blockLength - 1] & 0x80) !== 0x00) {
+            this.error = "End of input reached before message was fully decoded";
+            return -1;
+        }
+        if (this.valueHexView[0] === 0x00)
+            this.warnings.push("Needlessly long format of SID encoding");
+        if (this.blockLength <= 8)
+            this.valueDec = utilFromBase(this.valueHexView, 7);
+        else {
+            this.isHexOnly = true;
+            this.warnings.push("Too big SID for decoding, hex only");
+        }
+        return (inputOffset + this.blockLength);
+    }
+    toBER(sizeOnly) {
+        if (this.isHexOnly) {
+            if (sizeOnly)
+                return (new ArrayBuffer(this.valueHexView.byteLength));
+            const curView = this.valueHexView;
+            const retView = new Uint8Array(this.blockLength);
+            for (let i = 0; i < (this.blockLength - 1); i++)
+                retView[i] = curView[i] | 0x80;
+            retView[this.blockLength - 1] = curView[this.blockLength - 1];
+            return retView.buffer;
+        }
+        const encodedBuf = utilToBase(this.valueDec, 7);
+        if (encodedBuf.byteLength === 0) {
+            this.error = "Error during encoding SID value";
+            return EMPTY_BUFFER;
+        }
+        const retView = new Uint8Array(encodedBuf.byteLength);
+        if (!sizeOnly) {
+            const encodedView = new Uint8Array(encodedBuf);
+            const len = encodedBuf.byteLength - 1;
+            for (let i = 0; i < len; i++)
+                retView[i] = encodedView[i] | 0x80;
+            retView[len] = encodedView[len];
+        }
+        return retView.buffer;
+    }
+    toString() {
+        let result = "";
+        if (this.isHexOnly)
+            result = Convert.ToHex(this.valueHexView);
+        else {
+            result = this.valueDec.toString();
+        }
+        return result;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            valueDec: this.valueDec,
+        };
+    }
+}
+LocalRelativeSidValueBlock.NAME = "relativeSidBlock";
+
+class LocalRelativeObjectIdentifierValueBlock extends ValueBlock {
+    constructor({ value = EMPTY_STRING, ...parameters } = {}) {
+        super(parameters);
+        this.value = [];
+        if (value) {
+            this.fromString(value);
+        }
+    }
+    fromBER(inputBuffer, inputOffset, inputLength) {
+        let resultOffset = inputOffset;
+        while (inputLength > 0) {
+            const sidBlock = new LocalRelativeSidValueBlock();
+            resultOffset = sidBlock.fromBER(inputBuffer, resultOffset, inputLength);
+            if (resultOffset === -1) {
+                this.blockLength = 0;
+                this.error = sidBlock.error;
+                return resultOffset;
+            }
+            this.blockLength += sidBlock.blockLength;
+            inputLength -= sidBlock.blockLength;
+            this.value.push(sidBlock);
+        }
+        return resultOffset;
+    }
+    toBER(sizeOnly, _writer) {
+        const retBuffers = [];
+        for (let i = 0; i < this.value.length; i++) {
+            const valueBuf = this.value[i].toBER(sizeOnly);
+            if (valueBuf.byteLength === 0) {
+                this.error = this.value[i].error;
+                return EMPTY_BUFFER;
+            }
+            retBuffers.push(valueBuf);
+        }
+        return concat(retBuffers);
+    }
+    fromString(string) {
+        this.value = [];
+        let pos1 = 0;
+        let pos2 = 0;
+        let sid = "";
+        do {
+            pos2 = string.indexOf(".", pos1);
+            if (pos2 === -1)
+                sid = string.substring(pos1);
+            else
+                sid = string.substring(pos1, pos2);
+            pos1 = pos2 + 1;
+            const sidBlock = new LocalRelativeSidValueBlock();
+            sidBlock.valueDec = parseInt(sid, 10);
+            if (isNaN(sidBlock.valueDec))
+                return true;
+            this.value.push(sidBlock);
+        } while (pos2 !== -1);
+        return true;
+    }
+    toString() {
+        let result = "";
+        let isHexOnly = false;
+        for (let i = 0; i < this.value.length; i++) {
+            isHexOnly = this.value[i].isHexOnly;
+            let sidStr = this.value[i].toString();
+            if (i !== 0)
+                result = `${result}.`;
+            if (isHexOnly) {
+                sidStr = `{${sidStr}}`;
+                result += sidStr;
+            }
+            else
+                result += sidStr;
+        }
+        return result;
+    }
+    toJSON() {
+        const object = {
+            ...super.toJSON(),
+            value: this.toString(),
+            sidArray: [],
+        };
+        for (let i = 0; i < this.value.length; i++)
+            object.sidArray.push(this.value[i].toJSON());
+        return object;
+    }
+}
+LocalRelativeObjectIdentifierValueBlock.NAME = "RelativeObjectIdentifierValueBlock";
+
+var _a$l;
+class RelativeObjectIdentifier extends BaseBlock {
+    getValue() {
+        return this.valueBlock.toString();
+    }
+    setValue(value) {
+        this.valueBlock.fromString(value);
+    }
+    constructor(parameters = {}) {
+        super(parameters, LocalRelativeObjectIdentifierValueBlock);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 13;
+    }
+    onAsciiEncoding() {
+        return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            value: this.getValue(),
+        };
+    }
+}
+_a$l = RelativeObjectIdentifier;
+(() => {
+    typeStore.RelativeObjectIdentifier = _a$l;
+})();
+RelativeObjectIdentifier.NAME = "RelativeObjectIdentifier";
+
+var _a$k;
+class Sequence extends Constructed {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 16;
+    }
+}
+_a$k = Sequence;
+(() => {
+    typeStore.Sequence = _a$k;
+})();
+Sequence.NAME = "SEQUENCE";
+
+var _a$j;
+class Set$1 extends Constructed {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 17;
+    }
+}
+_a$j = Set$1;
+(() => {
+    typeStore.Set = _a$j;
+})();
+Set$1.NAME = "SET";
+
+class LocalStringValueBlock extends HexBlock(ValueBlock) {
+    constructor({ ...parameters } = {}) {
+        super(parameters);
+        this.isHexOnly = true;
+        this.value = EMPTY_STRING;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            value: this.value,
+        };
+    }
+}
+LocalStringValueBlock.NAME = "StringValueBlock";
+
+class LocalSimpleStringValueBlock extends LocalStringValueBlock {
+}
+LocalSimpleStringValueBlock.NAME = "SimpleStringValueBlock";
+
+class LocalSimpleStringBlock extends BaseStringBlock {
+    constructor({ ...parameters } = {}) {
+        super(parameters, LocalSimpleStringValueBlock);
+    }
+    fromBuffer(inputBuffer) {
+        this.valueBlock.value = String.fromCharCode.apply(null, BufferSourceConverter.toUint8Array(inputBuffer));
+    }
+    fromString(inputString) {
+        const strLen = inputString.length;
+        const view = this.valueBlock.valueHexView = new Uint8Array(strLen);
+        for (let i = 0; i < strLen; i++)
+            view[i] = inputString.charCodeAt(i);
+        this.valueBlock.value = inputString;
+    }
+}
+LocalSimpleStringBlock.NAME = "SIMPLE STRING";
+
+class LocalUtf8StringValueBlock extends LocalSimpleStringBlock {
+    fromBuffer(inputBuffer) {
+        this.valueBlock.valueHexView = BufferSourceConverter.toUint8Array(inputBuffer);
+        try {
+            this.valueBlock.value = Convert.ToUtf8String(inputBuffer);
         }
-        if (match) {
-            oidPosition = i;
-            break;
+        catch (ex) {
+            this.warnings.push(`Error during "decodeURIComponent": ${ex}, using raw string`);
+            this.valueBlock.value = Convert.ToBinary(inputBuffer);
         }
     }
-    if (oidPosition === -1) {
-        return publicKeyData;
+    fromString(inputString) {
+        this.valueBlock.valueHexView = new Uint8Array(Convert.FromUtf8String(inputString));
+        this.valueBlock.value = inputString;
     }
-    // Find the BitString that contains the key
-    let bitStringPosition = -1;
-    for (let i = oidPosition + RSA_OID.length; i < keyBytes.length; i++) {
-        if (keyBytes[i] === 0x03) {
-            // BIT STRING tag
-            bitStringPosition = i;
-            break;
+}
+LocalUtf8StringValueBlock.NAME = "Utf8StringValueBlock";
+
+var _a$i;
+class Utf8String extends LocalUtf8StringValueBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 12;
+    }
+}
+_a$i = Utf8String;
+(() => {
+    typeStore.Utf8String = _a$i;
+})();
+Utf8String.NAME = "UTF8String";
+
+class LocalBmpStringValueBlock extends LocalSimpleStringBlock {
+    fromBuffer(inputBuffer) {
+        this.valueBlock.value = Convert.ToUtf16String(inputBuffer);
+        this.valueBlock.valueHexView = BufferSourceConverter.toUint8Array(inputBuffer);
+    }
+    fromString(inputString) {
+        this.valueBlock.value = inputString;
+        this.valueBlock.valueHexView = new Uint8Array(Convert.FromUtf16String(inputString));
+    }
+}
+LocalBmpStringValueBlock.NAME = "BmpStringValueBlock";
+
+var _a$h;
+class BmpString extends LocalBmpStringValueBlock {
+    constructor({ ...parameters } = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 30;
+    }
+}
+_a$h = BmpString;
+(() => {
+    typeStore.BmpString = _a$h;
+})();
+BmpString.NAME = "BMPString";
+
+class LocalUniversalStringValueBlock extends LocalSimpleStringBlock {
+    fromBuffer(inputBuffer) {
+        const copyBuffer = ArrayBuffer.isView(inputBuffer) ? inputBuffer.slice().buffer : inputBuffer.slice(0);
+        const valueView = new Uint8Array(copyBuffer);
+        for (let i = 0; i < valueView.length; i += 4) {
+            valueView[i] = valueView[i + 3];
+            valueView[i + 1] = valueView[i + 2];
+            valueView[i + 2] = 0x00;
+            valueView[i + 3] = 0x00;
+        }
+        this.valueBlock.value = String.fromCharCode.apply(null, new Uint32Array(copyBuffer));
+    }
+    fromString(inputString) {
+        const strLength = inputString.length;
+        const valueHexView = this.valueBlock.valueHexView = new Uint8Array(strLength * 4);
+        for (let i = 0; i < strLength; i++) {
+            const codeBuf = utilToBase(inputString.charCodeAt(i), 8);
+            const codeView = new Uint8Array(codeBuf);
+            if (codeView.length > 4)
+                continue;
+            const dif = 4 - codeView.length;
+            for (let j = (codeView.length - 1); j >= 0; j--)
+                valueHexView[i * 4 + j + dif] = codeView[j];
         }
+        this.valueBlock.value = inputString;
     }
-    if (bitStringPosition === -1) {
-        return publicKeyData;
+}
+LocalUniversalStringValueBlock.NAME = "UniversalStringValueBlock";
+
+var _a$g;
+class UniversalString extends LocalUniversalStringValueBlock {
+    constructor({ ...parameters } = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 28;
     }
-    // Skip BIT STRING tag and length bytes to find unused bits byte
-    let bitStringLengthBytes = 0;
-    if ((keyBytes[bitStringPosition + 1] & 0x80) === 0) {
-        // Short form length
-        bitStringLengthBytes = 1;
+}
+_a$g = UniversalString;
+(() => {
+    typeStore.UniversalString = _a$g;
+})();
+UniversalString.NAME = "UniversalString";
+
+var _a$f;
+class NumericString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 18;
     }
-    else {
-        // Long form length
-        bitStringLengthBytes = 1 + (keyBytes[bitStringPosition + 1] & 0x7f);
+}
+_a$f = NumericString;
+(() => {
+    typeStore.NumericString = _a$f;
+})();
+NumericString.NAME = "NumericString";
+
+var _a$e;
+class PrintableString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 19;
     }
-    // The unused bits byte follows the length bytes
-    const unusedBitsPosition = bitStringPosition + 1 + bitStringLengthBytes;
-    if (unusedBitsPosition >= keyBytes.length) {
-        return publicKeyData;
+}
+_a$e = PrintableString;
+(() => {
+    typeStore.PrintableString = _a$e;
+})();
+PrintableString.NAME = "PrintableString";
+
+var _a$d;
+class TeletexString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 20;
     }
-    // The inner SEQUENCE (RSA key) should follow the unused bits byte
-    const innerSequencePosition = unusedBitsPosition + 1;
-    if (innerSequencePosition >= keyBytes.length || keyBytes[innerSequencePosition] !== 0x30) {
-        return publicKeyData;
+}
+_a$d = TeletexString;
+(() => {
+    typeStore.TeletexString = _a$d;
+})();
+TeletexString.NAME = "TeletexString";
+
+var _a$c;
+class VideotexString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 21;
     }
-    // Skip the inner SEQUENCE tag and length bytes to find the modulus
-    let innerSequenceLengthBytes = 0;
-    if ((keyBytes[innerSequencePosition + 1] & 0x80) === 0) {
-        // Short form length
-        innerSequenceLengthBytes = 1;
+}
+_a$c = VideotexString;
+(() => {
+    typeStore.VideotexString = _a$c;
+})();
+VideotexString.NAME = "VideotexString";
+
+var _a$b;
+class IA5String extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 22;
     }
-    else {
-        // Long form length
-        innerSequenceLengthBytes = 1 + (keyBytes[innerSequencePosition + 1] & 0x7f);
+}
+_a$b = IA5String;
+(() => {
+    typeStore.IA5String = _a$b;
+})();
+IA5String.NAME = "IA5String";
+
+var _a$a;
+class GraphicString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 25;
     }
-    // The modulus should be an INTEGER (tag 0x02) after the inner SEQUENCE
-    const modulusPosition = innerSequencePosition + 1 + innerSequenceLengthBytes;
-    if (modulusPosition >= keyBytes.length || keyBytes[modulusPosition] !== 0x02) {
-        return publicKeyData;
+}
+_a$a = GraphicString;
+(() => {
+    typeStore.GraphicString = _a$a;
+})();
+GraphicString.NAME = "GraphicString";
+
+var _a$9;
+class VisibleString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 26;
     }
-    // Skip the INTEGER tag and parse its length to find the modulus value
-    let modulusLengthBytes = 0;
-    let modulusLength = 0;
-    if ((keyBytes[modulusPosition + 1] & 0x80) === 0) {
-        // Short form length
-        modulusLength = keyBytes[modulusPosition + 1];
-        modulusLengthBytes = 1;
+}
+_a$9 = VisibleString;
+(() => {
+    typeStore.VisibleString = _a$9;
+})();
+VisibleString.NAME = "VisibleString";
+
+var _a$8;
+class GeneralString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 27;
     }
-    else {
-        // Long form length
-        const numLengthBytes = keyBytes[modulusPosition + 1] & 0x7f;
-        modulusLengthBytes = 1 + numLengthBytes;
-        // Calculate multi-byte length
-        modulusLength = 0;
-        for (let i = 0; i < numLengthBytes; i++) {
-            modulusLength = (modulusLength << 8) | keyBytes[modulusPosition + 2 + i];
+}
+_a$8 = GeneralString;
+(() => {
+    typeStore.GeneralString = _a$8;
+})();
+GeneralString.NAME = "GeneralString";
+
+var _a$7;
+class CharacterString extends LocalSimpleStringBlock {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 29;
+    }
+}
+_a$7 = CharacterString;
+(() => {
+    typeStore.CharacterString = _a$7;
+})();
+CharacterString.NAME = "CharacterString";
+
+var _a$6;
+class UTCTime extends VisibleString {
+    constructor({ value, valueDate, ...parameters } = {}) {
+        super(parameters);
+        this.year = 0;
+        this.month = 0;
+        this.day = 0;
+        this.hour = 0;
+        this.minute = 0;
+        this.second = 0;
+        if (value) {
+            this.fromString(value);
+            this.valueBlock.valueHexView = new Uint8Array(value.length);
+            for (let i = 0; i < value.length; i++)
+                this.valueBlock.valueHexView[i] = value.charCodeAt(i);
+        }
+        if (valueDate) {
+            this.fromDate(valueDate);
+            this.valueBlock.valueHexView = new Uint8Array(this.toBuffer());
+        }
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 23;
+    }
+    fromBuffer(inputBuffer) {
+        this.fromString(String.fromCharCode.apply(null, BufferSourceConverter.toUint8Array(inputBuffer)));
+    }
+    toBuffer() {
+        const str = this.toString();
+        const buffer = new ArrayBuffer(str.length);
+        const view = new Uint8Array(buffer);
+        for (let i = 0; i < str.length; i++)
+            view[i] = str.charCodeAt(i);
+        return buffer;
+    }
+    fromDate(inputDate) {
+        this.year = inputDate.getUTCFullYear();
+        this.month = inputDate.getUTCMonth() + 1;
+        this.day = inputDate.getUTCDate();
+        this.hour = inputDate.getUTCHours();
+        this.minute = inputDate.getUTCMinutes();
+        this.second = inputDate.getUTCSeconds();
+    }
+    toDate() {
+        return (new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second)));
+    }
+    fromString(inputString) {
+        const parser = /(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})Z/ig;
+        const parserArray = parser.exec(inputString);
+        if (parserArray === null) {
+            this.error = "Wrong input string for conversion";
+            return;
+        }
+        const year = parseInt(parserArray[1], 10);
+        if (year >= 50)
+            this.year = 1900 + year;
+        else
+            this.year = 2000 + year;
+        this.month = parseInt(parserArray[2], 10);
+        this.day = parseInt(parserArray[3], 10);
+        this.hour = parseInt(parserArray[4], 10);
+        this.minute = parseInt(parserArray[5], 10);
+        this.second = parseInt(parserArray[6], 10);
+    }
+    toString(encoding = "iso") {
+        if (encoding === "iso") {
+            const outputArray = new Array(7);
+            outputArray[0] = padNumber(((this.year < 2000) ? (this.year - 1900) : (this.year - 2000)), 2);
+            outputArray[1] = padNumber(this.month, 2);
+            outputArray[2] = padNumber(this.day, 2);
+            outputArray[3] = padNumber(this.hour, 2);
+            outputArray[4] = padNumber(this.minute, 2);
+            outputArray[5] = padNumber(this.second, 2);
+            outputArray[6] = "Z";
+            return outputArray.join("");
         }
+        return super.toString(encoding);
     }
-    // The first byte of the modulus value
-    const modulusValuePosition = modulusPosition + 1 + modulusLengthBytes;
-    if (modulusValuePosition >= keyBytes.length) {
-        return publicKeyData;
+    onAsciiEncoding() {
+        return `${this.constructor.NAME} : ${this.toDate().toISOString()}`;
     }
-    // Check if the high bit is set and padding is needed
-    if ((keyBytes[modulusValuePosition] & 0x80) !== 0) {
-        // Create a new key buffer with room for the padding byte
-        const fixedKey = new Uint8Array(keyBytes.length + 1);
-        // Copy bytes up to the modulus value
-        fixedKey.set(keyBytes.slice(0, modulusValuePosition));
-        // Add the padding byte
-        fixedKey[modulusValuePosition] = 0x00;
-        // Copy the rest of the original key after the padding
-        fixedKey.set(keyBytes.slice(modulusValuePosition), modulusValuePosition + 1);
-        // Now fix all the length fields that need to be incremented
-        // 1. Fix modulus length field
-        if ((keyBytes[modulusPosition + 1] & 0x80) === 0) {
-            // Short form
-            fixedKey[modulusPosition + 1] = keyBytes[modulusPosition + 1] + 1;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            year: this.year,
+            month: this.month,
+            day: this.day,
+            hour: this.hour,
+            minute: this.minute,
+            second: this.second,
+        };
+    }
+}
+_a$6 = UTCTime;
+(() => {
+    typeStore.UTCTime = _a$6;
+})();
+UTCTime.NAME = "UTCTime";
+
+var _a$5;
+class GeneralizedTime extends UTCTime {
+    constructor(parameters = {}) {
+        var _b;
+        super(parameters);
+        (_b = this.millisecond) !== null && _b !== void 0 ? _b : (this.millisecond = 0);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 24;
+    }
+    fromDate(inputDate) {
+        super.fromDate(inputDate);
+        this.millisecond = inputDate.getUTCMilliseconds();
+    }
+    toDate() {
+        const utcDate = Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond);
+        return (new Date(utcDate));
+    }
+    fromString(inputString) {
+        let isUTC = false;
+        let timeString = "";
+        let dateTimeString = "";
+        let fractionPart = 0;
+        let parser;
+        let hourDifference = 0;
+        let minuteDifference = 0;
+        if (inputString[inputString.length - 1] === "Z") {
+            timeString = inputString.substring(0, inputString.length - 1);
+            isUTC = true;
         }
         else {
-            // Long form
-            const numLengthBytes = keyBytes[modulusPosition + 1] & 0x7f;
-            let lengthValue = 0;
-            for (let i = 0; i < numLengthBytes; i++) {
-                lengthValue = (lengthValue << 8) | keyBytes[modulusPosition + 2 + i];
-            }
-            lengthValue += 1;
-            for (let i = numLengthBytes - 1; i >= 0; i--) {
-                fixedKey[modulusPosition + 2 + i] = lengthValue & 0xff;
-                lengthValue >>= 8;
-            }
+            const number = new Number(inputString[inputString.length - 1]);
+            if (isNaN(number.valueOf()))
+                throw new Error("Wrong input string for conversion");
+            timeString = inputString;
         }
-        // 2. Fix inner SEQUENCE length field
-        if ((keyBytes[innerSequencePosition + 1] & 0x80) === 0) {
-            // Short form
-            fixedKey[innerSequencePosition + 1] = keyBytes[innerSequencePosition + 1] + 1;
+        if (isUTC) {
+            if (timeString.indexOf("+") !== -1)
+                throw new Error("Wrong input string for conversion");
+            if (timeString.indexOf("-") !== -1)
+                throw new Error("Wrong input string for conversion");
         }
         else {
-            // Long form
-            const numLengthBytes = keyBytes[innerSequencePosition + 1] & 0x7f;
-            let lengthValue = 0;
-            for (let i = 0; i < numLengthBytes; i++) {
-                lengthValue = (lengthValue << 8) | keyBytes[innerSequencePosition + 2 + i];
+            let multiplier = 1;
+            let differencePosition = timeString.indexOf("+");
+            let differenceString = "";
+            if (differencePosition === -1) {
+                differencePosition = timeString.indexOf("-");
+                multiplier = -1;
             }
-            lengthValue += 1;
-            for (let i = numLengthBytes - 1; i >= 0; i--) {
-                fixedKey[innerSequencePosition + 2 + i] = lengthValue & 0xff;
-                lengthValue >>= 8;
+            if (differencePosition !== -1) {
+                differenceString = timeString.substring(differencePosition + 1);
+                timeString = timeString.substring(0, differencePosition);
+                if ((differenceString.length !== 2) && (differenceString.length !== 4))
+                    throw new Error("Wrong input string for conversion");
+                let number = parseInt(differenceString.substring(0, 2), 10);
+                if (isNaN(number.valueOf()))
+                    throw new Error("Wrong input string for conversion");
+                hourDifference = multiplier * number;
+                if (differenceString.length === 4) {
+                    number = parseInt(differenceString.substring(2, 4), 10);
+                    if (isNaN(number.valueOf()))
+                        throw new Error("Wrong input string for conversion");
+                    minuteDifference = multiplier * number;
+                }
             }
         }
-        // 3. Fix BIT STRING length field
-        if ((keyBytes[bitStringPosition + 1] & 0x80) === 0) {
-            // Short form
-            fixedKey[bitStringPosition + 1] = keyBytes[bitStringPosition + 1] + 1;
+        let fractionPointPosition = timeString.indexOf(".");
+        if (fractionPointPosition === -1)
+            fractionPointPosition = timeString.indexOf(",");
+        if (fractionPointPosition !== -1) {
+            const fractionPartCheck = new Number(`0${timeString.substring(fractionPointPosition)}`);
+            if (isNaN(fractionPartCheck.valueOf()))
+                throw new Error("Wrong input string for conversion");
+            fractionPart = fractionPartCheck.valueOf();
+            dateTimeString = timeString.substring(0, fractionPointPosition);
         }
-        else {
-            // Long form
-            const numLengthBytes = keyBytes[bitStringPosition + 1] & 0x7f;
-            let lengthValue = 0;
-            for (let i = 0; i < numLengthBytes; i++) {
-                lengthValue = (lengthValue << 8) | keyBytes[bitStringPosition + 2 + i];
-            }
-            lengthValue += 1;
-            for (let i = numLengthBytes - 1; i >= 0; i--) {
-                fixedKey[bitStringPosition + 2 + i] = lengthValue & 0xff;
-                lengthValue >>= 8;
+        else
+            dateTimeString = timeString;
+        switch (true) {
+            case (dateTimeString.length === 8):
+                parser = /(\d{4})(\d{2})(\d{2})/ig;
+                if (fractionPointPosition !== -1)
+                    throw new Error("Wrong input string for conversion");
+                break;
+            case (dateTimeString.length === 10):
+                parser = /(\d{4})(\d{2})(\d{2})(\d{2})/ig;
+                if (fractionPointPosition !== -1) {
+                    let fractionResult = 60 * fractionPart;
+                    this.minute = Math.floor(fractionResult);
+                    fractionResult = 60 * (fractionResult - this.minute);
+                    this.second = Math.floor(fractionResult);
+                    fractionResult = 1000 * (fractionResult - this.second);
+                    this.millisecond = Math.floor(fractionResult);
+                }
+                break;
+            case (dateTimeString.length === 12):
+                parser = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})/ig;
+                if (fractionPointPosition !== -1) {
+                    let fractionResult = 60 * fractionPart;
+                    this.second = Math.floor(fractionResult);
+                    fractionResult = 1000 * (fractionResult - this.second);
+                    this.millisecond = Math.floor(fractionResult);
+                }
+                break;
+            case (dateTimeString.length === 14):
+                parser = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/ig;
+                if (fractionPointPosition !== -1) {
+                    const fractionResult = 1000 * fractionPart;
+                    this.millisecond = Math.floor(fractionResult);
+                }
+                break;
+            default:
+                throw new Error("Wrong input string for conversion");
+        }
+        const parserArray = parser.exec(dateTimeString);
+        if (parserArray === null)
+            throw new Error("Wrong input string for conversion");
+        for (let j = 1; j < parserArray.length; j++) {
+            switch (j) {
+                case 1:
+                    this.year = parseInt(parserArray[j], 10);
+                    break;
+                case 2:
+                    this.month = parseInt(parserArray[j], 10);
+                    break;
+                case 3:
+                    this.day = parseInt(parserArray[j], 10);
+                    break;
+                case 4:
+                    this.hour = parseInt(parserArray[j], 10) + hourDifference;
+                    break;
+                case 5:
+                    this.minute = parseInt(parserArray[j], 10) + minuteDifference;
+                    break;
+                case 6:
+                    this.second = parseInt(parserArray[j], 10);
+                    break;
+                default:
+                    throw new Error("Wrong input string for conversion");
             }
         }
-        // 4. Fix outer SEQUENCE length field
-        if ((keyBytes[1] & 0x80) === 0) {
-            // Short form
-            fixedKey[1] = keyBytes[1] + 1;
+        if (isUTC === false) {
+            const tempDate = new Date(this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+            this.year = tempDate.getUTCFullYear();
+            this.month = tempDate.getUTCMonth();
+            this.day = tempDate.getUTCDay();
+            this.hour = tempDate.getUTCHours();
+            this.minute = tempDate.getUTCMinutes();
+            this.second = tempDate.getUTCSeconds();
+            this.millisecond = tempDate.getUTCMilliseconds();
         }
-        else {
-            // Long form
-            const numLengthBytes = keyBytes[1] & 0x7f;
-            let lengthValue = 0;
-            for (let i = 0; i < numLengthBytes; i++) {
-                lengthValue = (lengthValue << 8) | keyBytes[1 + 1 + i];
-            }
-            lengthValue += 1;
-            for (let i = numLengthBytes - 1; i >= 0; i--) {
-                fixedKey[1 + 1 + i] = lengthValue & 0xff;
-                lengthValue >>= 8;
+    }
+    toString(encoding = "iso") {
+        if (encoding === "iso") {
+            const outputArray = [];
+            outputArray.push(padNumber(this.year, 4));
+            outputArray.push(padNumber(this.month, 2));
+            outputArray.push(padNumber(this.day, 2));
+            outputArray.push(padNumber(this.hour, 2));
+            outputArray.push(padNumber(this.minute, 2));
+            outputArray.push(padNumber(this.second, 2));
+            if (this.millisecond !== 0) {
+                outputArray.push(".");
+                outputArray.push(padNumber(this.millisecond, 3));
             }
+            outputArray.push("Z");
+            return outputArray.join("");
         }
-        log("Fixed key length: " + fixedKey.length);
-        return fixedKey.buffer;
+        return super.toString(encoding);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            millisecond: this.millisecond,
+        };
     }
-    return publicKeyData;
 }
+_a$5 = GeneralizedTime;
+(() => {
+    typeStore.GeneralizedTime = _a$5;
+})();
+GeneralizedTime.NAME = "GeneralizedTime";
 
-// src/core/revocation/types.ts
-/**
- * Default options for revocation checking
- */
-const DEFAULT_REVOCATION_OPTIONS = {
-    ocspEnabled: true,
-    crlEnabled: true,
-    ocspTimeout: 5000,
-    crlTimeout: 10000,
-};
+var _a$4;
+class DATE extends Utf8String {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 31;
+    }
+}
+_a$4 = DATE;
+(() => {
+    typeStore.DATE = _a$4;
+})();
+DATE.NAME = "DATE";
+
+var _a$3;
+class TimeOfDay extends Utf8String {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 32;
+    }
+}
+_a$3 = TimeOfDay;
+(() => {
+    typeStore.TimeOfDay = _a$3;
+})();
+TimeOfDay.NAME = "TimeOfDay";
+
+var _a$2;
+class DateTime extends Utf8String {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 33;
+    }
+}
+_a$2 = DateTime;
+(() => {
+    typeStore.DateTime = _a$2;
+})();
+DateTime.NAME = "DateTime";
+
+var _a$1;
+class Duration extends Utf8String {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 34;
+    }
+}
+_a$1 = Duration;
+(() => {
+    typeStore.Duration = _a$1;
+})();
+Duration.NAME = "Duration";
+
+var _a;
+class TIME extends Utf8String {
+    constructor(parameters = {}) {
+        super(parameters);
+        this.idBlock.tagClass = 1;
+        this.idBlock.tagNumber = 14;
+    }
+}
+_a = TIME;
+(() => {
+    typeStore.TIME = _a;
+})();
+TIME.NAME = "TIME";
 
 // src/core/revocation/crl.ts
 /**
  * OID for CRL Distribution Points extension
  */
 const id_ce_cRLDistributionPoints = "2.5.29.31";
+/**
+ * Upper bound on ASN.1 nodes when parsing large CRLs.
+ *
+ * asn1js enforces a DoS guard (DEFAULT_MAX_NODES = 10000) that rejects national
+ * CRLs with tens of thousands of revoked entries (e.g. the Latvian LV eID ICA
+ * CRL has ~13k entries -> well over 10k nodes). @peculiar/x509's X509Crl does not
+ * expose the limit, so the large-CRL fallback in parseCRL() raises it here while
+ * still keeping a realistic ceiling so a maliciously huge CRL is rejected.
+ */
+const MAX_CRL_ASN1_NODES = 5000000;
 /**
  * Extract CRL distribution point URLs from certificate
  * @param cert X509Certificate to extract CRL URLs from
@@ -1250,6 +4603,47 @@ function isSerialInCRL(crl, serialNumber) {
     }
     return { isRevoked: false };
 }
+/**
+ * Convert CRL bytes to a DER ArrayBuffer, decoding from PEM if necessary.
+ */
+function crlBytesToDer(data) {
+    // Detect a PEM armor by inspecting the leading bytes ("-----BEGIN").
+    const head = new Uint8Array(data, 0, Math.min(data.byteLength, 16));
+    let prefix = "";
+    for (const byte of head) {
+        prefix += String.fromCharCode(byte);
+    }
+    if (prefix.includes("-----BEGIN")) {
+        const pem = new TextDecoder().decode(data);
+        const base64 = pem
+            .replace(/-----BEGIN[^-]+-----/g, "")
+            .replace(/-----END[^-]+-----/g, "")
+            .replace(/\s+/g, "");
+        return normalize.base64ToArrayBuffer(base64);
+    }
+    return data;
+}
+/**
+ * Parse a large CRL that exceeds asn1js's default node cap.
+ *
+ * X509Crl's constructor parses with asn1js defaults, so we decode the DER
+ * ourselves with a raised (but bounded) node limit and then hand the already
+ * decoded structure to X509Crl, which accepts a CertificateList directly.
+ */
+function parseLargeCRL(data) {
+    try {
+        const der = crlBytesToDer(data);
+        const asn1 = fromBER(der, { maxNodes: MAX_CRL_ASN1_NODES });
+        if (asn1.offset === -1 || !asn1.result) {
+            return null;
+        }
+        const certList = asn1Schema.AsnParser.fromASN(asn1.result, asn1X509.CertificateList);
+        return new x509.X509Crl(certList);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Parse CRL from DER or PEM data
  * @param data CRL data (DER or PEM)
@@ -1269,7 +4663,8 @@ function parseCRL(data) {
             return new x509.X509Crl(pem);
         }
         catch {
-            return null;
+            // National CRLs can exceed asn1js's default node cap; retry with a raised limit.
+            return parseLargeCRL(data);
         }
     }
 }
@@ -2742,8 +6137,15 @@ async function verifySignature(signatureInfo, files, options = {}) {
     // Check certificate revocation (default: enabled)
     if (options.checkRevocation !== false && certResult.isValid) {
         try {
+            // Certificates carried inside embedded OCSP responses are a useful source of
+            // the issuer cert, letting the lightweight live OCSP query succeed (and
+            // avoiding a full CRL download) when the container's chain is empty.
+            const revocationChain = [
+                ...(signatureInfo.certificateChain ?? []),
+                ...identity.extractCertsFromOCSPResponses(signatureInfo.revocationValues?.ocsp ?? []),
+            ];
             const revocationResult = await checkCertificateRevocation(signatureInfo.certificatePEM, {
-                certificateChain: signatureInfo.certificateChain,
+                certificateChain: revocationChain.length > 0 ? revocationChain : undefined,
                 ...options.revocationOptions,
             });
             certResult.revocation = revocationResult;