@waku/enr 0.0.28-ebd7523.0 → 0.0.29-5e19700.0

package/bundle/index.js

@@ -1218,6 +1218,9 @@ const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$
  * Returns a `Uint8Array` of the requested size. Referenced memory will
  * be initialized to 0.
  */
+function alloc$1(size = 0) {
+    return new Uint8Array(size);
+}
 /**
  * Where possible returns a Uint8Array of the requested size that references
  * uninitialized memory. Only use if you are certain you will immediately
@@ -1331,7 +1334,7 @@ const utf8ToBytes$2 = (s) => fromString(s, "utf8");
 /**
  * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
  */
-function concat$2(byteArrays, totalLength) {
+function concat$1(byteArrays, totalLength) {
     const len = totalLength ?? byteArrays.reduce((acc, curr) => acc + curr.length, 0);
     const res = new Uint8Array(len);
     let offset = 0;
@@ -3067,14 +3070,14 @@ async function sign$1(message, privateKey) {
         recovered: true,
         der: false
     });
-    return concat$2([signature, new Uint8Array([recoveryId])], signature.length + 1);
+    return concat$1([signature, new Uint8Array([recoveryId])], signature.length + 1);
 }
 function keccak256(input) {
     return new Uint8Array(sha3.keccak256.arrayBuffer(input));
 }
 function compressPublicKey(publicKey) {
     if (publicKey.length === 64) {
-        publicKey = concat$2([new Uint8Array([4]), publicKey], 65);
+        publicKey = concat$1([new Uint8Array([4]), publicKey], 65);
     }
     const point = Point.fromHex(publicKey);
     return point.toRawBytes(true);
@@ -4381,24 +4384,6 @@ let Logger$1 = class Logger {
     }
 };
 
-/**
- * Returns true if the two passed Uint8Arrays have the same content
- */
-function equals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    for (let i = 0; i < a.byteLength; i++) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);
 const N2 = Math.pow(2, 14);
