@ne1410s/crypto 0.2.329 → 0.2.331

package/dist/ne14_crypto.umd.min.js

@@ -1,3667 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ne_crypto = {}));
-})(this, (function (exports) { 'use strict';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-        return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (g && (g = 0, op[0] && (_ = 0)), _) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    /*!
-     * 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) {
-                    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) {
-            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 = 1;
-                let intTagNumberBuffer = this.valueHexView = new Uint8Array(255);
-                let tagNumberBufferMaxLength = 255;
-                while (intBuffer[count] & 0x80) {
-                    intTagNumberBuffer[count - 1] = intBuffer[count] & 0x7F;
-                    count++;
-                    if (count >= intBuffer.length) {
-                        this.error = "End of input reached before message was fully decoded";
-                        return -1;
-                    }
-                    if (count === tagNumberBufferMaxLength) {
-                        tagNumberBufferMaxLength += 255;
-                        const tempBufferView = new Uint8Array(tagNumberBufferMaxLength);
-                        for (let i = 0; i < intTagNumberBuffer.length; i++)
-                            tempBufferView[i] = intTagNumberBuffer[i];
-                        intTagNumberBuffer = this.valueHexView = new Uint8Array(tagNumberBufferMaxLength);
-                    }
-                }
-                this.blockLength = (count + 1);
-                intTagNumberBuffer[count - 1] = intBuffer[count] & 0x7F;
-                const tempBufferView = new Uint8Array(count);
-                for (let i = 0; i < count; i++)
-                    tempBufferView[i] = intTagNumberBuffer[i];
-                intTagNumberBuffer = this.valueHexView = new Uint8Array(count);
-                intTagNumberBuffer.set(tempBufferView);
-                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) {
-            const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm)
-                ? inputLength
-                : this.lenBlock.length);
-            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";
-
-    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) {
-        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,
-            };
-        }
-        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;
-        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, returnObject.lenBlock.isIndefiniteForm ? inputLength : returnObject.lenBlock.length);
-        returnObject.valueBeforeDecodeView = inputBuffer.subarray(incomingOffset, incomingOffset + returnObject.blockLength);
-        return {
-            offset: resultOffset,
-            result: returnObject,
-        };
-    }
-    function fromBER(inputBuffer) {
-        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);
-    }
-
-    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) {
-            const view = BufferSourceConverter.toUint8Array(inputBuffer);
-            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 = localFromBER(view, currentOffset, inputLength);
-                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) {
-            this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
-            const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm) ? inputLength : this.lenBlock.length);
-            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 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;
-    (() => {
-        typeStore.Boolean = _a$s;
-    })();
-    Boolean.NAME = "BOOLEAN";
-
-    class LocalOctetStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
-        constructor({ isConstructed = false, ...parameters } = {}) {
-            super(parameters);
-            this.isConstructed = isConstructed;
-        }
-        fromBER(inputBuffer, inputOffset, inputLength) {
-            let resultOffset = 0;
-            if (this.isConstructed) {
-                this.isHexOnly = false;
-                resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength);
-                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) {
-            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 asn = localFromBER(buf, 0, buf.byteLength);
-                        if (asn.offset !== -1 && asn.offset === inputLength) {
-                            this.valueBlock.value = [asn.result];
-                        }
-                    }
-                }
-                catch {
-                }
-            }
-            return super.fromBER(inputBuffer, inputOffset, inputLength);
-        }
-        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) {
-            if (!inputLength) {
-                return inputOffset;
-            }
-            let resultOffset = -1;
-            if (this.isConstructed) {
-                resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength);
-                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 asn = localFromBER(buf, 0, buf.byteLength);
-                        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) {
-            this.valueBlock.isConstructed = this.idBlock.isConstructed;
-            this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
-            return super.fromBER(inputBuffer, inputOffset, inputLength);
-        }
-        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 extends Constructed {
-        constructor(parameters = {}) {
-            super(parameters);
-            this.idBlock.tagClass = 1;
-            this.idBlock.tagNumber = 17;
-        }
-    }
-    _a$j = Set;
-    (() => {
-        typeStore.Set = _a$j;
-    })();
-    Set.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);
-            }
-            catch (ex) {
-                this.warnings.push(`Error during "decodeURIComponent": ${ex}, using raw string`);
-                this.valueBlock.value = Convert.ToBinary(inputBuffer);
-            }
-        }
-        fromString(inputString) {
-            this.valueBlock.valueHexView = new Uint8Array(Convert.FromUtf8String(inputString));
-            this.valueBlock.value = inputString;
-        }
-    }
-    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;
-        }
-    }
-    LocalUniversalStringValueBlock.NAME = "UniversalStringValueBlock";
-
-    var _a$g;
-    class UniversalString extends LocalUniversalStringValueBlock {
-        constructor({ ...parameters } = {}) {
-            super(parameters);
-            this.idBlock.tagClass = 1;
-            this.idBlock.tagNumber = 28;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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;
-        }
-    }
-    _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);
-        }
-        onAsciiEncoding() {
-            return `${this.constructor.NAME} : ${this.toDate().toISOString()}`;
-        }
-        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 {
-                const number = new Number(inputString[inputString.length - 1]);
-                if (isNaN(number.valueOf()))
-                    throw new Error("Wrong input string for conversion");
-                timeString = inputString;
-            }
-            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 {
-                let multiplier = 1;
-                let differencePosition = timeString.indexOf("+");
-                let differenceString = "";
-                if (differencePosition === -1) {
-                    differencePosition = timeString.indexOf("-");
-                    multiplier = -1;
-                }
-                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;
-                    }
-                }
-            }
-            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
-                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");
-                }
-            }
-            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();
-            }
-        }
-        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("");
-            }
-            return super.toString(encoding);
-        }
-        toJSON() {
-            return {
-                ...super.toJSON(),
-                millisecond: this.millisecond,
-            };
-        }
-    }
-    _a$5 = GeneralizedTime;
-    (() => {
-        typeStore.GeneralizedTime = _a$5;
-    })();
-    GeneralizedTime.NAME = "GeneralizedTime";
-
-    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";
-
-    /**
-     * Converts text to an array buffer.
-     * @param text The text.
-     * @returns An array buffer.
-     */
-    function textToBuffer(text) {
-        return Uint8Array.from(Array.from(text).map(function (letter) { return letter.charCodeAt(0); })).buffer;
-    }
-    /**
-     * Converts an array buffer to the corresponding text.
-     * @param buffer An array buffer.
-     * @returns The corresponding text.
-     */
-    function bufferToText(buffer) {
-        return String.fromCharCode.apply(null, new Uint8Array(buffer));
-    }
-    /**
-     * Encodes text as base 64.
-     * @param text The text.
-     * @returns The encoded base 64.
-     */
-    function textToBase64(text) {
-        return Buffer.from(text, 'binary').toString('base64');
-    }
-    /**
-     * Decodes base 64 to text.
-     * @param base64 The base 64.
-     * @returns The decoded text.
-     */
-    function base64ToText(base64) {
-        return Buffer.from(base64, 'base64').toString('binary');
-    }
-    /**
-     * Encodes an array buffer as base 64.
-     * @param buffer An array buffer.
-     * @returns The encoded base 64.
-     */
-    function bufferToBase64(buffer) {
-        return textToBase64(bufferToText(buffer));
-    }
-    /**
-     * Encodes an array buffer as base 64 url.
-     * @param buffer An array buffer.
-     * @returns The encoded base 64 url.
-     */
-    function bufferToBase64Url(buffer) {
-        return textToBase64Url(bufferToText(buffer));
-    }
-    /**
-     * Encodes text as base 64 url.
-     * @param text The text.
-     * @returns The encoded base 64 url.
-     */
-    function textToBase64Url(text) {
-        return textToBase64(text).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
-    }
-
-    var crypto = require('node:crypto');
-    var pkijs = require('pkijs');
-    pkijs.setEngine('OpenSSL', crypto, new pkijs.CryptoEngine({ name: '', crypto: crypto, subtle: crypto.subtle }));
-    var DEF_ALGO = {
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-        hash: { name: 'SHA-256' },
-    };
-    function randomString() {
-        return __awaiter(this, void 0, void 0, function () {
-            var bytes;
-            return __generator(this, function (_a) {
-                bytes = new Uint8Array(24);
-                crypto.getRandomValues(bytes);
-                return [2 /*return*/, bufferToBase64Url(bytes.buffer)];
-            });
-        });
-    }
-    function gen() {
-        return __awaiter(this, void 0, void 0, function () {
-            var keys;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, crypto.subtle.generateKey(DEF_ALGO, true, ['sign'])];
-                    case 1:
-                        keys = _b.sent();
-                        _a = {};
-                        return [4 /*yield*/, crypto.subtle.exportKey('jwk', keys.publicKey)];
-                    case 2:
-                        _a.publicJwk = _b.sent();
-                        return [4 /*yield*/, crypto.subtle.exportKey('jwk', keys.privateKey)];
-                    case 3: return [2 /*return*/, (_a.privateJwk = _b.sent(),
-                            _a)];
-                }
-            });
-        });
-    }
-    function sign(text, privateJwk) {
-        return __awaiter(this, void 0, void 0, function () {
-            var cKey, buffer, signed;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, crypto.subtle.importKey('jwk', privateJwk, DEF_ALGO, true, ['sign'])];
-                    case 1:
-                        cKey = _a.sent(), buffer = textToBuffer(text);
-                        return [4 /*yield*/, crypto.subtle.sign(DEF_ALGO.name, cKey, buffer)];
-                    case 2:
-                        signed = _a.sent();
-                        return [2 /*return*/, bufferToBase64Url(signed)];
-                }
-            });
-        });
-    }
-    function digest(text) {
-        return __awaiter(this, void 0, void 0, function () {
-            var buffer, digest;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        buffer = textToBuffer(text);
-                        return [4 /*yield*/, crypto.subtle.digest('SHA-256', buffer)];
-                    case 1:
-                        digest = _a.sent();
-                        return [2 /*return*/, bufferToBase64Url(digest)];
-                }
-            });
-        });
-    }
-    //https://github.com/PeculiarVentures/PKI.js/blob/master/examples/PKCS10ComplexExample/es6.js
-    function csr(params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pkcs10, keys, publicKey, toDigest, pubkeyhash_sha1, privateKey, pkcs10_schema, pkcs10_encoded, exportedPkcs8;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        pkcs10 = new pkijs.CertificationRequest();
-                        pkcs10.version = 0;
-                        pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue({
-                            type: '2.5.4.3', // CN=
-                            value: new PrintableString({ value: params.domains[0] }),
-                        }));
-                        if (params.country) {
-                            pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue({
-                                type: '2.5.4.6', // C=
-                                value: new PrintableString({ value: params.country }),
-                            }));
-                        }
-                        if (params.town) {
-                            pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue({
-                                type: '2.5.4.7', // L=
-                                value: new PrintableString({ value: params.town }),
-                            }));
-                        }
-                        if (params.county) {
-                            pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue({
-                                type: '2.5.4.8', // S=
-                                value: new PrintableString({ value: params.county }),
-                            }));
-                        }
-                        if (params.company) {
-                            pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue({
-                                type: '2.5.4.10', // O=
-                                value: new PrintableString({ value: params.company }),
-                            }));
-                        }
-                        if (params.department) {
-                            pkcs10.subject.typesAndValues.push(new pkijs.AttributeTypeAndValue({
-                                type: '2.5.4.11', // OU=
-                                value: new PrintableString({ value: params.department }),
-                            }));
-                        }
-                        return [4 /*yield*/, crypto.subtle.generateKey(DEF_ALGO, true, ['sign'])];
-                    case 1:
-                        keys = _b.sent();
-                        publicKey = keys.publicKey;
-                        return [4 /*yield*/, pkcs10.subjectPublicKeyInfo.importKey(publicKey)];
-                    case 2:
-                        _b.sent();
-                        toDigest = pkcs10.subjectPublicKeyInfo.subjectPublicKey.valueBlock.valueHex;
-                        return [4 /*yield*/, crypto.subtle.digest('SHA-1', toDigest)];
-                    case 3:
-                        pubkeyhash_sha1 = _b.sent();
-                        //pubkeyhash_sha256 = await crypto.subtle.digest('SHA-256', toDigest);
-                        pkcs10.attributes = [];
-                        pkcs10.attributes.push(new pkijs.Attribute({
-                            type: '1.2.840.113549.1.9.14', // pkcs-9-at-extensionRequest
-                            values: [
-                                new pkijs.Extensions({
-                                    extensions: [
-                                        new pkijs.Extension({
-                                            extnID: '2.5.29.14',
-                                            critical: false,
-                                            extnValue: new OctetString({ valueHex: pubkeyhash_sha1 }).toBER(false),
-                                        }),
-                                        new pkijs.Extension({
-                                            extnID: '2.5.29.17',
-                                            critical: false,
-                                            extnValue: new pkijs.GeneralNames({
-                                                names: params.domains.map(function (dom) {
-                                                    return new pkijs.GeneralName({
-                                                        type: 2,
-                                                        value: dom,
-                                                    });
-                                                }),
-                                            })
-                                                .toSchema()
-                                                .toBER(false),
-                                        }),
-                                    ],
-                                }).toSchema(),
-                            ],
-                        }));
-                        privateKey = keys.privateKey;
-                        return [4 /*yield*/, pkcs10.sign(privateKey, 'SHA-256')];
-                    case 4:
-                        _b.sent(), pkcs10_schema = pkcs10.toSchema(), pkcs10_encoded = pkcs10_schema.toBER(false);
-                        return [4 /*yield*/, crypto.subtle.exportKey('pkcs8', keys.privateKey)];
-                    case 5:
-                        exportedPkcs8 = _b.sent();
-                        _a = {
-                            pem: bufferToPem(pkcs10_encoded, 'CERTIFICATE REQUEST'),
-                            der: bufferToBase64Url(pkcs10_encoded),
-                            pkcs8_pem: bufferToPem(exportedPkcs8, 'PRIVATE KEY'),
-                            pkcs8_b64: bufferToBase64(exportedPkcs8)
-                        };
-                        return [4 /*yield*/, crypto.subtle.exportKey('jwk', keys.privateKey)];
-                    case 6:
-                        _a.privateJwk = _b.sent();
-                        return [4 /*yield*/, crypto.subtle.exportKey('jwk', keys.publicKey)];
-                    case 7: return [2 /*return*/, (_a.publicJwk = _b.sent(),
-                            _a)];
-                }
-            });
-        });
-    }
-    //https://github.com/PeculiarVentures/PKI.js/blob/master/examples/PKCS12SimpleExample/es6.js
-    function pfx(friendlyName_1, cert_b64_1, key_b64_1, password_1) {
-        return __awaiter(this, arguments, void 0, function (friendlyName, cert_b64, key_b64, password, hash) {
-            var asn1_cer, asn1_key, objc_cer, objc_key, pkcs12;
-            if (hash === void 0) { hash = 'SHA-256'; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        asn1_cer = fromBER(textToBuffer(base64ToText(cert_b64))), asn1_key = fromBER(textToBuffer(base64ToText(key_b64)));
-                        objc_cer = new pkijs.Certificate({ schema: asn1_cer.result }), objc_key = new pkijs.PrivateKeyInfo({ schema: asn1_key.result });
-                        pkcs12 = new pkijs.PFX({
-                            parsedValue: {
-                                integrityMode: 0, // Password-Based Integrity Mode
-                                authenticatedSafe: new pkijs.AuthenticatedSafe({
-                                    parsedValue: {
-                                        safeContents: [
-                                            {
-                                                privacyMode: 0, // 'No Privacy' mode
-                                                value: new pkijs.SafeContents({
-                                                    safeBags: [
-                                                        new pkijs.SafeBag({
-                                                            bagId: '1.2.840.113549.1.12.10.1.1',
-                                                            bagValue: objc_key,
-                                                        }),
-                                                        new pkijs.SafeBag({
-                                                            bagId: '1.2.840.113549.1.12.10.1.3',
-                                                            bagValue: new pkijs.CertBag({
-                                                                parsedValue: objc_cer,
-                                                            }),
-                                                            bagAttributes: [
-                                                                new pkijs.Attribute({
-                                                                    type: '1.2.840.113549.1.9.20', // friendlyName
-                                                                    values: [new BmpString({ value: friendlyName })],
-                                                                }),
-                                                            ],
-                                                        }),
-                                                    ],
-                                                }),
-                                            },
-                                        ],
-                                    },
-                                }),
-                            },
-                        });
-                        return [4 /*yield*/, pkcs12.parsedValue.authenticatedSafe.makeInternalValues({
-                                safeContents: [
-                                    {
-                                    /* Empty as 'No Privacy' for SafeContents */
-                                    },
-                                ],
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, pkcs12.makeInternalValues({
-                                password: textToBuffer(password),
-                                iterations: 1000,
-                                pbkdf2HashAlgorithm: hash,
-                                hmacHashAlgorithm: hash,
-                            })];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, pkcs12.toSchema().toBER(false)];
-                }
-            });
-        });
-    }
-    function pemToBase64Parts(pem) {
-        return pem
-            .split(/-----[\w\s]+-----/)
-            .map(function (p) { return p.replace(/\s/g, ''); })
-            .filter(function (p) { return p; });
-    }
-    function base64ToPem(base64, title) {
-        var string_length = base64.length;
-        var result_string = '';
-        for (var i = 0, count = 0; i < string_length; i++, count++) {
-            if (count > 63) {
-                result_string += '\r\n';
-                count = 0;
-            }
-            result_string += base64[i];
-        }
-        title =
-            (title || '')
-                .replace(/[^\w\s]+/, '')
-                .trim()
-                .toUpperCase() || 'CERTIFICATE';
-        return "-----BEGIN ".concat(title, "-----\r\n").concat(result_string, "\r\n-----END ").concat(title, "-----\r\n");
-    }
-    function bufferToPem(pkcs10_buf, title) {
-        var base64 = bufferToBase64(pkcs10_buf);
-        return base64ToPem(base64, title);
-    }
-
-    exports.base64ToPem = base64ToPem;
-    exports.bufferToPem = bufferToPem;
-    exports.csr = csr;
-    exports.digest = digest;
-    exports.gen = gen;
-    exports.pemToBase64Parts = pemToBase64Parts;
-    exports.pfx = pfx;
-    exports.randomString = randomString;
-    exports.sign = sign;
-
-}));