@@ -4635,7 +4620,7 @@ function asUint8Array(buf) {
 /**
  * Returns a new Uint8Array created by concatenating the passed Uint8Arrays
  */
-function concat$1(arrays, length) {
+function concat(arrays, length) {
     if (length == null) {
         length = arrays.reduce((acc, curr) => acc + curr.length, 0);
     }
@@ -5158,10 +5143,10 @@ function convertToBytes(proto, str) {
             return fromString(str, 'base16'); // no clue. convert from hex
     }
 }
-const decoders = Object.values(bases).map((c) => c.decoder);
+const decoders$1 = Object.values(bases).map((c) => c.decoder);
 const anybaseDecoder = (function () {
-    let acc = decoders[0].or(decoders[1]);
-    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
+    let acc = decoders$1[0].or(decoders$1[1]);
+    decoders$1.slice(2).forEach((d) => (acc = acc.or(d)));
     return acc;
 })();
 function ip2bytes(ipString) {
@@ -5193,7 +5178,7 @@ function bytes2port(buf) {
 function str2bytes(str) {
     const buf = fromString(str);
     const size = Uint8Array.from(encode$1(buf.length));
-    return concat$1([size, buf], size.length + buf.length);
+    return concat([size, buf], size.length + buf.length);
 }
 function bytes2str(buf) {
     const size = decode$1(buf);
@@ -5213,12 +5198,12 @@ function mh2bytes(hash) {
     }
     // the address is a varint prefixed multihash string representation
     const size = Uint8Array.from(encode$1(mh.length));
-    return concat$1([size, mh], size.length + mh.length);
+    return concat([size, mh], size.length + mh.length);
 }
 function mb2bytes(mbstr) {
     const mb = anybaseDecoder.decode(mbstr);
     const size = Uint8Array.from(encode$1(mb.length));
-    return concat$1([size, mb], size.length + mb.length);
+    return concat([size, mb], size.length + mb.length);
 }
 function bytes2mb(buf) {
     const size = decode$1(buf);
@@ -5255,7 +5240,7 @@ function onion2bytes(str) {
         throw new Error('Port number is not in range(1, 65536)');
     }
     const portBuf = port2bytes(port);
-    return concat$1([buf, portBuf], buf.length + portBuf.length);
+    return concat([buf, portBuf], buf.length + portBuf.length);
 }
 function onion32bytes(str) {
     const addr = str.split(':');
@@ -5273,7 +5258,7 @@ function onion32bytes(str) {
         throw new Error('Port number is not in range(1, 65536)');
     }
     const portBuf = port2bytes(port);
-    return concat$1([buf, portBuf], buf.length + portBuf.length);
+    return concat([buf, portBuf], buf.length + portBuf.length);
 }
 function bytes2onion(buf) {
     const addrBytes = buf.slice(0, buf.length - 2);
@@ -5309,7 +5294,7 @@ function stringToMultiaddrParts(str) {
         }
         p++; // advance addr part
         if (p >= parts.length) {
-            throw ParseError('invalid address: ' + str);
+            throw new ParseError('invalid address: ' + str);
         }
         // if it's a path proto, take the rest
         if (proto.path === true) {
@@ -5353,7 +5338,7 @@ function bytesToMultiaddrParts(bytes) {
         const addr = bytes.slice(i + n, i + n + size);
         i += (size + n);
         if (i > bytes.length) { // did not end _exactly_ at buffer.length
-            throw ParseError('Invalid address Uint8Array: ' + toString$1(bytes, 'base16'));
+            throw new ParseError('Invalid address Uint8Array: ' + toString$1(bytes, 'base16'));
         }
         // ok, tuple seems good.
         tuples.push([code, addr]);
@@ -5376,7 +5361,7 @@ function bytesToMultiaddrParts(bytes) {
     };
 }
 /**
- * [[str name, str addr]... ] -> string
+ * [[num code, str value?]... ] -> string
  */
 function stringTuplesToString(tuples) {
     const parts = [];
@@ -5394,11 +5379,11 @@ function stringTuplesToString(tuples) {
  * [[int code, Uint8Array ]... ] -> Uint8Array
  */
 function tuplesToBytes(tuples) {
-    return concat$1(tuples.map((tup) => {
+    return concat(tuples.map((tup) => {
         const proto = getProtocol(tup[0]);
         let buf = Uint8Array.from(encode$1(proto.code));
         if (tup.length > 1 && tup[1] != null) {
-            buf = concat$1([buf, tup[1]]); // add address buffer
+            buf = concat([buf, tup[1]]); // add address buffer
         }
         return buf;
     }));
@@ -5421,12 +5406,35 @@ function sizeForAddr(p, addr) {
 function cleanPath(str) {
     return '/' + str.trim().split('/').filter((a) => a).join('/');
 }
-function ParseError(str) {
-    return new Error('Error parsing address: ' + str);
+class ParseError extends Error {
+    static name = 'ParseError';
+    name = 'ParseError';
+    constructor(str) {
+        super(`Error parsing address: ${str}`);
+    }
+}
+
+/**
+ * Returns true if the two passed Uint8Arrays have the same content
+ */
+function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
 }
 
+/* eslint-disable complexity */
 const inspect$1 = Symbol.for('nodejs.util.inspect.custom');
-const symbol = Symbol.for('@multiformats/js-multiaddr/multiaddr');
+const symbol$1 = Symbol.for('@multiformats/js-multiaddr/multiaddr');
 const DNS_CODES = [
     getProtocol('dns').code,
     getProtocol('dns4').code,
@@ -5448,7 +5456,7 @@ class Multiaddr {
     #tuples;
     #stringTuples;
     #path;
-    [symbol] = true;
+    [symbol$1] = true;
     constructor(addr) {
         // default
         if (addr == null) {
@@ -5500,17 +5508,17 @@ class Multiaddr {
             }
             // default to https when protocol & port are omitted from DNS addrs
             if (DNS_CODES.includes(code)) {
-                transport = tcp.name;
+                transport = tcp.name === 'tcp' ? 'tcp' : 'udp';
                 port = 443;
                 host = `${value ?? ''}${zone}`;
                 family = code === dns6.code ? 6 : 4;
             }
             if (code === tcp.code || code === udp.code) {
-                transport = getProtocol(code).name;
+                transport = getProtocol(code).name === 'tcp' ? 'tcp' : 'udp';
                 port = parseInt(value ?? '');
             }
             if (code === ip4.code || code === ip6.code) {
-                transport = getProtocol(code).name;
+                transport = getProtocol(code).name === 'tcp' ? 'tcp' : 'udp';
                 host = `${value ?? ''}${zone}`;
                 family = code === ip6.code ? 6 : 4;
             }
@@ -5777,7 +5785,7 @@ const resolvers = new Map();
  * ```
  */
 function isMultiaddr(value) {
-    return Boolean(value?.[symbol]);
+    return Boolean(value?.[symbol$1]);
 }
 /**
  * A function that takes a {@link MultiaddrInput} and returns a {@link Multiaddr}
@@ -9058,3255 +9066,711 @@ var PrivateKey;
     };
 })(PrivateKey || (PrivateKey = {}));
 
-/*!
- * 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.
- * 
+/**
+ * @packageDocumentation
+ *
+ * A class that lets you do operations over a list of Uint8Arrays without
+ * copying them.
+ *
+ * ```js
+ * import { Uint8ArrayList } from 'uint8arraylist'
+ *
+ * const list = new Uint8ArrayList()
+ * list.append(Uint8Array.from([0, 1, 2]))
+ * list.append(Uint8Array.from([3, 4, 5]))
+ *
+ * list.subarray()
+ * // -> Uint8Array([0, 1, 2, 3, 4, 5])
+ *
+ * list.consume(3)
+ * list.subarray()
+ * // -> Uint8Array([3, 4, 5])
+ *
+ * // you can also iterate over the list
+ * for (const buf of list) {
+ *   // ..do something with `buf`
+ * }
+ *
+ * list.subarray(0, 1)
+ * // -> Uint8Array([0])
+ * ```
+ *
+ * ## Converting Uint8ArrayLists to Uint8Arrays
+ *
+ * There are two ways to turn a `Uint8ArrayList` into a `Uint8Array` - `.slice` and `.subarray` and one way to turn a `Uint8ArrayList` into a `Uint8ArrayList` with different contents - `.sublist`.
+ *
+ * ### slice
+ *
+ * Slice follows the same semantics as [Uint8Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) in that it creates a new `Uint8Array` and copies bytes into it using an optional offset & length.
+ *
+ * ```js
+ * const list = new Uint8ArrayList()
+ * list.append(Uint8Array.from([0, 1, 2]))
+ * list.append(Uint8Array.from([3, 4, 5]))
+ *
+ * list.slice(0, 1)
+ * // -> Uint8Array([0])
+ * ```
+ *
+ * ### subarray
+ *
+ * Subarray attempts to follow the same semantics as [Uint8Array.subarray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) with one important different - this is a no-copy operation, unless the requested bytes span two internal buffers in which case it is a copy operation.
+ *
+ * ```js
+ * const list = new Uint8ArrayList()
+ * list.append(Uint8Array.from([0, 1, 2]))
+ * list.append(Uint8Array.from([3, 4, 5]))
+ *
+ * list.subarray(0, 1)
+ * // -> Uint8Array([0]) - no-copy
+ *
+ * list.subarray(2, 5)
+ * // -> Uint8Array([2, 3, 4]) - copy
+ * ```
+ *
+ * ### sublist
+ *
+ * Sublist creates and returns a new `Uint8ArrayList` that shares the underlying buffers with the original so is always a no-copy operation.
+ *
+ * ```js
+ * const list = new Uint8ArrayList()
+ * list.append(Uint8Array.from([0, 1, 2]))
+ * list.append(Uint8Array.from([3, 4, 5]))
+ *
+ * list.sublist(0, 1)
+ * // -> Uint8ArrayList([0]) - no-copy
+ *
+ * list.sublist(2, 5)
+ * // -> Uint8ArrayList([2], [3, 4]) - no-copy
+ * ```
+ *
+ * ## Inspiration
+ *
+ * Borrows liberally from [bl](https://www.npmjs.com/package/bl) but only uses native JS types.
  */
-
-const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
-class BufferSourceConverter {
-    static isArrayBuffer(data) {
-        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
+const symbol = Symbol.for('@achingbrain/uint8arraylist');
+function findBufAndOffset(bufs, index) {
+    if (index == null || index < 0) {
+        throw new RangeError('index is out of bounds');
     }
-    static toArrayBuffer(data) {
-        if (this.isArrayBuffer(data)) {
-            return data;
-        }
-        if (data.byteLength === data.buffer.byteLength) {
-            return data.buffer;
+    let offset = 0;
+    for (const buf of bufs) {
+        const bufEnd = offset + buf.byteLength;
+        if (index < bufEnd) {
+            return {
+                buf,
+                index: index - offset
+            };
         }
-        if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-            return data.buffer;
+        offset = bufEnd;
+    }
+    throw new RangeError('index is out of bounds');
+}
+/**
+ * Check if object is a CID instance
+ *
+ * @example
+ *
+ * ```js
+ * import { isUint8ArrayList, Uint8ArrayList } from 'uint8arraylist'
+ *
+ * isUint8ArrayList(true) // false
+ * isUint8ArrayList([]) // false
+ * isUint8ArrayList(new Uint8ArrayList()) // true
+ * ```
+ */
+function isUint8ArrayList(value) {
+    return Boolean(value?.[symbol]);
+}
+class Uint8ArrayList {
+    bufs;
+    length;
+    [symbol] = true;
+    constructor(...data) {
+        this.bufs = [];
+        this.length = 0;
+        if (data.length > 0) {
+            this.appendAll(data);
         }
-        return this.toUint8Array(data.buffer)
-            .slice(data.byteOffset, data.byteOffset + data.byteLength)
-            .buffer;
     }
-    static toUint8Array(data) {
-        return this.toView(data, Uint8Array);
+    *[Symbol.iterator]() {
+        yield* this.bufs;
     }
-    static toView(data, type) {
-        if (data.constructor === type) {
-            return data;
-        }
-        if (this.isArrayBuffer(data)) {
-            return new type(data);
+    get byteLength() {
+        return this.length;
+    }
+    /**
+     * Add one or more `bufs` to the end of this Uint8ArrayList
+     */
+    append(...bufs) {
+        this.appendAll(bufs);
+    }
+    /**
+     * Add all `bufs` to the end of this Uint8ArrayList
+     */
+    appendAll(bufs) {
+        let length = 0;
+        for (const buf of bufs) {
+            if (buf instanceof Uint8Array) {
+                length += buf.byteLength;
+                this.bufs.push(buf);
+            }
+            else if (isUint8ArrayList(buf)) {
+                length += buf.byteLength;
+                this.bufs.push(...buf.bufs);
+            }
+            else {
+                throw new Error('Could not append value, must be an Uint8Array or a Uint8ArrayList');
+            }
         }
-        if (this.isArrayBufferView(data)) {
-            return new type(data.buffer, data.byteOffset, data.byteLength);
+        this.length += length;
+    }
+    /**
+     * Add one or more `bufs` to the start of this Uint8ArrayList
+     */
+    prepend(...bufs) {
+        this.prependAll(bufs);
+    }
+    /**
+     * Add all `bufs` to the start of this Uint8ArrayList
+     */
+    prependAll(bufs) {
+        let length = 0;
+        for (const buf of bufs.reverse()) {
+            if (buf instanceof Uint8Array) {
+                length += buf.byteLength;
+                this.bufs.unshift(buf);
+            }
+            else if (isUint8ArrayList(buf)) {
+                length += buf.byteLength;
+                this.bufs.unshift(...buf.bufs);
+            }
+            else {
+                throw new Error('Could not prepend value, must be an Uint8Array or a Uint8ArrayList');
+            }
         }
-        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+        this.length += length;
     }
-    static isBufferSource(data) {
-        return this.isArrayBufferView(data)
-            || this.isArrayBuffer(data);
+    /**
+     * Read the value at `index`
+     */
+    get(index) {
+        const res = findBufAndOffset(this.bufs, index);
+        return res.buf[res.index];
     }
-    static isArrayBufferView(data) {
-        return ArrayBuffer.isView(data)
-            || (data && this.isArrayBuffer(data.buffer));
+    /**
+     * Set the value at `index` to `value`
+     */
+    set(index, value) {
+        const res = findBufAndOffset(this.bufs, index);
+        res.buf[res.index] = value;
     }
-    static isEqual(a, b) {
-        const aView = BufferSourceConverter.toUint8Array(a);
-        const bView = BufferSourceConverter.toUint8Array(b);
-        if (aView.length !== bView.byteLength) {
-            return false;
+    /**
+     * Copy bytes from `buf` to the index specified by `offset`
+     */
+    write(buf, offset = 0) {
+        if (buf instanceof Uint8Array) {
+            for (let i = 0; i < buf.length; i++) {
+                this.set(offset + i, buf[i]);
+            }
         }
-        for (let i = 0; i < aView.length; i++) {
-            if (aView[i] !== bView[i]) {
-                return false;
+        else if (isUint8ArrayList(buf)) {
+            for (let i = 0; i < buf.length; i++) {
+                this.set(offset + i, buf.get(i));
             }
         }
-        return true;
+        else {
+            throw new Error('Could not write value, must be an Uint8Array or a Uint8ArrayList');
+        }
     }
-    static concat(...args) {
-        let buffers;
-        if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
-            buffers = args[0];
+    /**
+     * Remove bytes from the front of the pool
+     */
+    consume(bytes) {
+        // first, normalize the argument, in accordance with how Buffer does it
+        bytes = Math.trunc(bytes);
+        // do nothing if not a positive number
+        if (Number.isNaN(bytes) || bytes <= 0) {
+            return;
         }
-        else if (Array.isArray(args[0]) && args[1] instanceof Function) {
-            buffers = args[0];
+        // if consuming all bytes, skip iterating
+        if (bytes === this.byteLength) {
+            this.bufs = [];
+            this.length = 0;
+            return;
         }
-        else {
-            if (args[args.length - 1] instanceof Function) {
-                buffers = args.slice(0, args.length - 1);
+        while (this.bufs.length > 0) {
+            if (bytes >= this.bufs[0].byteLength) {
+                bytes -= this.bufs[0].byteLength;
+                this.length -= this.bufs[0].byteLength;
+                this.bufs.shift();
             }
             else {
-                buffers = args;
+                this.bufs[0] = this.bufs[0].subarray(bytes);
+                this.length -= bytes;
+                break;
             }
         }
-        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;
+    /**
+     * Extracts a section of an array and returns a new array.
+     *
+     * This is a copy operation as it is with Uint8Arrays and Arrays
+     * - note this is different to the behaviour of Node Buffers.
+     */
+    slice(beginInclusive, endExclusive) {
+        const { bufs, length } = this._subList(beginInclusive, endExclusive);
+        return concat(bufs, length);
     }
-    static toString(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        let encodedString = "";
-        for (let i = 0; i < buf.length; i++) {
-            encodedString += String.fromCharCode(buf[i]);
+    /**
+     * Returns a alloc from the given start and end element index.
+     *
+     * In the best case where the data extracted comes from a single Uint8Array
+     * internally this is a no-copy operation otherwise it is a copy operation.
+     */
+    subarray(beginInclusive, endExclusive) {
+        const { bufs, length } = this._subList(beginInclusive, endExclusive);
+        if (bufs.length === 1) {
+            return bufs[0];
         }
-        const decodedString = decodeURIComponent(escape(encodedString));
-        return decodedString;
+        return concat(bufs, length);
     }
-}
-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;
+    /**
+     * Returns a allocList from the given start and end element index.
+     *
+     * This is a no-copy operation.
+     */
+    sublist(beginInclusive, endExclusive) {
+        const { bufs, length } = this._subList(beginInclusive, endExclusive);
+        const list = new Uint8ArrayList();
+        list.length = length;
+        // don't loop, just set the bufs
+        list.bufs = [...bufs];
+        return list;
     }
-    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);
+    _subList(beginInclusive, endExclusive) {
+        beginInclusive = beginInclusive ?? 0;
+        endExclusive = endExclusive ?? this.length;
+        if (beginInclusive < 0) {
+            beginInclusive = this.length + beginInclusive;
         }
-        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}'`);
+        if (endExclusive < 0) {
+            endExclusive = this.length + endExclusive;
         }
-    }
-    static ToBase64(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        if (typeof btoa !== "undefined") {
-            const binary = this.ToString(buf, "binary");
-            return btoa(binary);
+        if (beginInclusive < 0 || endExclusive > this.length) {
+            throw new RangeError('index is out of bounds');
         }
-        else {
-            return Buffer.from(buf).toString("base64");
+        if (beginInclusive === endExclusive) {
+            return { bufs: [], length: 0 };
         }
-    }
-    static FromBase64(base64) {
-        const formatted = this.formatString(base64);
-        if (!formatted) {
-            return new ArrayBuffer(0);
+        if (beginInclusive === 0 && endExclusive === this.length) {
+            return { bufs: this.bufs, length: this.length };
         }
-        if (!Convert.isBase64(formatted)) {
-            throw new TypeError("Argument 'base64Text' is not Base64 encoded");
+        const bufs = [];
+        let offset = 0;
+        for (let i = 0; i < this.bufs.length; i++) {
+            const buf = this.bufs[i];
+            const bufStart = offset;
+            const bufEnd = bufStart + buf.byteLength;
+            // for next loop
+            offset = bufEnd;
+            if (beginInclusive >= bufEnd) {
+                // start after this buf
+                continue;
+            }
+            const sliceStartInBuf = beginInclusive >= bufStart && beginInclusive < bufEnd;
+            const sliceEndsInBuf = endExclusive > bufStart && endExclusive <= bufEnd;
+            if (sliceStartInBuf && sliceEndsInBuf) {
+                // slice is wholly contained within this buffer
+                if (beginInclusive === bufStart && endExclusive === bufEnd) {
+                    // requested whole buffer
+                    bufs.push(buf);
+                    break;
+                }
+                // requested part of buffer
+                const start = beginInclusive - bufStart;
+                bufs.push(buf.subarray(start, start + (endExclusive - beginInclusive)));
+                break;
+            }
+            if (sliceStartInBuf) {
+                // slice starts in this buffer
+                if (beginInclusive === 0) {
+                    // requested whole buffer
+                    bufs.push(buf);
+                    continue;
+                }
+                // requested part of buffer
+                bufs.push(buf.subarray(beginInclusive - bufStart));
+                continue;
+            }
+            if (sliceEndsInBuf) {
+                if (endExclusive === bufEnd) {
+                    // requested whole buffer
+                    bufs.push(buf);
+                    break;
+                }
+                // requested part of buffer
+                bufs.push(buf.subarray(0, endExclusive - bufStart));
+                break;
+            }
+            // slice started before this buffer and ends after it
+            bufs.push(buf);
         }
-        if (typeof atob !== "undefined") {
-            return this.FromBinary(atob(formatted));
+        return { bufs, length: endExclusive - beginInclusive };
+    }
+    indexOf(search, offset = 0) {
+        if (!isUint8ArrayList(search) && !(search instanceof Uint8Array)) {
+            throw new TypeError('The "value" argument must be a Uint8ArrayList or Uint8Array');
         }
-        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}'`);
+        const needle = search instanceof Uint8Array ? search : search.subarray();
+        offset = Number(offset ?? 0);
+        if (isNaN(offset)) {
+            offset = 0;
         }
-    }
-    static FromBinary(text) {
-        const stringLength = text.length;
-        const resultView = new Uint8Array(stringLength);
-        for (let i = 0; i < stringLength; i++) {
-            resultView[i] = text.charCodeAt(i);
+        if (offset < 0) {
+            offset = this.length + offset;
         }
-        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]);
+        if (offset < 0) {
+            offset = 0;
         }
-        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";
+        if (search.length === 0) {
+            return offset > this.length ? this.length : offset;
+        }
+        // https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string-search_algorithm
+        const M = needle.byteLength;
+        if (M === 0) {
+            throw new TypeError('search must be at least 1 byte long');
+        }
+        // radix
+        const radix = 256;
+        const rightmostPositions = new Int32Array(radix);
+        // position of the rightmost occurrence of the byte c in the pattern
+        for (let c = 0; c < radix; c++) {
+            // -1 for bytes not in pattern
+            rightmostPositions[c] = -1;
+        }
+        for (let j = 0; j < M; j++) {
+            // rightmost position for bytes in pattern
+            rightmostPositions[needle[j]] = j;
+        }
+        // Return offset of first match, -1 if no match
+        const right = rightmostPositions;
+        const lastIndex = this.byteLength - needle.byteLength;
+        const lastPatIndex = needle.byteLength - 1;
+        let skip;
+        for (let i = offset; i <= lastIndex; i += skip) {
+            skip = 0;
+            for (let j = lastPatIndex; j >= 0; j--) {
+                const char = this.get(i + j);
+                if (needle[j] !== char) {
+                    skip = Math.max(1, j - right[char]);
+                    break;
+                }
+            }
+            if (skip === 0) {
+                return i;
             }
-            result += byte.toString(16);
         }
-        return result;
+        return -1;
+    }
+    getInt8(byteOffset) {
+        const buf = this.subarray(byteOffset, byteOffset + 1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getInt8(0);
+    }
+    setInt8(byteOffset, value) {
+        const buf = allocUnsafe(1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setInt8(0, value);
+        this.write(buf, byteOffset);
+    }
+    getInt16(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getInt16(0, littleEndian);
+    }
+    setInt16(byteOffset, value, littleEndian) {
+        const buf = alloc$1(2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setInt16(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getInt32(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getInt32(0, littleEndian);
+    }
+    setInt32(byteOffset, value, littleEndian) {
+        const buf = alloc$1(4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setInt32(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getBigInt64(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getBigInt64(0, littleEndian);
+    }
+    setBigInt64(byteOffset, value, littleEndian) {
+        const buf = alloc$1(8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setBigInt64(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getUint8(byteOffset) {
+        const buf = this.subarray(byteOffset, byteOffset + 1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getUint8(0);
+    }
+    setUint8(byteOffset, value) {
+        const buf = allocUnsafe(1);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setUint8(0, value);
+        this.write(buf, byteOffset);
+    }
+    getUint16(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getUint16(0, littleEndian);
+    }
+    setUint16(byteOffset, value, littleEndian) {
+        const buf = alloc$1(2);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setUint16(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getUint32(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getUint32(0, littleEndian);
+    }
+    setUint32(byteOffset, value, littleEndian) {
+        const buf = alloc$1(4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setUint32(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getBigUint64(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getBigUint64(0, littleEndian);
+    }
+    setBigUint64(byteOffset, value, littleEndian) {
+        const buf = alloc$1(8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setBigUint64(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getFloat32(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getFloat32(0, littleEndian);
+    }
+    setFloat32(byteOffset, value, littleEndian) {
+        const buf = alloc$1(4);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setFloat32(0, value, littleEndian);
+        this.write(buf, byteOffset);
+    }
+    getFloat64(byteOffset, littleEndian) {
+        const buf = this.subarray(byteOffset, byteOffset + 8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        return view.getFloat64(0, littleEndian);
+    }
+    setFloat64(byteOffset, value, littleEndian) {
+        const buf = alloc$1(8);
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        view.setFloat64(0, value, littleEndian);
+        this.write(buf, byteOffset);
     }
-    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");
+    equals(other) {
+        if (other == null) {
+            return false;
         }
-        if (formatted.length % 2) {
-            formatted = `0${formatted}`;
+        if (!(other instanceof Uint8ArrayList)) {
+            return false;
         }
-        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);
+        if (other.bufs.length !== this.bufs.length) {
+            return false;
         }
-        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 += "=";
+        for (let i = 0; i < this.bufs.length; i++) {
+            if (!equals(this.bufs[i], other.bufs[i])) {
+                return false;
             }
         }
-        return base64;
+        return true;
     }
-    static formatString(data) {
-        return (data === null || data === undefined ? undefined : data.replace(/[\n\r\t ]/g, "")) || "";
+    /**
+     * Create a Uint8ArrayList from a pre-existing list of Uint8Arrays.  Use this
+     * method if you know the total size of all the Uint8Arrays ahead of time.
+     */
+    static fromUint8Arrays(bufs, length) {
+        const list = new Uint8ArrayList();
+        list.bufs = bufs;
+        if (length == null) {
+            length = bufs.reduce((acc, curr) => acc + curr.byteLength, 0);
+        }
+        list.length = length;
+        return list;
     }
 }
-Convert.DEFAULT_UTF8_ENCODING = "utf8";
+/*
+function indexOf (needle: Uint8Array, haystack: Uint8Array, offset = 0) {
+  for (let i = offset; i < haystack.byteLength; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        break
+      }
 
-var BufferSourceConverter_1 = BufferSourceConverter;
-var Convert_1 = Convert;
-
-/*!
- 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.
- * 
- */
+      if (j === needle.byteLength -1) {
+        return i
+      }
+    }
 
+    if (haystack.byteLength - i < needle.byteLength) {
+      break
+    }
+  }
 
-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 {
-            constructor(...args) {
-                var _a;
-                super(...args);
-                const params = args[0] || {};
-                this.isHexOnly = (_a = params.isHexOnly) !== null && _a !== undefined ? _a : false;
-                this.valueHexView = params.valueHex ? BufferSourceConverter_1.toUint8Array(params.valueHex) : EMPTY_VIEW;
-            }
-            get valueHex() {
-                return this.valueHexView.slice().buffer;
-            }
-            set valueHex(value) {
-                this.valueHexView = new Uint8Array(value);
-            }
-            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_1.ToHex(this.valueHexView),
-                };
-            }
-        },
-        _a.NAME = "hexBlock",
-        _a;
-}
-
-class LocalBaseBlock {
-    constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW, } = {}) {
-        this.blockLength = blockLength;
-        this.error = error;
-        this.warnings = warnings;
-        this.valueBeforeDecodeView = BufferSourceConverter_1.toUint8Array(valueBeforeDecode);
-    }
-    static blockName() {
-        return this.NAME;
-    }
-    get valueBeforeDecode() {
-        return this.valueBeforeDecodeView.slice().buffer;
-    }
-    set valueBeforeDecode(value) {
-        this.valueBeforeDecodeView = new Uint8Array(value);
-    }
-    toJSON() {
-        return {
-            blockName: this.constructor.NAME,
-            blockLength: this.blockLength,
-            error: this.error,
-            warnings: this.warnings,
-            valueBeforeDecode: Convert_1.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 !== undefined ? _a : false;
-            this.valueHexView = idBlock.valueHex ? BufferSourceConverter_1.toUint8Array(idBlock.valueHex) : EMPTY_VIEW;
-            this.tagClass = (_b = idBlock.tagClass) !== null && _b !== undefined ? _b : -1;
-            this.tagNumber = (_c = idBlock.tagNumber) !== null && _c !== undefined ? _c : -1;
-            this.isConstructed = (_d = idBlock.isConstructed) !== null && _d !== undefined ? _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_1.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 !== undefined ? _a : false;
-        this.longFormUsed = (_b = lenBlock.longFormUsed) !== null && _b !== undefined ? _b : false;
-        this.length = (_c = lenBlock.length) !== null && _c !== undefined ? _c : 0;
-    }
-    fromBER(inputBuffer, inputOffset, inputLength) {
-        const view = BufferSourceConverter_1.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_1.ToHex(this.toBER());
-    }
-    onAsciiEncoding() {
-        return `${this.constructor.NAME} : ${Convert_1.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
-    }
-    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) {
-    if (baseBlock instanceof typeStore.Constructed) {
-        for (const value of baseBlock.valueBlock.value) {
-            if (prepareIndefiniteForm(value)) {
-                baseBlock.lenBlock.isIndefiniteForm = true;
-            }
-        }
-    }
-    return !!baseBlock.lenBlock.isIndefiniteForm;
-}
-
-class BaseStringBlock extends BaseBlock {
-    constructor({ value = EMPTY_STRING, ...parameters } = {}, stringValueBlockType) {
-        super(parameters, stringValueBlockType);
-        if (value) {
-            this.fromString(value);
-        }
-    }
-    getValue() {
-        return this.valueBlock.value;
-    }
-    setValue(value) {
-        this.valueBlock.value = 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_1.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_1.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) {
-    constructor({ value, ...parameters } = {}) {
-        super(parameters);
-        if (parameters.valueHex) {
-            this.valueHexView = BufferSourceConverter_1.toUint8Array(parameters.valueHex);
-        }
-        else {
-            this.valueHexView = new Uint8Array(1);
-        }
-        if (value) {
-            this.value = value;
-        }
-    }
-    get value() {
-        for (const octet of this.valueHexView) {
-            if (octet > 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    set value(value) {
-        this.valueHexView[0] = value ? 0xFF : 0x00;
-    }
-    fromBER(inputBuffer, inputOffset, inputLength) {
-        const inputView = BufferSourceConverter_1.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;
-let Boolean$1 = class Boolean extends BaseBlock {
-    constructor(parameters = {}) {
-        super(parameters, LocalBooleanValueBlock);
-        this.idBlock.tagClass = 1;
-        this.idBlock.tagNumber = 1;
-    }
-    getValue() {
-        return this.valueBlock.value;
-    }
-    setValue(value) {
-        this.valueBlock.value = value;
-    }
-    onAsciiEncoding() {
-        return `${this.constructor.NAME} : ${this.getValue}`;
-    }
-};
-_a$s = Boolean$1;
-(() => {
-    typeStore.Boolean = _a$s;
-})();
-Boolean$1.NAME = "BOOLEAN";
-
-class LocalOctetStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
-    constructor({ isConstructed = false, ...parameters } = {}) {
-        super(parameters);
-        this.isConstructed = isConstructed;
-    }
-    fromBER(inputBuffer, inputOffset, inputLength) {
-        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 !== undefined ? _b : (parameters.isConstructed = !!((_c = parameters.value) === null || _c === undefined ? undefined : _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 (e) {
-            }
-        }
-        return super.fromBER(inputBuffer, inputOffset, inputLength);
-    }
-    onAsciiEncoding() {
-        if (this.valueBlock.isConstructed || (this.valueBlock.value && this.valueBlock.value.length)) {
-            return Constructed.prototype.onAsciiEncoding.call(this);
-        }
-        return `${this.constructor.NAME} : ${Convert_1.ToHex(this.valueBlock.valueHexView)}`;
-    }
-    getValue() {
-        if (!this.idBlock.isConstructed) {
-            return this.valueBlock.valueHexView.slice().buffer;
-        }
-        const array = [];
-        for (const content of this.valueBlock.value) {
-            if (content instanceof OctetString) {
-                array.push(content.valueBlock.valueHexView);
-            }
-        }
-        return BufferSourceConverter_1.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_1.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 (e) {
-            }
-        }
-        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) {
-            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 !== undefined ? _b : (parameters.isConstructed = !!((_c = parameters.value) === null || _c === undefined ? undefined : _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("");
-            return `${this.constructor.NAME} : ${bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits)}`;
-        }
-    }
-}
-_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) {
-    constructor({ value, ...parameters } = {}) {
-        super(parameters);
-        this._valueDec = 0;
-        if (parameters.valueHex) {
-            this.setValueHex();
-        }
-        if (value !== undefined) {
-            this.valueDec = value;
-        }
-    }
-    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);
-            }
-        }
-    }
-    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;
-        },
-    });
-})();
+  return -1
+}
+*/
 
-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_1.FromHex(hex));
-        if (bigIntValue < 0) {
-            const first = new Uint8Array(view.length + (view[0] & 0x80 ? 1 : 0));
-            first[0] |= 0x80;
-            const firstInt = BigInt(`0x${Convert_1.ToHex(first)}`);
-            const secondInt = firstInt + bigIntValue;
-            const second = BufferSourceConverter_1.toUint8Array(Convert_1.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 Integer({
-            valueHex: writer.final(),
-        });
-        return res;
-    }
-    convertToDER() {
-        const integer = new Integer({ valueHex: this.valueBlock.valueHexView });
-        integer.valueBlock.toDER();
-        return integer;
-    }
-    convertFromDER() {
-        return new Integer({
-            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_1.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_1.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 {
-    constructor(parameters = {}) {
-        super(parameters, LocalObjectIdentifierValueBlock);
-        this.idBlock.tagClass = 1;
-        this.idBlock.tagNumber = 6;
-    }
-    getValue() {
-        return this.valueBlock.toString();
-    }
-    setValue(value) {
-        this.valueBlock.fromString(value);
-    }
-    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_1.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_1.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 {
-    constructor(parameters = {}) {
-        super(parameters, LocalRelativeObjectIdentifierValueBlock);
-        this.idBlock.tagClass = 1;
-        this.idBlock.tagNumber = 13;
-    }
-    getValue() {
-        return this.valueBlock.toString();
-    }
-    setValue(value) {
-        this.valueBlock.fromString(value);
-    }
-    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_1.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_1.toUint8Array(inputBuffer);
-        try {
-            this.valueBlock.value = Convert_1.ToUtf8String(inputBuffer);
-        }
-        catch (ex) {
-            this.warnings.push(`Error during "decodeURIComponent": ${ex}, using raw string`);
-            this.valueBlock.value = Convert_1.ToBinary(inputBuffer);
-        }
-    }
-    fromString(inputString) {
-        this.valueBlock.valueHexView = new Uint8Array(Convert_1.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_1.ToUtf16String(inputBuffer);
-        this.valueBlock.valueHexView = BufferSourceConverter_1.toUint8Array(inputBuffer);
-    }
-    fromString(inputString) {
-        this.valueBlock.value = inputString;
-        this.valueBlock.valueHexView = new Uint8Array(Convert_1.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_1.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 !== undefined ? _b : (this.millisecond = 0);
-        this.idBlock.tagClass = 1;
-        this.idBlock.tagNumber = 24;
-    }
-    fromDate(inputDate) {
-        super.fromDate(inputDate);
-        this.millisecond = inputDate.getUTCMilliseconds();
-    }
-    toDate() {
-        return (new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond)));
-    }
-    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";
+const TAG_MASK = parseInt('11111', 2);
+const LONG_LENGTH_MASK = parseInt('10000000', 2);
+const LONG_LENGTH_BYTES_MASK = parseInt('01111111', 2);
+const decoders = {
+    0x2: readInteger,
+    0x3: readBitString,
+    0x5: readNull,
+    0x6: readObjectIdentifier,
+    0x10: readSequence,
+    0x16: readSequence,
+    0x30: readSequence
+};
+function decodeDer(buf, context = { offset: 0 }) {
+    const tag = buf[context.offset] & TAG_MASK;
+    context.offset++;
+    if (decoders[tag] != null) {
+        return decoders[tag](buf, context);
+    }
+    throw new Error('No decoder for tag ' + tag);
+}
+function readLength(buf, context) {
+    let length = 0;
+    if ((buf[context.offset] & LONG_LENGTH_MASK) === LONG_LENGTH_MASK) {
+        // long length
+        const count = buf[context.offset] & LONG_LENGTH_BYTES_MASK;
+        let str = '0x';
+        context.offset++;
+        for (let i = 0; i < count; i++, context.offset++) {
+            str += buf[context.offset].toString(16).padStart(2, '0');
+        }
+        length = parseInt(str, 16);
+    }
+    else {
+        length = buf[context.offset];
+        context.offset++;
+    }
+    return length;
+}
+function readSequence(buf, context) {
+    readLength(buf, context);
+    const entries = [];
+    while (true) {
+        if (context.offset >= buf.byteLength) {
+            break;
+        }
+        const result = decodeDer(buf, context);
+        if (result === null) {
+            break;
+        }
+        entries.push(result);
+    }
+    return entries;
+}
+function readInteger(buf, context) {
+    const length = readLength(buf, context);
+    const start = context.offset;
+    const end = context.offset + length;
+    const vals = [];
+    for (let i = start; i < end; i++) {
+        if (i === start && buf[i] === 0) {
+            continue;
+        }
+        vals.push(buf[i]);
+    }
+    context.offset += length;
+    return Uint8Array.from(vals);
+}
+function readObjectIdentifier(buf, context) {
+    const count = readLength(buf, context);
+    // skip OID
+    context.offset += count;
+    return ['oid-unimplemented'];
+}
+function readNull(buf, context) {
+    context.offset++;
+    return null;
+}
+function readBitString(buf, context) {
+    const length = readLength(buf, context);
+    const unusedBits = buf[context.offset];
+    context.offset++;
+    const bytes = buf.subarray(context.offset, context.offset + length);
+    context.offset += length;
+    if (unusedBits !== 0) {
+        // need to shift all bytes along by this many bits
+        throw new Error('Unused bits in bit string is unimplemented');
+    }
+    return decodeDer(bytes, {
+        offset: 0
+    });
+}
+function encodeNumber(value) {
+    let number = value.toString(16);
+    if (number.length % 2 === 1) {
+        number = '0' + number;
+    }
+    const array = new Uint8ArrayList();
+    for (let i = 0; i < number.length; i += 2) {
+        array.append(Uint8Array.from([parseInt(`${number[i]}${number[i + 1]}`, 16)]));
+    }
+    return array;
+}
+function encodeLength(bytes) {
+    if (bytes.byteLength < 128) {
+        return Uint8Array.from([bytes.byteLength]);
+    }
+    // long length
+    const length = encodeNumber(bytes.byteLength);
+    return new Uint8ArrayList(Uint8Array.from([
+        length.byteLength | LONG_LENGTH_MASK
+    ]), length);
+}
+function encodeInteger(value) {
+    const contents = new Uint8ArrayList();
+    const mask = parseInt('10000000', 2);
+    const positive = (value.subarray()[0] & mask) === mask;
+    if (positive) {
+        contents.append(Uint8Array.from([0]));
+    }
+    contents.append(value);
+    return new Uint8ArrayList(Uint8Array.from([0x02]), encodeLength(contents), contents);
+}
+function encodeBitString(value) {
+    // unused bits is always 0 with full-byte-only values
+    const unusedBits = Uint8Array.from([0]);
+    const contents = new Uint8ArrayList(unusedBits, value);
+    return new Uint8ArrayList(Uint8Array.from([0x03]), encodeLength(contents), contents);
+}
+function encodeSequence(values) {
+    const output = new Uint8ArrayList();
+    for (const buf of values) {
+        output.append(buf);
+    }
+    return new Uint8ArrayList(Uint8Array.from([0x30]), encodeLength(output), output);
+}
 
 /**
  * Signing a message failed
@@ -12354,16 +9818,6 @@ async function hashAndVerify$1(key, sig, msg) {
     }, false, ['verify']);
     return webcrypto.get().subtle.verify({ name: 'RSASSA-PKCS1-v1_5' }, publicKey, sig, msg instanceof Uint8Array ? msg : msg.subarray());
 }
-function rsaKeySize(jwk) {
-    if (jwk.kty !== 'RSA') {
-        throw new InvalidParametersError('invalid key type');
-    }
-    else if (jwk.n == null) {
-        throw new InvalidParametersError('invalid key modulus');
-    }
-    const bytes = fromString(jwk.n, 'base64url');
-    return bytes.length * 8;
-}
 
 class RSAPublicKey {
     type = 'RSA';
@@ -12400,87 +9854,57 @@ class RSAPublicKey {
     }
 }
 
-const MAX_RSA_KEY_SIZE = 8192;
 const SHA2_256_CODE = 0x12;
+const MAX_RSA_JWK_SIZE = 1062;
+const RSA_ALGORITHM_IDENTIFIER = Uint8Array.from([
+    0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00
+]);
 /**
- * Convert a PKIX in ASN1 DER format to a JWK key
+ * Convert a PKIX in ASN1 DER format to a JWK public key
  */
 function pkixToJwk(bytes) {
-    const { result } = fromBER(bytes);
-    // @ts-expect-error this looks fragile but DER is a canonical format so we are
-    // safe to have deeply property chains like this
-    const values = result.valueBlock.value[1].valueBlock.value[0].valueBlock.value;
+    const decoded = decodeDer(bytes, {
+        offset: 0
+    });
+    // this looks fragile but DER is a canonical format so we are safe to have
+    // deeply property chains like this
     return {
         kty: 'RSA',
-        n: asn1jsIntegerToBase64(values[0]),
-        e: asn1jsIntegerToBase64(values[1])
+        n: toString$1(decoded[1][0], 'base64url'),
+        e: toString$1(decoded[1][1], 'base64url')
     };
 }
 /**
- * Convert a JWK key to PKIX in ASN1 DER format
+ * Convert a JWK public key to PKIX in ASN1 DER format
  */
 function jwkToPkix(jwk) {
     if (jwk.n == null || jwk.e == null) {
         throw new InvalidParametersError('JWK was missing components');
     }
-    const root = new Sequence({
-        value: [
-            new Sequence({
-                value: [
-                    // rsaEncryption
-                    new ObjectIdentifier({
-                        value: '1.2.840.113549.1.1.1'
-                    }),
-                    new Null()
-                ]
-            }),
-            // this appears to be a bug in asn1js.js - this should really be a Sequence
-            // and not a BitString but it generates the same bytes as node-forge so 🤷‍♂️
-            new BitString({
-                valueHex: new Sequence({
-                    value: [
-                        Integer.fromBigInt(bufToBn(fromString(jwk.n, 'base64url'))),
-                        Integer.fromBigInt(bufToBn(fromString(jwk.e, 'base64url')))
-                    ]
-                }).toBER()
-            })
-        ]
-    });
-    const der = root.toBER();
-    return new Uint8Array(der, 0, der.byteLength);
-}
-function asn1jsIntegerToBase64(int) {
-    let buf = int.valueBlock.valueHexView;
-    // chrome rejects values with leading 0s
-    while (buf[0] === 0) {
-        buf = buf.subarray(1);
-    }
-    return toString$1(buf, 'base64url');
-}
-function bufToBn(u8) {
-    const hex = [];
-    u8.forEach(function (i) {
-        let h = i.toString(16);
-        if (h.length % 2 > 0) {
-            h = `0${h}`;
-        }
-        hex.push(h);
-    });
-    return BigInt('0x' + hex.join(''));
+    const subjectPublicKeyInfo = encodeSequence([
+        RSA_ALGORITHM_IDENTIFIER,
+        encodeBitString(encodeSequence([
+            encodeInteger(fromString(jwk.n, 'base64url')),
+            encodeInteger(fromString(jwk.e, 'base64url'))
+        ]))
+    ]);
+    return subjectPublicKeyInfo.subarray();
 }
 /**
  * Turn PKIX bytes to a PublicKey
  */
-function pkixToRSAPublicKey(bytes) {
-    const jwk = pkixToJwk(bytes);
-    if (rsaKeySize(jwk) > MAX_RSA_KEY_SIZE) {
+function pkixToRSAPublicKey(bytes, digest) {
+    if (bytes.byteLength >= MAX_RSA_JWK_SIZE) {
         throw new InvalidPublicKeyError('Key size is too large');
     }
-    const hash = sha256(PublicKey.encode({
-        Type: KeyType.RSA,
-        Data: bytes
-    }));
-    const digest = create(SHA2_256_CODE, hash);
+    const jwk = pkixToJwk(bytes);
+    if (digest == null) {
+        const hash = sha256(PublicKey.encode({
+            Type: KeyType.RSA,
+            Data: bytes
+        }));
+        digest = create(SHA2_256_CODE, hash);
+    }
     return new RSAPublicKey(jwk, digest);
 }
 
@@ -14396,7 +11820,7 @@ class EnrCreator {
     }
 }
 
-const version$2 = "logger/5.7.0";
+const version$2 = "logger/5.8.0";
 
 let _permanentCensorErrors = false;
 let _censorErrors = false;
@@ -14747,7 +12171,7 @@ class Logger {
 Logger.errors = ErrorCode;
 Logger.levels = LogLevel;
 
-const version$1 = "bytes/5.7.0";
+const version$1 = "bytes/5.8.0";
 
 const logger$1 = new Logger(version$1);
 ///////////////////////////////
@@ -14901,7 +12325,7 @@ function hexlify(value, options) {
     return logger$1.throwArgumentError("invalid hexlify value", "value", value);
 }
 
-const version = "rlp/5.7.0";
+const version = "rlp/5.8.0";
 
 const logger = new Logger(version);
 function arrayifyInteger(value) {