Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

76 files changed, 11886 insertions, 0 deletions

diff --git a/comm/third_party/asn1js/LICENSE b/comm/third_party/asn1js/LICENSE
new file mode 100644
index 0000000000..8d57190329
--- /dev/null
+++ b/comm/third_party/asn1js/LICENSE
@@ -0,0 +1,30 @@
+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.
diff --git a/comm/third_party/asn1js/asn1js.mjs b/comm/third_party/asn1js/asn1js.mjs
new file mode 100644
index 0000000000..a937f01dbc
--- /dev/null
+++ b/comm/third_party/asn1js/asn1js.mjs
@@ -0,0 +1,3913 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/pvtsutils/build/index.js
+var require_build = __commonJS({
+  "node_modules/pvtsutils/build/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
+    var BufferSourceConverter19 = class {
+      static isArrayBuffer(data) {
+        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
+      }
+      static toArrayBuffer(data) {
+        if (this.isArrayBuffer(data)) {
+          return data;
+        }
+        if (data.byteLength === data.buffer.byteLength) {
+          return data.buffer;
+        }
+        return this.toUint8Array(data).slice().buffer;
+      }
+      static toUint8Array(data) {
+        return this.toView(data, Uint8Array);
+      }
+      static toView(data, type) {
+        if (data.constructor === type) {
+          return data;
+        }
+        if (this.isArrayBuffer(data)) {
+          return new type(data);
+        }
+        if (this.isArrayBufferView(data)) {
+          return new type(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+      }
+      static isBufferSource(data) {
+        return this.isArrayBufferView(data) || this.isArrayBuffer(data);
+      }
+      static isArrayBufferView(data) {
+        return ArrayBuffer.isView(data) || data && this.isArrayBuffer(data.buffer);
+      }
+      static isEqual(a, b) {
+        const aView = BufferSourceConverter19.toUint8Array(a);
+        const bView = BufferSourceConverter19.toUint8Array(b);
+        if (aView.length !== bView.byteLength) {
+          return false;
+        }
+        for (let i = 0; i < aView.length; i++) {
+          if (aView[i] !== bView[i]) {
+            return false;
+          }
+        }
+        return true;
+      }
+      static concat(...args) {
+        if (Array.isArray(args[0])) {
+          const buffers = args[0];
+          let size = 0;
+          for (const buffer of buffers) {
+            size += buffer.byteLength;
+          }
+          const res = new Uint8Array(size);
+          let offset = 0;
+          for (const buffer of buffers) {
+            const view = this.toUint8Array(buffer);
+            res.set(view, offset);
+            offset += view.length;
+          }
+          if (args[1]) {
+            return this.toView(res, args[1]);
+          }
+          return res.buffer;
+        } else {
+          return this.concat(args);
+        }
+      }
+    };
+    var Utf8Converter = class {
+      static fromString(text) {
+        const s = unescape(encodeURIComponent(text));
+        const uintArray = new Uint8Array(s.length);
+        for (let i = 0; i < s.length; i++) {
+          uintArray[i] = s.charCodeAt(i);
+        }
+        return uintArray.buffer;
+      }
+      static toString(buffer) {
+        const buf = BufferSourceConverter19.toUint8Array(buffer);
+        let encodedString = "";
+        for (let i = 0; i < buf.length; i++) {
+          encodedString += String.fromCharCode(buf[i]);
+        }
+        const decodedString = decodeURIComponent(escape(encodedString));
+        return decodedString;
+      }
+    };
+    var Utf16Converter = class {
+      static toString(buffer, littleEndian = false) {
+        const arrayBuffer = BufferSourceConverter19.toArrayBuffer(buffer);
+        const dataView = new DataView(arrayBuffer);
+        let res = "";
+        for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
+          const code = dataView.getUint16(i, littleEndian);
+          res += String.fromCharCode(code);
+        }
+        return res;
+      }
+      static fromString(text, littleEndian = false) {
+        const res = new ArrayBuffer(text.length * 2);
+        const dataView = new DataView(res);
+        for (let i = 0; i < text.length; i++) {
+          dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
+        }
+        return res;
+      }
+    };
+    var Convert10 = class {
+      static isHex(data) {
+        return typeof data === "string" && /^[a-z0-9]+$/i.test(data);
+      }
+      static isBase64(data) {
+        return typeof data === "string" && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data);
+      }
+      static isBase64Url(data) {
+        return typeof data === "string" && /^[a-zA-Z0-9-_]+$/i.test(data);
+      }
+      static ToString(buffer, enc = "utf8") {
+        const buf = BufferSourceConverter19.toUint8Array(buffer);
+        switch (enc.toLowerCase()) {
+          case "utf8":
+            return this.ToUtf8String(buf);
+          case "binary":
+            return this.ToBinary(buf);
+          case "hex":
+            return this.ToHex(buf);
+          case "base64":
+            return this.ToBase64(buf);
+          case "base64url":
+            return this.ToBase64Url(buf);
+          case "utf16le":
+            return Utf16Converter.toString(buf, true);
+          case "utf16":
+          case "utf16be":
+            return Utf16Converter.toString(buf);
+          default:
+            throw new Error(`Unknown type of encoding '${enc}'`);
+        }
+      }
+      static FromString(str, enc = "utf8") {
+        if (!str) {
+          return new ArrayBuffer(0);
+        }
+        switch (enc.toLowerCase()) {
+          case "utf8":
+            return this.FromUtf8String(str);
+          case "binary":
+            return this.FromBinary(str);
+          case "hex":
+            return this.FromHex(str);
+          case "base64":
+            return this.FromBase64(str);
+          case "base64url":
+            return this.FromBase64Url(str);
+          case "utf16le":
+            return Utf16Converter.fromString(str, true);
+          case "utf16":
+          case "utf16be":
+            return Utf16Converter.fromString(str);
+          default:
+            throw new Error(`Unknown type of encoding '${enc}'`);
+        }
+      }
+      static ToBase64(buffer) {
+        const buf = BufferSourceConverter19.toUint8Array(buffer);
+        if (typeof btoa !== "undefined") {
+          const binary = this.ToString(buf, "binary");
+          return btoa(binary);
+        } else {
+          return Buffer.from(buf).toString("base64");
+        }
+      }
+      static FromBase64(base64) {
+        const formatted = this.formatString(base64);
+        if (!formatted) {
+          return new ArrayBuffer(0);
+        }
+        if (!Convert10.isBase64(formatted)) {
+          throw new TypeError("Argument 'base64Text' is not Base64 encoded");
+        }
+        if (typeof atob !== "undefined") {
+          return this.FromBinary(atob(formatted));
+        } else {
+          return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
+        }
+      }
+      static FromBase64Url(base64url) {
+        const formatted = this.formatString(base64url);
+        if (!formatted) {
+          return new ArrayBuffer(0);
+        }
+        if (!Convert10.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 = Convert10.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 = Convert10.DEFAULT_UTF8_ENCODING) {
+        switch (encoding) {
+          case "ascii":
+            return this.ToBinary(buffer);
+          case "utf8":
+            return Utf8Converter.toString(buffer);
+          case "utf16":
+          case "utf16be":
+            return Utf16Converter.toString(buffer);
+          case "utf16le":
+          case "usc2":
+            return Utf16Converter.toString(buffer, true);
+          default:
+            throw new Error(`Unknown type of encoding '${encoding}'`);
+        }
+      }
+      static FromBinary(text) {
+        const stringLength = text.length;
+        const resultView = new Uint8Array(stringLength);
+        for (let i = 0; i < stringLength; i++) {
+          resultView[i] = text.charCodeAt(i);
+        }
+        return resultView.buffer;
+      }
+      static ToBinary(buffer) {
+        const buf = BufferSourceConverter19.toUint8Array(buffer);
+        let res = "";
+        for (let i = 0; i < buf.length; i++) {
+          res += String.fromCharCode(buf[i]);
+        }
+        return res;
+      }
+      static ToHex(buffer) {
+        const buf = BufferSourceConverter19.toUint8Array(buffer);
+        const splitter = "";
+        const res = [];
+        const len = buf.length;
+        for (let i = 0; i < len; i++) {
+          const char = buf[i].toString(16).padStart(2, "0");
+          res.push(char);
+        }
+        return res.join(splitter);
+      }
+      static FromHex(hexString) {
+        let formatted = this.formatString(hexString);
+        if (!formatted) {
+          return new ArrayBuffer(0);
+        }
+        if (!Convert10.isHex(formatted)) {
+          throw new TypeError("Argument 'hexString' is not HEX encoded");
+        }
+        if (formatted.length % 2) {
+          formatted = `0${formatted}`;
+        }
+        const res = new Uint8Array(formatted.length / 2);
+        for (let i = 0; i < formatted.length; i = i + 2) {
+          const c = formatted.slice(i, i + 2);
+          res[i / 2] = parseInt(c, 16);
+        }
+        return res.buffer;
+      }
+      static ToUtf16String(buffer, littleEndian = false) {
+        return Utf16Converter.toString(buffer, littleEndian);
+      }
+      static FromUtf16String(text, littleEndian = false) {
+        return Utf16Converter.fromString(text, littleEndian);
+      }
+      static Base64Padding(base64) {
+        const padCount = 4 - base64.length % 4;
+        if (padCount < 4) {
+          for (let i = 0; i < padCount; i++) {
+            base64 += "=";
+          }
+        }
+        return base64;
+      }
+      static formatString(data) {
+        return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
+      }
+    };
+    Convert10.DEFAULT_UTF8_ENCODING = "utf8";
+    function assign(target, ...sources) {
+      const res = arguments[0];
+      for (let i = 1; i < arguments.length; i++) {
+        const obj = arguments[i];
+        for (const prop in obj) {
+          res[prop] = obj[prop];
+        }
+      }
+      return res;
+    }
+    function combine(...buf) {
+      const totalByteLength = buf.map((item) => item.byteLength).reduce((prev, cur) => prev + cur);
+      const res = new Uint8Array(totalByteLength);
+      let currentPos = 0;
+      buf.map((item) => new Uint8Array(item)).forEach((arr) => {
+        for (const item2 of arr) {
+          res[currentPos++] = item2;
+        }
+      });
+      return res.buffer;
+    }
+    function isEqual(bytes1, bytes2) {
+      if (!(bytes1 && bytes2)) {
+        return false;
+      }
+      if (bytes1.byteLength !== bytes2.byteLength) {
+        return false;
+      }
+      const b1 = new Uint8Array(bytes1);
+      const b2 = new Uint8Array(bytes2);
+      for (let i = 0; i < bytes1.byteLength; i++) {
+        if (b1[i] !== b2[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    exports.BufferSourceConverter = BufferSourceConverter19;
+    exports.Convert = Convert10;
+    exports.assign = assign;
+    exports.combine = combine;
+    exports.isEqual = isEqual;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Any: () => Any,
+  BaseBlock: () => BaseBlock,
+  BaseStringBlock: () => BaseStringBlock,
+  BitString: () => BitString,
+  BmpString: () => BmpString,
+  Boolean: () => Boolean,
+  CharacterString: () => CharacterString,
+  Choice: () => Choice,
+  Constructed: () => Constructed,
+  DATE: () => DATE,
+  DateTime: () => DateTime,
+  Duration: () => Duration,
+  EndOfContent: () => EndOfContent,
+  Enumerated: () => Enumerated,
+  GeneralString: () => GeneralString,
+  GeneralizedTime: () => GeneralizedTime,
+  GraphicString: () => GraphicString,
+  HexBlock: () => HexBlock,
+  IA5String: () => IA5String,
+  Integer: () => Integer,
+  Null: () => Null,
+  NumericString: () => NumericString,
+  ObjectIdentifier: () => ObjectIdentifier,
+  OctetString: () => OctetString,
+  Primitive: () => Primitive,
+  PrintableString: () => PrintableString,
+  RawData: () => RawData,
+  RelativeObjectIdentifier: () => RelativeObjectIdentifier,
+  Repeated: () => Repeated,
+  Sequence: () => Sequence,
+  Set: () => Set,
+  TIME: () => TIME,
+  TeletexString: () => TeletexString,
+  TimeOfDay: () => TimeOfDay,
+  UTCTime: () => UTCTime,
+  UniversalString: () => UniversalString,
+  Utf8String: () => Utf8String,
+  ValueBlock: () => ValueBlock,
+  VideotexString: () => VideotexString,
+  ViewWriter: () => ViewWriter,
+  VisibleString: () => VisibleString,
+  compareSchema: () => compareSchema,
+  fromBER: () => fromBER,
+  verifySchema: () => verifySchema
+});
+
+// src/internals/utils.ts
+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;
+}
+
+// src/ViewWriter.ts
+var ViewWriter = class {
+  constructor() {
+    this.items = [];
+  }
+  /**
+   * Writes buffer
+   * @param buf
+   */
+  write(buf) {
+    this.items.push(buf);
+  }
+  /**
+   * Concatenates all buffers
+   * @returns Concatenated buffer
+   */
+  final() {
+    return concat(this.items);
+  }
+};
+
+// src/HexBlock.ts
+var pvtsutils = __toESM(require_build());
+
+// src/internals/constants.ts
+var powers2 = [new Uint8Array([1])];
+var digitsString = "0123456789";
+var NAME = "name";
+var VALUE_HEX_VIEW = "valueHexView";
+var IS_HEX_ONLY = "isHexOnly";
+var ID_BLOCK = "idBlock";
+var TAG_CLASS = "tagClass";
+var TAG_NUMBER = "tagNumber";
+var IS_CONSTRUCTED = "isConstructed";
+var FROM_BER = "fromBER";
+var TO_BER = "toBER";
+var LOCAL = "local";
+var EMPTY_STRING = "";
+var EMPTY_BUFFER = new ArrayBuffer(0);
+var EMPTY_VIEW = new Uint8Array(0);
+var END_OF_CONTENT_NAME = "EndOfContent";
+var OCTET_STRING_NAME = "OCTET STRING";
+var BIT_STRING_NAME = "BIT STRING";
+
+// src/HexBlock.ts
+function HexBlock(BaseClass) {
+  var _a;
+  return _a = class extends BaseClass {
+    constructor(...args) {
+      var _a2;
+      super(...args);
+      const params = args[0] || {};
+      this.isHexOnly = (_a2 = params.isHexOnly) != null ? _a2 : false;
+      this.valueHexView = params.valueHex ? pvtsutils.BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
+    }
+    /**
+     * Binary data in ArrayBuffer representation
+     *
+     * @deprecated since version 3.0.0
+     */
+    get valueHex() {
+      return this.valueHexView.slice().buffer;
+    }
+    /**
+     * Binary data in ArrayBuffer representation
+     *
+     * @deprecated since version 3.0.0
+     */
+    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;
+    }
+    /**
+     * Returns a JSON representation of an object
+     * @returns JSON object
+     */
+    toJSON() {
+      return {
+        ...super.toJSON(),
+        isHexOnly: this.isHexOnly,
+        valueHex: pvtsutils.Convert.ToHex(this.valueHexView)
+      };
+    }
+  }, _a.NAME = "hexBlock", _a;
+}
+
+// src/internals/LocalBaseBlock.ts
+var pvtsutils2 = __toESM(require_build());
+var LocalBaseBlock = class {
+  /**
+   * Aux function, need to get a block name. Need to have it here for inheritance
+   * @returns Returns name of the block
+   */
+  static blockName() {
+    return this.NAME;
+  }
+  /**
+   * @deprecated since version 3.0.0
+   */
+  get valueBeforeDecode() {
+    return this.valueBeforeDecodeView.slice().buffer;
+  }
+  /**
+   * @deprecated since version 3.0.0
+   */
+  set valueBeforeDecode(value) {
+    this.valueBeforeDecodeView = new Uint8Array(value);
+  }
+  /**
+   * Creates and initializes an object instance of that class
+   * @param param0 Initialization parameters
+   */
+  constructor({
+    blockLength = 0,
+    error = EMPTY_STRING,
+    warnings = [],
+    valueBeforeDecode = EMPTY_VIEW
+  } = {}) {
+    this.blockLength = blockLength;
+    this.error = error;
+    this.warnings = warnings;
+    this.valueBeforeDecodeView = pvtsutils2.BufferSourceConverter.toUint8Array(valueBeforeDecode);
+  }
+  /**
+   * Returns a JSON representation of an object
+   * @returns JSON object
+   */
+  toJSON() {
+    return {
+      blockName: this.constructor.NAME,
+      blockLength: this.blockLength,
+      error: this.error,
+      warnings: this.warnings,
+      valueBeforeDecode: pvtsutils2.Convert.ToHex(this.valueBeforeDecodeView)
+    };
+  }
+};
+/**
+ * Name of the block
+ */
+LocalBaseBlock.NAME = "baseBlock";
+
+// src/ValueBlock.ts
+var ValueBlock = class 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";
+
+// src/BaseBlock.ts
+var pvtsutils5 = __toESM(require_build());
+
+// node_modules/pvutils/build/utils.es.js
+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] === 255 && buf[1] & 128;
+    const condition2 = buf[0] === 0 && (buf[1] & 128) === 0;
+    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] & 128;
+  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] &= 127;
+  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 retBuf2 = utilToBase(smallInt, 8, i);
+        const retView2 = new Uint8Array(retBuf2);
+        retView2[0] |= 128;
+        return retBuf2;
+      }
+      let retBuf = utilToBase(modValue, 8, i);
+      let retView = new Uint8Array(retBuf);
+      if (retView[0] & 128) {
+        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] = 0;
+      }
+      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);
+}
+var log2 = Math.log(2);
+
+// src/internals/LocalIdentificationBlock.ts
+var pvtsutils3 = __toESM(require_build());
+var LocalIdentificationBlock = class extends HexBlock(LocalBaseBlock) {
+  constructor({
+    idBlock = {}
+  } = {}) {
+    var _a, _b, _c, _d;
+    super();
+    if (idBlock) {
+      this.isHexOnly = (_a = idBlock.isHexOnly) != null ? _a : false;
+      this.valueHexView = idBlock.valueHex ? pvtsutils3.BufferSourceConverter.toUint8Array(idBlock.valueHex) : EMPTY_VIEW;
+      this.tagClass = (_b = idBlock.tagClass) != null ? _b : -1;
+      this.tagNumber = (_c = idBlock.tagNumber) != null ? _c : -1;
+      this.isConstructed = (_d = idBlock.isConstructed) != null ? _d : false;
+    } else {
+      this.tagClass = -1;
+      this.tagNumber = -1;
+      this.isConstructed = false;
+    }
+  }
+  toBER(sizeOnly = false) {
+    let firstOctet = 0;
+    switch (this.tagClass) {
+      case 1:
+        firstOctet |= 0;
+        break;
+      case 2:
+        firstOctet |= 64;
+        break;
+      case 3:
+        firstOctet |= 128;
+        break;
+      case 4:
+        firstOctet |= 192;
+        break;
+      default:
+        this.error = "Unknown tag class";
+        return EMPTY_BUFFER;
+    }
+    if (this.isConstructed)
+      firstOctet |= 32;
+    if (this.tagNumber < 31 && !this.isHexOnly) {
+      const retView2 = new Uint8Array(1);
+      if (!sizeOnly) {
+        let number = this.tagNumber;
+        number &= 31;
+        firstOctet |= number;
+        retView2[0] = firstOctet;
+      }
+      return retView2.buffer;
+    }
+    if (!this.isHexOnly) {
+      const encodedBuf = utilToBase(this.tagNumber, 7);
+      const encodedView = new Uint8Array(encodedBuf);
+      const size = encodedBuf.byteLength;
+      const retView2 = new Uint8Array(size + 1);
+      retView2[0] = firstOctet | 31;
+      if (!sizeOnly) {
+        for (let i = 0; i < size - 1; i++)
+          retView2[i + 1] = encodedView[i] | 128;
+        retView2[size] = encodedView[size - 1];
+      }
+      return retView2.buffer;
+    }
+    const retView = new Uint8Array(this.valueHexView.byteLength + 1);
+    retView[0] = firstOctet | 31;
+    if (!sizeOnly) {
+      const curView = this.valueHexView;
+      for (let i = 0; i < curView.length - 1; i++)
+        retView[i + 1] = curView[i] | 128;
+      retView[this.valueHexView.byteLength] = curView[curView.length - 1];
+    }
+    return retView.buffer;
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    const inputView = pvtsutils3.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+      return -1;
+    }
+    const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+    if (intBuffer.length === 0) {
+      this.error = "Zero buffer length";
+      return -1;
+    }
+    const tagClassMask = intBuffer[0] & 192;
+    switch (tagClassMask) {
+      case 0:
+        this.tagClass = 1;
+        break;
+      case 64:
+        this.tagClass = 2;
+        break;
+      case 128:
+        this.tagClass = 3;
+        break;
+      case 192:
+        this.tagClass = 4;
+        break;
+      default:
+        this.error = "Unknown tag class";
+        return -1;
+    }
+    this.isConstructed = (intBuffer[0] & 32) === 32;
+    this.isHexOnly = false;
+    const tagNumberMask = intBuffer[0] & 31;
+    if (tagNumberMask !== 31) {
+      this.tagNumber = tagNumberMask;
+      this.blockLength = 1;
+    } else {
+      let count = 1;
+      let intTagNumberBuffer = this.valueHexView = new Uint8Array(255);
+      let tagNumberBufferMaxLength = 255;
+      while (intBuffer[count] & 128) {
+        intTagNumberBuffer[count - 1] = intBuffer[count] & 127;
+        count++;
+        if (count >= intBuffer.length) {
+          this.error = "End of input reached before message was fully decoded";
+          return -1;
+        }
+        if (count === tagNumberBufferMaxLength) {
+          tagNumberBufferMaxLength += 255;
+          const tempBufferView2 = new Uint8Array(tagNumberBufferMaxLength);
+          for (let i = 0; i < intTagNumberBuffer.length; i++)
+            tempBufferView2[i] = intTagNumberBuffer[i];
+          intTagNumberBuffer = this.valueHexView = new Uint8Array(tagNumberBufferMaxLength);
+        }
+      }
+      this.blockLength = count + 1;
+      intTagNumberBuffer[count - 1] = intBuffer[count] & 127;
+      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;
+        default:
+      }
+    }
+    return inputOffset + this.blockLength;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      tagClass: this.tagClass,
+      tagNumber: this.tagNumber,
+      isConstructed: this.isConstructed
+    };
+  }
+};
+LocalIdentificationBlock.NAME = "identificationBlock";
+
+// src/internals/LocalLengthBlock.ts
+var pvtsutils4 = __toESM(require_build());
+var LocalLengthBlock = class extends LocalBaseBlock {
+  constructor({
+    lenBlock = {}
+  } = {}) {
+    var _a, _b, _c;
+    super();
+    this.isIndefiniteForm = (_a = lenBlock.isIndefiniteForm) != null ? _a : false;
+    this.longFormUsed = (_b = lenBlock.longFormUsed) != null ? _b : false;
+    this.length = (_c = lenBlock.length) != null ? _c : 0;
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    const view = pvtsutils4.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+      return -1;
+    }
+    const intBuffer = view.subarray(inputOffset, inputOffset + inputLength);
+    if (intBuffer.length === 0) {
+      this.error = "Zero buffer length";
+      return -1;
+    }
+    if (intBuffer[0] === 255) {
+      this.error = "Length block 0xFF is reserved by standard";
+      return -1;
+    }
+    this.isIndefiniteForm = intBuffer[0] === 128;
+    if (this.isIndefiniteForm) {
+      this.blockLength = 1;
+      return inputOffset + this.blockLength;
+    }
+    this.longFormUsed = !!(intBuffer[0] & 128);
+    if (this.longFormUsed === false) {
+      this.length = intBuffer[0];
+      this.blockLength = 1;
+      return inputOffset + this.blockLength;
+    }
+    const count = intBuffer[0] & 127;
+    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] === 0)
+      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] = 128;
+      }
+      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 | 128;
+      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";
+
+// src/TypeStore.ts
+var typeStore = {};
+
+// src/BaseBlock.ts
+var BaseBlock = class 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([128]).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 pvtsutils5.Convert.ToHex(this.toBER());
+  }
+  onAsciiEncoding() {
+    return `${this.constructor.NAME} : ${pvtsutils5.Convert.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
+  }
+  /**
+   * Determines whether two object instances are equal
+   * @param other Object to compare with the current object
+   */
+  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;
+}
+
+// src/BaseStringBlock.ts
+var BaseStringBlock = class extends BaseBlock {
+  /**
+   * String value
+   * @since 3.0.0
+   */
+  getValue() {
+    return this.valueBlock.value;
+  }
+  /**
+   * String value
+   * @param value String value
+   * @since 3.0.0
+   */
+  setValue(value) {
+    this.valueBlock.value = value;
+  }
+  constructor({
+    value = EMPTY_STRING,
+    ...parameters
+  } = {}, stringValueBlockType) {
+    super(parameters, stringValueBlockType);
+    if (value) {
+      this.fromString(value);
+    }
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length);
+    if (resultOffset === -1) {
+      this.error = this.valueBlock.error;
+      return resultOffset;
+    }
+    this.fromBuffer(this.valueBlock.valueHexView);
+    if (!this.idBlock.error.length)
+      this.blockLength += this.idBlock.blockLength;
+    if (!this.lenBlock.error.length)
+      this.blockLength += this.lenBlock.blockLength;
+    if (!this.valueBlock.error.length)
+      this.blockLength += this.valueBlock.blockLength;
+    return resultOffset;
+  }
+  onAsciiEncoding() {
+    return `${this.constructor.NAME} : '${this.valueBlock.value}'`;
+  }
+};
+BaseStringBlock.NAME = "BaseStringBlock";
+
+// src/internals/LocalPrimitiveValueBlock.ts
+var LocalPrimitiveValueBlock = class extends HexBlock(ValueBlock) {
+  constructor({
+    isHexOnly = true,
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.isHexOnly = isHexOnly;
+  }
+};
+LocalPrimitiveValueBlock.NAME = "PrimitiveValueBlock";
+
+// src/Primitive.ts
+var _Primitive = class extends BaseBlock {
+  constructor(parameters = {}) {
+    super(parameters, LocalPrimitiveValueBlock);
+    this.idBlock.isConstructed = false;
+  }
+};
+var Primitive = _Primitive;
+(() => {
+  typeStore.Primitive = _Primitive;
+})();
+Primitive.NAME = "PRIMITIVE";
+
+// src/internals/LocalConstructedValueBlock.ts
+var pvtsutils7 = __toESM(require_build());
+
+// src/parser.ts
+var pvtsutils6 = __toESM(require_build());
+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(pvtsutils6.BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength);
+}
+
+// src/internals/LocalConstructedValueBlock.ts
+function checkLen(indefiniteLength, length) {
+  if (indefiniteLength) {
+    return 1;
+  }
+  return length;
+}
+var LocalConstructedValueBlock = class extends ValueBlock {
+  constructor({
+    value = [],
+    isIndefiniteForm = false,
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.value = value;
+    this.isIndefiniteForm = isIndefiniteForm;
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    const view = pvtsutils7.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+      return -1;
+    }
+    this.valueBeforeDecodeView = view.subarray(inputOffset, inputOffset + inputLength);
+    if (this.valueBeforeDecodeView.length === 0) {
+      this.warnings.push("Zero buffer length");
+      return inputOffset;
+    }
+    let currentOffset = inputOffset;
+    while (checkLen(this.isIndefiniteForm, inputLength) > 0) {
+      const returnObject = localFromBER(view, currentOffset, inputLength);
+      if (returnObject.offset === -1) {
+        this.error = returnObject.result.error;
+        this.warnings.concat(returnObject.result.warnings);
+        return -1;
+      }
+      currentOffset = returnObject.offset;
+      this.blockLength += returnObject.result.blockLength;
+      inputLength -= returnObject.result.blockLength;
+      this.value.push(returnObject.result);
+      if (this.isIndefiniteForm && returnObject.result.constructor.NAME === END_OF_CONTENT_NAME) {
+        break;
+      }
+    }
+    if (this.isIndefiniteForm) {
+      if (this.value[this.value.length - 1].constructor.NAME === END_OF_CONTENT_NAME) {
+        this.value.pop();
+      } else {
+        this.warnings.push("No EndOfContent block encoded");
+      }
+    }
+    return currentOffset;
+  }
+  toBER(sizeOnly, writer) {
+    const _writer = writer || new ViewWriter();
+    for (let i = 0; i < this.value.length; i++) {
+      this.value[i].toBER(sizeOnly, _writer);
+    }
+    if (!writer) {
+      return _writer.final();
+    }
+    return EMPTY_BUFFER;
+  }
+  toJSON() {
+    const object = {
+      ...super.toJSON(),
+      isIndefiniteForm: this.isIndefiniteForm,
+      value: []
+    };
+    for (const value of this.value) {
+      object.value.push(value.toJSON());
+    }
+    return object;
+  }
+};
+LocalConstructedValueBlock.NAME = "ConstructedValueBlock";
+
+// src/Constructed.ts
+var _Constructed = class 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;
+  }
+  /**
+   * @internal
+   */
+  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} :
+${values.join("\n")}` : `${blockName} :`;
+  }
+};
+var Constructed = _Constructed;
+(() => {
+  typeStore.Constructed = _Constructed;
+})();
+Constructed.NAME = "CONSTRUCTED";
+
+// src/internals/LocalEndOfContentValueBlock.ts
+var LocalEndOfContentValueBlock = class extends ValueBlock {
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    return inputOffset;
+  }
+  toBER(sizeOnly) {
+    return EMPTY_BUFFER;
+  }
+};
+LocalEndOfContentValueBlock.override = "EndOfContentValueBlock";
+
+// src/EndOfContent.ts
+var _EndOfContent = class extends BaseBlock {
+  constructor(parameters = {}) {
+    super(parameters, LocalEndOfContentValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 0;
+  }
+};
+var EndOfContent = _EndOfContent;
+(() => {
+  typeStore.EndOfContent = _EndOfContent;
+})();
+EndOfContent.NAME = END_OF_CONTENT_NAME;
+
+// src/Null.ts
+var _Null = class 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] = 5;
+      retView[1] = 0;
+    }
+    if (writer) {
+      writer.write(retBuf);
+    }
+    return retBuf;
+  }
+  onAsciiEncoding() {
+    return `${this.constructor.NAME}`;
+  }
+};
+var Null = _Null;
+(() => {
+  typeStore.Null = _Null;
+})();
+Null.NAME = "NULL";
+
+// src/internals/LocalBooleanValueBlock.ts
+var pvtsutils8 = __toESM(require_build());
+var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
+  get value() {
+    for (const octet of this.valueHexView) {
+      if (octet > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  set value(value) {
+    this.valueHexView[0] = value ? 255 : 0;
+  }
+  constructor({
+    value,
+    ...parameters
+  } = {}) {
+    super(parameters);
+    if (parameters.valueHex) {
+      this.valueHexView = pvtsutils8.BufferSourceConverter.toUint8Array(parameters.valueHex);
+    } else {
+      this.valueHexView = new Uint8Array(1);
+    }
+    if (value) {
+      this.value = value;
+    }
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    const inputView = pvtsutils8.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+      return -1;
+    }
+    this.valueHexView = inputView.subarray(inputOffset, inputOffset + inputLength);
+    if (inputLength > 1)
+      this.warnings.push("Boolean value encoded in more then 1 octet");
+    this.isHexOnly = true;
+    utilDecodeTC.call(this);
+    this.blockLength = inputLength;
+    return inputOffset + inputLength;
+  }
+  toBER() {
+    return this.valueHexView.slice();
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      value: this.value
+    };
+  }
+};
+LocalBooleanValueBlock.NAME = "BooleanValueBlock";
+
+// src/Boolean.ts
+var _Boolean = class extends BaseBlock {
+  /**
+   * Gets value
+   * @since 3.0.0
+   */
+  getValue() {
+    return this.valueBlock.value;
+  }
+  /**
+   * Sets value
+   * @param value Boolean value
+   * @since 3.0.0
+   */
+  setValue(value) {
+    this.valueBlock.value = value;
+  }
+  constructor(parameters = {}) {
+    super(parameters, LocalBooleanValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 1;
+  }
+  onAsciiEncoding() {
+    return `${this.constructor.NAME} : ${this.getValue}`;
+  }
+};
+var Boolean = _Boolean;
+(() => {
+  typeStore.Boolean = _Boolean;
+})();
+Boolean.NAME = "BOOLEAN";
+
+// src/OctetString.ts
+var pvtsutils9 = __toESM(require_build());
+
+// src/internals/LocalOctetStringValueBlock.ts
+var LocalOctetStringValueBlock = class 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";
+
+// src/OctetString.ts
+var _OctetString = class extends BaseBlock {
+  constructor({
+    idBlock = {},
+    lenBlock = {},
+    ...parameters
+  } = {}) {
+    var _a, _b;
+    (_b = parameters.isConstructed) != null ? _b : parameters.isConstructed = !!((_a = parameters.value) == null ? void 0 : _a.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} : ${pvtsutils9.Convert.ToHex(this.valueBlock.valueHexView)}`;
+  }
+  /**
+   * Returns OctetString value. If OctetString is constructed, returns concatenated internal OctetString values
+   * @returns Array buffer
+   * @since 3.0.0
+   */
+  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 pvtsutils9.BufferSourceConverter.concat(array);
+  }
+};
+var OctetString = _OctetString;
+(() => {
+  typeStore.OctetString = _OctetString;
+})();
+OctetString.NAME = OCTET_STRING_NAME;
+
+// src/internals/LocalBitStringValueBlock.ts
+var pvtsutils10 = __toESM(require_build());
+var LocalBitStringValueBlock = class 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 = pvtsutils10.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+      return -1;
+    }
+    const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+    this.unusedBits = intBuffer[0];
+    if (this.unusedBits > 7) {
+      this.error = "Unused bits for BitString must be in range 0-7";
+      return -1;
+    }
+    if (!this.unusedBits) {
+      const buf = intBuffer.subarray(1);
+      try {
+        if (buf.byteLength) {
+          const asn = localFromBER(buf, 0, buf.byteLength);
+          if (asn.offset !== -1 && asn.offset === inputLength - 1) {
+            this.value = [asn.result];
+          }
+        }
+      } catch (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";
+
+// src/BitString.ts
+var _BitString = class extends BaseBlock {
+  constructor({
+    idBlock = {},
+    lenBlock = {},
+    ...parameters
+  } = {}) {
+    var _a, _b;
+    (_b = parameters.isConstructed) != null ? _b : parameters.isConstructed = !!((_a = parameters.value) == null ? void 0 : _a.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)}`;
+    }
+  }
+};
+var BitString = _BitString;
+(() => {
+  typeStore.BitString = _BitString;
+})();
+BitString.NAME = BIT_STRING_NAME;
+
+// src/Integer.ts
+var pvtsutils11 = __toESM(require_build());
+
+// src/internals/LocalIntegerValueBlock.ts
+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();
+}
+var _LocalIntegerValueBlock = class extends HexBlock(ValueBlock) {
+  constructor({
+    value,
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this._valueDec = 0;
+    if (parameters.valueHex) {
+      this.setValueHex();
+    }
+    if (value !== void 0) {
+      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] === 0 && (view[1] & 128) !== 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] & 128) !== 0:
+        {
+          const updatedView = new Uint8Array(this.valueHexView.length + 1);
+          updatedView[0] = 0;
+          updatedView.set(view, 1);
+          this.valueHexView = updatedView;
+        }
+        break;
+      case (view[0] === 0 && (view[1] & 128) === 0):
+        {
+          this.valueHexView = this.valueHexView.subarray(1);
+        }
+        break;
+      default:
+    }
+    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;
+  }
+};
+var LocalIntegerValueBlock = _LocalIntegerValueBlock;
+LocalIntegerValueBlock.NAME = "IntegerValueBlock";
+(() => {
+  Object.defineProperty(_LocalIntegerValueBlock.prototype, "valueHex", {
+    set: function(v) {
+      this.valueHexView = new Uint8Array(v);
+      this.setValueHex();
+    },
+    get: function() {
+      return this.valueHexView.slice().buffer;
+    }
+  });
+})();
+
+// src/Integer.ts
+var _Integer = class extends BaseBlock {
+  constructor(parameters = {}) {
+    super(parameters, LocalIntegerValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 2;
+  }
+  /**
+   * Converts Integer into BigInt
+   * @throws Throws Error if BigInt is not supported
+   * @since 3.0.0
+   */
+  toBigInt() {
+    assertBigInt();
+    return BigInt(this.valueBlock.toString());
+  }
+  /**
+   * Creates Integer from BigInt value
+   * @param value BigInt value
+   * @returns ASN.1 Integer
+   * @throws Throws Error if BigInt is not supported
+   * @since 3.0.0
+   */
+  static fromBigInt(value) {
+    assertBigInt();
+    const bigIntValue = BigInt(value);
+    const writer = new ViewWriter();
+    const hex = bigIntValue.toString(16).replace(/^-/, "");
+    const view = new Uint8Array(pvtsutils11.Convert.FromHex(hex));
+    if (bigIntValue < 0) {
+      const first = new Uint8Array(view.length + (view[0] & 128 ? 1 : 0));
+      first[0] |= 128;
+      const firstInt = BigInt(`0x${pvtsutils11.Convert.ToHex(first)}`);
+      const secondInt = firstInt + bigIntValue;
+      const second = pvtsutils11.BufferSourceConverter.toUint8Array(pvtsutils11.Convert.FromHex(secondInt.toString(16)));
+      second[0] |= 128;
+      writer.write(second);
+    } else {
+      if (view[0] & 128) {
+        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;
+  }
+  /**
+   * Convert current Integer value from DER to BER format
+   * @returns
+   */
+  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()}`;
+  }
+};
+var Integer = _Integer;
+(() => {
+  typeStore.Integer = _Integer;
+})();
+Integer.NAME = "INTEGER";
+
+// src/Enumerated.ts
+var _Enumerated = class extends Integer {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 10;
+  }
+};
+var Enumerated = _Enumerated;
+(() => {
+  typeStore.Enumerated = _Enumerated;
+})();
+Enumerated.NAME = "ENUMERATED";
+
+// src/internals/LocalSidValueBlock.ts
+var pvtsutils12 = __toESM(require_build());
+var LocalSidValueBlock = class 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 = pvtsutils12.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+      return -1;
+    }
+    const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+    this.valueHexView = new Uint8Array(inputLength);
+    for (let i = 0; i < inputLength; i++) {
+      this.valueHexView[i] = intBuffer[i] & 127;
+      this.blockLength++;
+      if ((intBuffer[i] & 128) === 0)
+        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] & 128) !== 0) {
+      this.error = "End of input reached before message was fully decoded";
+      return -1;
+    }
+    if (this.valueHexView[0] === 0)
+      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 ? 128 : 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 retView2 = new Uint8Array(this.blockLength);
+      for (let i = 0; i < this.blockLength - 1; i++)
+        retView2[i] = curView[i] | 128;
+      retView2[this.blockLength - 1] = curView[this.blockLength - 1];
+      return retView2.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] | 128;
+      retView[len] = encodedView[len];
+    }
+    return retView;
+  }
+  toString() {
+    let result = "";
+    if (this.isHexOnly)
+      result = pvtsutils12.Convert.ToHex(this.valueHexView);
+    else {
+      if (this.isFirstSid) {
+        let sidValue = this.valueDec;
+        if (this.valueDec <= 39)
+          result = "0.";
+        else {
+          if (this.valueDec <= 79) {
+            result = "1.";
+            sidValue -= 40;
+          } else {
+            result = "2.";
+            sidValue -= 80;
+          }
+        }
+        result += sidValue.toString();
+      } else
+        result = this.valueDec.toString();
+    }
+    return result;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      valueDec: this.valueDec,
+      isFirstSid: this.isFirstSid
+    };
+  }
+};
+LocalSidValueBlock.NAME = "sidBlock";
+
+// src/internals/LocalObjectIdentifierValueBlock.ts
+var LocalObjectIdentifierValueBlock = class 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";
+
+// src/ObjectIdentifier.ts
+var _ObjectIdentifier = class extends BaseBlock {
+  /**
+   * Gets string representation of Object Identifier
+   * @since 3.0.0
+   */
+  getValue() {
+    return this.valueBlock.toString();
+  }
+  /**
+   * Sets Object Identifier value from string
+   * @param value String value
+   * @since 3.0.0
+   */
+  setValue(value) {
+    this.valueBlock.fromString(value);
+  }
+  constructor(parameters = {}) {
+    super(parameters, LocalObjectIdentifierValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 6;
+  }
+  onAsciiEncoding() {
+    return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      value: this.getValue()
+    };
+  }
+};
+var ObjectIdentifier = _ObjectIdentifier;
+(() => {
+  typeStore.ObjectIdentifier = _ObjectIdentifier;
+})();
+ObjectIdentifier.NAME = "OBJECT IDENTIFIER";
+
+// src/internals/LocalRelativeSidValueBlock.ts
+var pvtsutils13 = __toESM(require_build());
+var LocalRelativeSidValueBlock = class extends HexBlock(LocalBaseBlock) {
+  constructor({
+    valueDec = 0,
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.valueDec = valueDec;
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    if (inputLength === 0)
+      return inputOffset;
+    const inputView = pvtsutils13.BufferSourceConverter.toUint8Array(inputBuffer);
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength))
+      return -1;
+    const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+    this.valueHexView = new Uint8Array(inputLength);
+    for (let i = 0; i < inputLength; i++) {
+      this.valueHexView[i] = intBuffer[i] & 127;
+      this.blockLength++;
+      if ((intBuffer[i] & 128) === 0)
+        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] & 128) !== 0) {
+      this.error = "End of input reached before message was fully decoded";
+      return -1;
+    }
+    if (this.valueHexView[0] === 0)
+      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 retView2 = new Uint8Array(this.blockLength);
+      for (let i = 0; i < this.blockLength - 1; i++)
+        retView2[i] = curView[i] | 128;
+      retView2[this.blockLength - 1] = curView[this.blockLength - 1];
+      return retView2.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] | 128;
+      retView[len] = encodedView[len];
+    }
+    return retView.buffer;
+  }
+  toString() {
+    let result = "";
+    if (this.isHexOnly)
+      result = pvtsutils13.Convert.ToHex(this.valueHexView);
+    else {
+      result = this.valueDec.toString();
+    }
+    return result;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      valueDec: this.valueDec
+    };
+  }
+};
+LocalRelativeSidValueBlock.NAME = "relativeSidBlock";
+
+// src/internals/LocalRelativeObjectIdentifierValueBlock.ts
+var LocalRelativeObjectIdentifierValueBlock = class 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";
+
+// src/RelativeObjectIdentifier.ts
+var _RelativeObjectIdentifier = class extends BaseBlock {
+  /**
+   * Gets string representation of Relative Object Identifier
+   * @since 3.0.0
+   */
+  getValue() {
+    return this.valueBlock.toString();
+  }
+  /**
+   * Sets Relative Object Identifier value from string
+   * @param value String value
+   * @since 3.0.0
+   */
+  setValue(value) {
+    this.valueBlock.fromString(value);
+  }
+  constructor(parameters = {}) {
+    super(parameters, LocalRelativeObjectIdentifierValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 13;
+  }
+  onAsciiEncoding() {
+    return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      value: this.getValue()
+    };
+  }
+};
+var RelativeObjectIdentifier = _RelativeObjectIdentifier;
+(() => {
+  typeStore.RelativeObjectIdentifier = _RelativeObjectIdentifier;
+})();
+RelativeObjectIdentifier.NAME = "RelativeObjectIdentifier";
+
+// src/Sequence.ts
+var _Sequence = class extends Constructed {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 16;
+  }
+};
+var Sequence = _Sequence;
+(() => {
+  typeStore.Sequence = _Sequence;
+})();
+Sequence.NAME = "SEQUENCE";
+
+// src/Set.ts
+var _Set = class extends Constructed {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 17;
+  }
+};
+var Set = _Set;
+(() => {
+  typeStore.Set = _Set;
+})();
+Set.NAME = "SET";
+
+// src/internals/LocalUtf8StringValueBlock.ts
+var pvtsutils15 = __toESM(require_build());
+
+// src/internals/LocalSimpleStringBlock.ts
+var pvtsutils14 = __toESM(require_build());
+
+// src/internals/LocalStringValueBlock.ts
+var LocalStringValueBlock = class extends HexBlock(ValueBlock) {
+  constructor({
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.isHexOnly = true;
+    this.value = EMPTY_STRING;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      value: this.value
+    };
+  }
+};
+LocalStringValueBlock.NAME = "StringValueBlock";
+
+// src/internals/LocalSimpleStringValueBlock.ts
+var LocalSimpleStringValueBlock = class extends LocalStringValueBlock {
+};
+LocalSimpleStringValueBlock.NAME = "SimpleStringValueBlock";
+
+// src/internals/LocalSimpleStringBlock.ts
+var LocalSimpleStringBlock = class extends BaseStringBlock {
+  constructor({
+    ...parameters
+  } = {}) {
+    super(parameters, LocalSimpleStringValueBlock);
+  }
+  fromBuffer(inputBuffer) {
+    this.valueBlock.value = String.fromCharCode.apply(null, pvtsutils14.BufferSourceConverter.toUint8Array(inputBuffer));
+  }
+  fromString(inputString) {
+    const strLen = inputString.length;
+    const view = this.valueBlock.valueHexView = new Uint8Array(strLen);
+    for (let i = 0; i < strLen; i++)
+      view[i] = inputString.charCodeAt(i);
+    this.valueBlock.value = inputString;
+  }
+};
+LocalSimpleStringBlock.NAME = "SIMPLE STRING";
+
+// src/internals/LocalUtf8StringValueBlock.ts
+var LocalUtf8StringValueBlock = class extends LocalSimpleStringBlock {
+  fromBuffer(inputBuffer) {
+    this.valueBlock.valueHexView = pvtsutils15.BufferSourceConverter.toUint8Array(inputBuffer);
+    try {
+      this.valueBlock.value = pvtsutils15.Convert.ToUtf8String(inputBuffer);
+    } catch (ex) {
+      this.warnings.push(`Error during "decodeURIComponent": ${ex}, using raw string`);
+      this.valueBlock.value = pvtsutils15.Convert.ToBinary(inputBuffer);
+    }
+  }
+  fromString(inputString) {
+    this.valueBlock.valueHexView = new Uint8Array(pvtsutils15.Convert.FromUtf8String(inputString));
+    this.valueBlock.value = inputString;
+  }
+};
+LocalUtf8StringValueBlock.NAME = "Utf8StringValueBlock";
+
+// src/Utf8String.ts
+var _Utf8String = class extends LocalUtf8StringValueBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 12;
+  }
+};
+var Utf8String = _Utf8String;
+(() => {
+  typeStore.Utf8String = _Utf8String;
+})();
+Utf8String.NAME = "UTF8String";
+
+// src/internals/LocalBmpStringValueBlock.ts
+var pvtsutils16 = __toESM(require_build());
+var LocalBmpStringValueBlock = class extends LocalSimpleStringBlock {
+  fromBuffer(inputBuffer) {
+    this.valueBlock.value = pvtsutils16.Convert.ToUtf16String(inputBuffer);
+    this.valueBlock.valueHexView = pvtsutils16.BufferSourceConverter.toUint8Array(inputBuffer);
+  }
+  fromString(inputString) {
+    this.valueBlock.value = inputString;
+    this.valueBlock.valueHexView = new Uint8Array(pvtsutils16.Convert.FromUtf16String(inputString));
+  }
+};
+LocalBmpStringValueBlock.NAME = "BmpStringValueBlock";
+
+// src/BmpString.ts
+var _BmpString = class extends LocalBmpStringValueBlock {
+  constructor({
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 30;
+  }
+};
+var BmpString = _BmpString;
+(() => {
+  typeStore.BmpString = _BmpString;
+})();
+BmpString.NAME = "BMPString";
+
+// src/internals/LocalUniversalStringValueBlockParams.ts
+var LocalUniversalStringValueBlock = class 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] = 0;
+      valueView[i + 3] = 0;
+    }
+    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";
+
+// src/UniversalString.ts
+var _UniversalString = class extends LocalUniversalStringValueBlock {
+  constructor({
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 28;
+  }
+};
+var UniversalString = _UniversalString;
+(() => {
+  typeStore.UniversalString = _UniversalString;
+})();
+UniversalString.NAME = "UniversalString";
+
+// src/NumericString.ts
+var _NumericString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 18;
+  }
+};
+var NumericString = _NumericString;
+(() => {
+  typeStore.NumericString = _NumericString;
+})();
+NumericString.NAME = "NumericString";
+
+// src/PrintableString.ts
+var _PrintableString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 19;
+  }
+};
+var PrintableString = _PrintableString;
+(() => {
+  typeStore.PrintableString = _PrintableString;
+})();
+PrintableString.NAME = "PrintableString";
+
+// src/TeletexString.ts
+var _TeletexString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 20;
+  }
+};
+var TeletexString = _TeletexString;
+(() => {
+  typeStore.TeletexString = _TeletexString;
+})();
+TeletexString.NAME = "TeletexString";
+
+// src/VideotexString.ts
+var _VideotexString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 21;
+  }
+};
+var VideotexString = _VideotexString;
+(() => {
+  typeStore.VideotexString = _VideotexString;
+})();
+VideotexString.NAME = "VideotexString";
+
+// src/IA5String.ts
+var _IA5String = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 22;
+  }
+};
+var IA5String = _IA5String;
+(() => {
+  typeStore.IA5String = _IA5String;
+})();
+IA5String.NAME = "IA5String";
+
+// src/GraphicString.ts
+var _GraphicString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 25;
+  }
+};
+var GraphicString = _GraphicString;
+(() => {
+  typeStore.GraphicString = _GraphicString;
+})();
+GraphicString.NAME = "GraphicString";
+
+// src/VisibleString.ts
+var _VisibleString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 26;
+  }
+};
+var VisibleString = _VisibleString;
+(() => {
+  typeStore.VisibleString = _VisibleString;
+})();
+VisibleString.NAME = "VisibleString";
+
+// src/GeneralString.ts
+var _GeneralString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 27;
+  }
+};
+var GeneralString = _GeneralString;
+(() => {
+  typeStore.GeneralString = _GeneralString;
+})();
+GeneralString.NAME = "GeneralString";
+
+// src/CharacterString.ts
+var _CharacterString = class extends LocalSimpleStringBlock {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 29;
+  }
+};
+var CharacterString = _CharacterString;
+(() => {
+  typeStore.CharacterString = _CharacterString;
+})();
+CharacterString.NAME = "CharacterString";
+
+// src/UTCTime.ts
+var pvtsutils17 = __toESM(require_build());
+var _UTCTime = class 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, pvtsutils17.BufferSourceConverter.toUint8Array(inputBuffer)));
+  }
+  /**
+   * Function converting ASN.1 internal string into ArrayBuffer
+   * @returns
+   */
+  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;
+  }
+  /**
+   * Function converting "Date" object into ASN.1 internal string
+   * @param {!Date} inputDate JavaScript "Date" object
+   */
+  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 = 2e3 + 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 < 2e3 ? this.year - 1900 : this.year - 2e3, 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
+    };
+  }
+};
+var UTCTime = _UTCTime;
+(() => {
+  typeStore.UTCTime = _UTCTime;
+})();
+UTCTime.NAME = "UTCTime";
+
+// src/GeneralizedTime.ts
+var _GeneralizedTime = class extends UTCTime {
+  constructor(parameters = {}) {
+    var _a;
+    super(parameters);
+    (_a = this.millisecond) != null ? _a : 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 = 1e3 * (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 = 1e3 * (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 = 1e3 * 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
+    };
+  }
+};
+var GeneralizedTime = _GeneralizedTime;
+(() => {
+  typeStore.GeneralizedTime = _GeneralizedTime;
+})();
+GeneralizedTime.NAME = "GeneralizedTime";
+
+// src/DATE.ts
+var _DATE = class extends Utf8String {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 31;
+  }
+};
+var DATE = _DATE;
+(() => {
+  typeStore.DATE = _DATE;
+})();
+DATE.NAME = "DATE";
+
+// src/TimeOfDay.ts
+var _TimeOfDay = class extends Utf8String {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 32;
+  }
+};
+var TimeOfDay = _TimeOfDay;
+(() => {
+  typeStore.TimeOfDay = _TimeOfDay;
+})();
+TimeOfDay.NAME = "TimeOfDay";
+
+// src/DateTime.ts
+var _DateTime = class extends Utf8String {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 33;
+  }
+};
+var DateTime = _DateTime;
+(() => {
+  typeStore.DateTime = _DateTime;
+})();
+DateTime.NAME = "DateTime";
+
+// src/Duration.ts
+var _Duration = class extends Utf8String {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 34;
+  }
+};
+var Duration = _Duration;
+(() => {
+  typeStore.Duration = _Duration;
+})();
+Duration.NAME = "Duration";
+
+// src/TIME.ts
+var _TIME = class extends Utf8String {
+  constructor(parameters = {}) {
+    super(parameters);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 14;
+  }
+};
+var TIME = _TIME;
+(() => {
+  typeStore.TIME = _TIME;
+})();
+TIME.NAME = "TIME";
+
+// src/Any.ts
+var Any = class {
+  constructor({
+    name = EMPTY_STRING,
+    optional = false
+  } = {}) {
+    this.name = name;
+    this.optional = optional;
+  }
+};
+
+// src/Choice.ts
+var Choice = class extends Any {
+  constructor({
+    value = [],
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.value = value;
+  }
+};
+
+// src/Repeated.ts
+var Repeated = class extends Any {
+  constructor({
+    value = new Any(),
+    local = false,
+    ...parameters
+  } = {}) {
+    super(parameters);
+    this.value = value;
+    this.local = local;
+  }
+};
+
+// src/RawData.ts
+var pvtsutils18 = __toESM(require_build());
+var RawData = class {
+  /**
+   * @deprecated Since v3.0.0
+   */
+  get data() {
+    return this.dataView.slice().buffer;
+  }
+  /**
+   * @deprecated Since v3.0.0
+   */
+  set data(value) {
+    this.dataView = pvtsutils18.BufferSourceConverter.toUint8Array(value);
+  }
+  constructor({ data = EMPTY_VIEW } = {}) {
+    this.dataView = pvtsutils18.BufferSourceConverter.toUint8Array(data);
+  }
+  fromBER(inputBuffer, inputOffset, inputLength) {
+    const endLength = inputOffset + inputLength;
+    this.dataView = pvtsutils18.BufferSourceConverter.toUint8Array(inputBuffer).subarray(inputOffset, endLength);
+    return endLength;
+  }
+  toBER(sizeOnly) {
+    return this.dataView.slice().buffer;
+  }
+};
+
+// src/schema.ts
+var pvtsutils19 = __toESM(require_build());
+function compareSchema(root, inputData, inputSchema) {
+  if (inputSchema instanceof Choice) {
+    const choiceResult = false;
+    for (let j = 0; j < inputSchema.value.length; j++) {
+      const result = compareSchema(root, inputData, inputSchema.value[j]);
+      if (result.verified) {
+        return {
+          verified: true,
+          result: root
+        };
+      }
+    }
+    if (choiceResult === false) {
+      const _result = {
+        verified: false,
+        result: {
+          error: "Wrong values for Choice type"
+        }
+      };
+      if (inputSchema.hasOwnProperty(NAME))
+        _result.name = inputSchema.name;
+      return _result;
+    }
+  }
+  if (inputSchema instanceof Any) {
+    if (inputSchema.hasOwnProperty(NAME))
+      root[inputSchema.name] = inputData;
+    return {
+      verified: true,
+      result: root
+    };
+  }
+  if (root instanceof Object === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong root object" }
+    };
+  }
+  if (inputData instanceof Object === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 data" }
+    };
+  }
+  if (inputSchema instanceof Object === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (ID_BLOCK in inputSchema === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (FROM_BER in inputSchema.idBlock === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (TO_BER in inputSchema.idBlock === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  const encodedId = inputSchema.idBlock.toBER(false);
+  if (encodedId.byteLength === 0) {
+    return {
+      verified: false,
+      result: { error: "Error encoding idBlock for ASN.1 schema" }
+    };
+  }
+  const decodedOffset = inputSchema.idBlock.fromBER(encodedId, 0, encodedId.byteLength);
+  if (decodedOffset === -1) {
+    return {
+      verified: false,
+      result: { error: "Error decoding idBlock for ASN.1 schema" }
+    };
+  }
+  if (inputSchema.idBlock.hasOwnProperty(TAG_CLASS) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (inputSchema.idBlock.tagClass !== inputData.idBlock.tagClass) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  if (inputSchema.idBlock.hasOwnProperty(TAG_NUMBER) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (inputSchema.idBlock.tagNumber !== inputData.idBlock.tagNumber) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  if (inputSchema.idBlock.hasOwnProperty(IS_CONSTRUCTED) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (inputSchema.idBlock.isConstructed !== inputData.idBlock.isConstructed) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  if (!(IS_HEX_ONLY in inputSchema.idBlock)) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  if (inputSchema.idBlock.isHexOnly !== inputData.idBlock.isHexOnly) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  if (inputSchema.idBlock.isHexOnly) {
+    if (VALUE_HEX_VIEW in inputSchema.idBlock === false) {
+      return {
+        verified: false,
+        result: { error: "Wrong ASN.1 schema" }
+      };
+    }
+    const schemaView = inputSchema.idBlock.valueHexView;
+    const asn1View = inputData.idBlock.valueHexView;
+    if (schemaView.length !== asn1View.length) {
+      return {
+        verified: false,
+        result: root
+      };
+    }
+    for (let i = 0; i < schemaView.length; i++) {
+      if (schemaView[i] !== asn1View[1]) {
+        return {
+          verified: false,
+          result: root
+        };
+      }
+    }
+  }
+  if (inputSchema.name) {
+    inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+    if (inputSchema.name)
+      root[inputSchema.name] = inputData;
+  }
+  if (inputSchema instanceof typeStore.Constructed) {
+    let admission = 0;
+    let result = {
+      verified: false,
+      result: {
+        error: "Unknown error"
+      }
+    };
+    let maxLength = inputSchema.valueBlock.value.length;
+    if (maxLength > 0) {
+      if (inputSchema.valueBlock.value[0] instanceof Repeated) {
+        maxLength = inputData.valueBlock.value.length;
+      }
+    }
+    if (maxLength === 0) {
+      return {
+        verified: true,
+        result: root
+      };
+    }
+    if (inputData.valueBlock.value.length === 0 && inputSchema.valueBlock.value.length !== 0) {
+      let _optional = true;
+      for (let i = 0; i < inputSchema.valueBlock.value.length; i++)
+        _optional = _optional && (inputSchema.valueBlock.value[i].optional || false);
+      if (_optional) {
+        return {
+          verified: true,
+          result: root
+        };
+      }
+      if (inputSchema.name) {
+        inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+        if (inputSchema.name)
+          delete root[inputSchema.name];
+      }
+      root.error = "Inconsistent object length";
+      return {
+        verified: false,
+        result: root
+      };
+    }
+    for (let i = 0; i < maxLength; i++) {
+      if (i - admission >= inputData.valueBlock.value.length) {
+        if (inputSchema.valueBlock.value[i].optional === false) {
+          const _result = {
+            verified: false,
+            result: root
+          };
+          root.error = "Inconsistent length between ASN.1 data and schema";
+          if (inputSchema.name) {
+            inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+            if (inputSchema.name) {
+              delete root[inputSchema.name];
+              _result.name = inputSchema.name;
+            }
+          }
+          return _result;
+        }
+      } else {
+        if (inputSchema.valueBlock.value[0] instanceof Repeated) {
+          result = compareSchema(root, inputData.valueBlock.value[i], inputSchema.valueBlock.value[0].value);
+          if (result.verified === false) {
+            if (inputSchema.valueBlock.value[0].optional)
+              admission++;
+            else {
+              if (inputSchema.name) {
+                inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+                if (inputSchema.name)
+                  delete root[inputSchema.name];
+              }
+              return result;
+            }
+          }
+          if (NAME in inputSchema.valueBlock.value[0] && inputSchema.valueBlock.value[0].name.length > 0) {
+            let arrayRoot = {};
+            if (LOCAL in inputSchema.valueBlock.value[0] && inputSchema.valueBlock.value[0].local)
+              arrayRoot = inputData;
+            else
+              arrayRoot = root;
+            if (typeof arrayRoot[inputSchema.valueBlock.value[0].name] === "undefined")
+              arrayRoot[inputSchema.valueBlock.value[0].name] = [];
+            arrayRoot[inputSchema.valueBlock.value[0].name].push(inputData.valueBlock.value[i]);
+          }
+        } else {
+          result = compareSchema(root, inputData.valueBlock.value[i - admission], inputSchema.valueBlock.value[i]);
+          if (result.verified === false) {
+            if (inputSchema.valueBlock.value[i].optional)
+              admission++;
+            else {
+              if (inputSchema.name) {
+                inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+                if (inputSchema.name)
+                  delete root[inputSchema.name];
+              }
+              return result;
+            }
+          }
+        }
+      }
+    }
+    if (result.verified === false) {
+      const _result = {
+        verified: false,
+        result: root
+      };
+      if (inputSchema.name) {
+        inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+        if (inputSchema.name) {
+          delete root[inputSchema.name];
+          _result.name = inputSchema.name;
+        }
+      }
+      return _result;
+    }
+    return {
+      verified: true,
+      result: root
+    };
+  }
+  if (inputSchema.primitiveSchema && VALUE_HEX_VIEW in inputData.valueBlock) {
+    const asn1 = localFromBER(inputData.valueBlock.valueHexView);
+    if (asn1.offset === -1) {
+      const _result = {
+        verified: false,
+        result: asn1.result
+      };
+      if (inputSchema.name) {
+        inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+        if (inputSchema.name) {
+          delete root[inputSchema.name];
+          _result.name = inputSchema.name;
+        }
+      }
+      return _result;
+    }
+    return compareSchema(root, asn1.result, inputSchema.primitiveSchema);
+  }
+  return {
+    verified: true,
+    result: root
+  };
+}
+function verifySchema(inputBuffer, inputSchema) {
+  if (inputSchema instanceof Object === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema type" }
+    };
+  }
+  const asn1 = localFromBER(pvtsutils19.BufferSourceConverter.toUint8Array(inputBuffer));
+  if (asn1.offset === -1) {
+    return {
+      verified: false,
+      result: asn1.result
+    };
+  }
+  return compareSchema(asn1.result, asn1.result, inputSchema);
+}
+export {
+  src_exports as asn1js
+};
+/*! Bundled license information:
+
+pvtsutils/build/index.js:
+  (*!
+   * MIT License
+   * 
+   * Copyright (c) 2017-2022 Peculiar Ventures, LLC
+   * 
+   * Permission is hereby granted, free of charge, to any person obtaining a copy
+   * of this software and associated documentation files (the "Software"), to deal
+   * in the Software without restriction, including without limitation the rights
+   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   * copies of the Software, and to permit persons to whom the Software is
+   * furnished to do so, subject to the following conditions:
+   * 
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   * 
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   * SOFTWARE.
+   * 
+   *)
+
+pvutils/build/utils.es.js:
+  (*!
+   Copyright (c) Peculiar Ventures, LLC
+  *)
+*/
diff --git a/comm/third_party/asn1js/make_bundle.sh b/comm/third_party/asn1js/make_bundle.sh
new file mode 100755
index 0000000000..57d87138ce
--- /dev/null
+++ b/comm/third_party/asn1js/make_bundle.sh
@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -e
+
+yarn install
+npm install --no-save esbuild
+
+echo 'export * as asn1js from "./src/index.ts";' | \
+  ./node_modules/.bin/esbuild --bundle \
+  --sourcefile=entry.js \
+  --loader=ts \
+  --format=esm \
+  --target=es2019 \
+  --log-level=verbose \
+  --outfile=asn1js.mjs
+
+rm -rf node_modules
diff --git a/comm/third_party/asn1js/moz.build b/comm/third_party/asn1js/moz.build
new file mode 100644
index 0000000000..ce34f7f124
--- /dev/null
+++ b/comm/third_party/asn1js/moz.build
@@ -0,0 +1,7 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, you can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXTRA_JS_MODULES += [
+    "asn1js.mjs",
+]
diff --git a/comm/third_party/asn1js/moz.yaml b/comm/third_party/asn1js/moz.yaml
new file mode 100644
index 0000000000..f9a60af27f
--- /dev/null
+++ b/comm/third_party/asn1js/moz.yaml
@@ -0,0 +1,91 @@
+---
+# Version of this schema
+schema: 1
+
+bugzilla:
+  # Bugzilla product and component for this directory and subdirectories
+  product: Mailnews Core
+  component: LDAP Integration
+# Document the source of externally hosted code
+origin:
+
+  # Short name of the package/library
+  name: ASN1.js
+
+  description: ASN1js is a pure JavaScript library implementing a full ASN.1 BER decoder and encoder
+
+  # Full URL for the package's homepage/etc
+  # Usually different from repository url
+  url: https://asn1js.org/
+
+  # Human-readable identifier for this version/release
+  # Generally "version NNN", "tag SSS", "bookmark SSS"
+  release: tag v3.0.5
+
+  # Revision to pull in
+  # Must be a long or short commit SHA (long preferred)
+  revision: v3.0.5
+
+  # The package's license, where possible using the mnemonic from
+  # https://spdx.org/licenses/
+  # Multiple licenses can be specified (as a YAML list)
+  # A "LICENSE" file must exist containing the full license text
+  license: BSD-3-Clause
+
+  # If the package's license is specified in a particular file,
+  # this is the name of the file.
+  # optional
+  license-file: LICENSE
+
+# Configuration for the automated vendoring system.
+# optional
+vendoring:
+
+  # Repository URL to vendor from
+  # eg. https://github.com/kinetiknz/nestegg
+  # Any repository host can be specified here, however initially we'll only
+  # support automated vendoring from selected sources.
+  url: https://github.com/PeculiarVentures/asn1.js
+
+  # Type of hosting for the upstream repository
+  # Valid values are 'gitlab', 'github', googlesource
+  source-hosting: github
+  tracking: tag
+
+  skip-vendoring-steps:
+    - hg-add
+    - spurious-check
+    - update-moz-build
+
+  # Files/paths that will not be vendored from the upstream repository
+  # Implicitly contains ".git", and ".gitignore"
+  # optional
+  exclude:
+    - .eslintrc.json
+    - .github/
+    - .gitignore
+    - .mocharc.yaml
+    - .npmrc
+    - .nycrc
+    - CNAME
+    - README.md
+    - rollup.config.js
+    - test/
+    - typedoc.json
+
+  keep:
+    - make_bundle.sh
+    - make-esmodule-bundle.patch
+
+  update-actions:
+    - action: run-script
+      script: 'make_bundle.sh'
+      cwd: '{yaml_dir}'
+
+    - action: replace-in-file-regex
+      file: '{yaml_dir}/../README.asn1js'
+      pattern: '\[tag v[0-9\.]+\]'
+      with: '[tag {revision}]'
+
+    - action: delete-path
+      path: 'build'
diff --git a/comm/third_party/asn1js/package.json b/comm/third_party/asn1js/package.json
new file mode 100644
index 0000000000..d0720330c1
--- /dev/null
+++ b/comm/third_party/asn1js/package.json
@@ -0,0 +1,77 @@
+{
+  "author": {
+    "email": "yury@strozhevsky.com",
+    "name": "Yury Strozhevsky"
+  },
+  "contributors": [
+    {
+      "email": "rmh@unmitigatedrisk.com",
+      "name": "Ryan Hurst"
+    }
+  ],
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "devDependencies": {
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^17.0.32",
+    "@typescript-eslint/eslint-plugin": "^5.23.0",
+    "@typescript-eslint/parser": "^5.23.0",
+    "asn1-test-suite": "^1.0.2",
+    "eslint": "^8.15.0",
+    "eslint-plugin-deprecation": "^1.3.2",
+    "mocha": "^10.0.0",
+    "nyc": "^15.1.0",
+    "rollup": "^2.72.1",
+    "rollup-plugin-dts": "^4.2.1",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "rollup-plugin-typescript2": "^0.31.2",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/PeculiarVentures/asn1.js.git"
+  },
+  "dependencies": {
+    "pvtsutils": "^1.3.2",
+    "pvutils": "^1.1.3",
+    "tslib": "^2.4.0"
+  },
+  "description": "asn1js is a pure JavaScript library implementing this standard. ASN.1 is the basis of all X.509 related data structures and numerous other protocols used on the web",
+  "keywords": [
+    "asn1",
+    "parser",
+    "asn.1",
+    "ber",
+    "der",
+    "sequence",
+    "set",
+    "bitstring",
+    "octetstring",
+    "utctime",
+    "utf8string",
+    "bmpstring",
+    "universalstring",
+    "generalizedtime"
+  ],
+  "main": "build/index.js",
+  "module": "build/index.es.js",
+  "types": "build/index.d.ts",
+  "name": "asn1js",
+  "files": [
+    "build",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "test": "mocha",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint --fix . --ext .ts",
+    "coverage": "nyc npm test"
+  },
+  "version": "3.0.5",
+  "license": "BSD-3-Clause"
+}
diff --git a/comm/third_party/asn1js/src/Any.ts b/comm/third_party/asn1js/src/Any.ts
new file mode 100644
index 0000000000..36db46cc2e
--- /dev/null
+++ b/comm/third_party/asn1js/src/Any.ts
@@ -0,0 +1,22 @@
+import { EMPTY_STRING } from "./internals/constants";
+
+export interface IAny {
+  name: string;
+  optional: boolean;
+}
+
+export type AnyParams = Partial<IAny>;
+
+export class Any implements IAny {
+
+  public name: string;
+  public optional: boolean;
+
+  constructor({
+    name = EMPTY_STRING, optional = false,
+  }: AnyParams = {}) {
+    this.name = name;
+    this.optional = optional;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/BaseBlock.ts b/comm/third_party/asn1js/src/BaseBlock.ts
new file mode 100644
index 0000000000..8a4c58528c
--- /dev/null
+++ b/comm/third_party/asn1js/src/BaseBlock.ts
@@ -0,0 +1,186 @@
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { IBerConvertible } from "./types";
+import { LocalBaseBlockJson, LocalBaseBlockParams, LocalBaseBlock } from "./internals/LocalBaseBlock";
+import { LocalIdentificationBlock, LocalIdentificationBlockJson, LocalIdentificationBlockParams } from "./internals/LocalIdentificationBlock";
+import { LocalLengthBlock, LocalLengthBlockJson, LocalLengthBlockParams } from "./internals/LocalLengthBlock";
+import { ViewWriter } from "./ViewWriter";
+import { ValueBlock, ValueBlockJson } from "./ValueBlock";
+import { EMPTY_BUFFER, EMPTY_STRING } from "./internals/constants";
+import { typeStore } from "./TypeStore";
+
+export interface IBaseBlock {
+  name: string;
+  optional: boolean;
+  primitiveSchema?: BaseBlock;
+}
+
+export interface BaseBlockParams extends LocalBaseBlockParams, LocalIdentificationBlockParams, LocalLengthBlockParams, Partial<IBaseBlock> { }
+
+export interface ValueBlockConstructor<T extends ValueBlock = ValueBlock> {
+  new(...args: any[]): T;
+}
+
+export interface BaseBlockJson<T extends LocalBaseBlockJson = LocalBaseBlockJson> extends LocalBaseBlockJson, Omit<IBaseBlock, "primitiveSchema"> {
+  idBlock: LocalIdentificationBlockJson;
+  lenBlock: LocalLengthBlockJson;
+  valueBlock: T;
+  primitiveSchema?: BaseBlockJson;
+}
+
+export type StringEncoding = "ascii" | "hex";
+
+export class BaseBlock<T extends ValueBlock = ValueBlock, J extends ValueBlockJson = ValueBlockJson> extends LocalBaseBlock implements IBaseBlock, IBerConvertible {
+
+  static {
+
+  }
+
+  public static override NAME = "BaseBlock";
+
+  public idBlock: LocalIdentificationBlock;
+  public lenBlock: LocalLengthBlock;
+  public valueBlock: T;
+  public name: string;
+  public optional: boolean;
+  public primitiveSchema?: BaseBlock;
+
+  constructor({
+    name = EMPTY_STRING,
+    optional = false,
+    primitiveSchema,
+    ...parameters
+  }: BaseBlockParams = {}, valueBlockType?: ValueBlockConstructor<T>) {
+    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) as unknown as T;
+  }
+
+  public fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    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;
+  }
+
+  public toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    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;
+  }
+
+  public override toJSON(): BaseBlockJson<J> {
+    const object: BaseBlockJson = {
+      ...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 as BaseBlockJson<J>;
+  }
+  public override toString(encoding: StringEncoding = "ascii"): string {
+    if (encoding === "ascii") {
+      return this.onAsciiEncoding();
+    }
+
+    return pvtsutils.Convert.ToHex(this.toBER());
+  }
+
+  protected onAsciiEncoding(): string {
+    return `${(this.constructor as typeof BaseBlock).NAME} : ${pvtsutils.Convert.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
+  }
+
+  /**
+   * Determines whether two object instances are equal
+   * @param other Object to compare with the current object
+   */
+  public isEqual(other: unknown): other is this {
+    if (this === other) {
+      return true;
+    }
+
+    // Check input type
+    if (!(other instanceof this.constructor)) {
+      return false;
+    }
+
+    const thisRaw = this.toBER();
+    const otherRaw = (other as BaseBlock).toBER();
+
+    return pvutils.isEqualBuffer(thisRaw, otherRaw);
+  }
+
+}
+
+/**
+ * Recursive function which checks and enables isIndefiniteForm flag for constructed blocks if any child has that flag enabled
+ * @param baseBlock Base ASN.1 block
+ * @returns Returns `true` if incoming block is `indefinite form`
+ */
+function prepareIndefiniteForm(baseBlock: BaseBlock): boolean {
+  if (baseBlock instanceof typeStore.Constructed) {
+    for (const value of baseBlock.valueBlock.value) {
+      if (prepareIndefiniteForm(value)) {
+        baseBlock.lenBlock.isIndefiniteForm = true;
+      }
+    }
+  }
+
+  return !!baseBlock.lenBlock.isIndefiniteForm;
+}
diff --git a/comm/third_party/asn1js/src/BaseStringBlock.ts b/comm/third_party/asn1js/src/BaseStringBlock.ts
new file mode 100644
index 0000000000..606b330e0c
--- /dev/null
+++ b/comm/third_party/asn1js/src/BaseStringBlock.ts
@@ -0,0 +1,74 @@
+import { BaseBlock, BaseBlockParams } from "./BaseBlock";
+import { IStringConvertible } from "./types";
+import { EMPTY_STRING } from "./internals/constants";
+import { LocalStringValueBlock, LocalStringValueBlockJson, LocalStringValueBlockParams } from "./internals/LocalStringValueBlock";
+
+export interface BaseStringBlockParams extends BaseBlockParams, LocalStringValueBlockParams { }
+export type BaseStringBlockJson = LocalStringValueBlockJson;
+
+export abstract class BaseStringBlock<T extends LocalStringValueBlock = LocalStringValueBlock, J extends BaseStringBlockJson = BaseStringBlockJson> extends BaseBlock<T, J> implements IStringConvertible {
+
+  public static override NAME = "BaseStringBlock";
+
+  /**
+   * String value
+   * @since 3.0.0
+   */
+  public getValue(): string {
+    return this.valueBlock.value;
+  }
+  /**
+   * String value
+   * @param value String value
+   * @since 3.0.0
+   */
+  public setValue(value: string): void {
+    this.valueBlock.value = value;
+  }
+
+  constructor({
+    value = EMPTY_STRING,
+    ...parameters
+  }: BaseStringBlockParams = {}, stringValueBlockType: new () => T) {
+    super(parameters, stringValueBlockType);
+
+    if (value) {
+      this.fromString(value);
+    }
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    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;
+  }
+
+  /**
+   * Function converting ArrayBuffer into ASN.1 internal string
+   * @param inputBuffer ASN.1 BER encoded array
+   */
+  public abstract fromBuffer(inputBuffer: ArrayBuffer | Uint8Array): void;
+
+  public abstract fromString(inputString: string): void;
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof BaseStringBlock).NAME} : '${this.valueBlock.value}'`;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/BitString.ts b/comm/third_party/asn1js/src/BitString.ts
new file mode 100644
index 0000000000..2c8ada83cc
--- /dev/null
+++ b/comm/third_party/asn1js/src/BitString.ts
@@ -0,0 +1,64 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { Constructed } from "./Constructed";
+import { BIT_STRING_NAME } from "./internals/constants";
+import { LocalBitStringValueBlockParams, LocalBitStringValueBlock, LocalBitStringValueBlockJson } from "./internals/LocalBitStringValueBlock";
+import { typeStore } from "./TypeStore";
+
+export interface BitStringParams extends BaseBlockParams, LocalBitStringValueBlockParams { }
+export type BitStringJson = BaseBlockJson<LocalBitStringValueBlockJson>;
+
+export class BitString extends BaseBlock<LocalBitStringValueBlock, LocalBitStringValueBlockJson> {
+
+  static {
+    typeStore.BitString = this;
+  }
+
+  public static override NAME = BIT_STRING_NAME;
+
+  constructor({
+    idBlock = {},
+    lenBlock = {},
+    ...parameters
+  }: BitStringParams = {}) {
+    parameters.isConstructed ??= !!parameters.value?.length;
+    super({
+      idBlock: {
+        isConstructed: parameters.isConstructed,
+        ...idBlock,
+      },
+      lenBlock: {
+        ...lenBlock,
+        isIndefiniteForm: !!parameters.isIndefiniteForm,
+      },
+      ...parameters,
+    }, LocalBitStringValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 3; // BitString
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    this.valueBlock.isConstructed = this.idBlock.isConstructed;
+    this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
+
+    return super.fromBER(inputBuffer, inputOffset, inputLength);
+  }
+
+  protected override onAsciiEncoding(): string {
+    if (this.valueBlock.isConstructed || (this.valueBlock.value && this.valueBlock.value.length)) {
+      return Constructed.prototype.onAsciiEncoding.call(this);
+    } else {
+      // convert bytes to bits
+      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 as typeof BitString).NAME} : ${bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits)}`;
+    }
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/BmpString.ts b/comm/third_party/asn1js/src/BmpString.ts
new file mode 100644
index 0000000000..42f23ea773
--- /dev/null
+++ b/comm/third_party/asn1js/src/BmpString.ts
@@ -0,0 +1,23 @@
+import { LocalBmpStringValueBlockParams, LocalBmpStringValueBlock, LocalBmpStringValueBlockJson } from "./internals/LocalBmpStringValueBlock";
+import { typeStore } from "./TypeStore";
+
+export type BmpStringParams = LocalBmpStringValueBlockParams;
+export type BmpStringJson = LocalBmpStringValueBlockJson;
+
+export class BmpString extends LocalBmpStringValueBlock {
+
+  static {
+    typeStore.BmpString = this;
+  }
+  public static override NAME = "BMPString";
+
+  constructor({
+    ...parameters
+  }: BmpStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 30; // BmpString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Boolean.ts b/comm/third_party/asn1js/src/Boolean.ts
new file mode 100644
index 0000000000..3bcdb05ae2
--- /dev/null
+++ b/comm/third_party/asn1js/src/Boolean.ts
@@ -0,0 +1,43 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { LocalBooleanValueBlockParams, LocalBooleanValueBlock, LocalBooleanValueBlockJson } from "./internals/LocalBooleanValueBlock";
+import { typeStore } from "./TypeStore";
+
+export interface BooleanParams extends BaseBlockParams, LocalBooleanValueBlockParams { }
+export type BooleanJson = BaseBlockJson<LocalBooleanValueBlockJson>;
+
+export class Boolean extends BaseBlock<LocalBooleanValueBlock, LocalBooleanValueBlockJson> {
+
+  static {
+    typeStore.Boolean = this;
+  }
+
+  /**
+   * Gets value
+   * @since 3.0.0
+   */
+  public getValue(): boolean {
+    return this.valueBlock.value;
+  }
+  /**
+   * Sets value
+   * @param value Boolean value
+   * @since 3.0.0
+   */
+  public setValue(value: boolean): void {
+    this.valueBlock.value = value;
+  }
+
+  public static override NAME = "BOOLEAN";
+
+  constructor(parameters: BooleanParams = {}) {
+    super(parameters, LocalBooleanValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 1; // Boolean
+  }
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof Boolean).NAME} : ${this.getValue}`;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/CharacterString.ts b/comm/third_party/asn1js/src/CharacterString.ts
new file mode 100644
index 0000000000..a15798cced
--- /dev/null
+++ b/comm/third_party/asn1js/src/CharacterString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type CharacterStringParams = LocalSimpleStringBlockParams;
+export type CharacterStringJson = LocalSimpleStringBlockJson;
+
+export class CharacterString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.CharacterString = this;
+  }
+
+  public static override NAME = "CharacterString";
+
+  constructor(parameters: CharacterStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 29; // CharacterString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Choice.ts b/comm/third_party/asn1js/src/Choice.ts
new file mode 100644
index 0000000000..3246bfa3c3
--- /dev/null
+++ b/comm/third_party/asn1js/src/Choice.ts
@@ -0,0 +1,22 @@
+import { BaseBlock } from "./BaseBlock";
+import { IAny, Any } from "./Any";
+
+export interface IChoice extends IAny {
+  value: BaseBlock[];
+}
+
+export type ChoiceParams = Partial<IChoice>;
+
+export class Choice extends Any implements IChoice {
+  public value: BaseBlock[];
+
+  constructor({
+    value = [],
+    ...parameters
+  }: ChoiceParams = {}) {
+    super(parameters);
+
+    this.value = value;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Constructed.ts b/comm/third_party/asn1js/src/Constructed.ts
new file mode 100644
index 0000000000..8fe3bc502f
--- /dev/null
+++ b/comm/third_party/asn1js/src/Constructed.ts
@@ -0,0 +1,61 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { LocalConstructedValueBlock, LocalConstructedValueBlockJson, LocalConstructedValueBlockParams } from "./internals/LocalConstructedValueBlock";
+import { typeStore } from "./TypeStore";
+
+export interface ConstructedParams extends BaseBlockParams, LocalConstructedValueBlockParams { }
+export type ConstructedJson = BaseBlockJson<LocalConstructedValueBlockJson>;
+
+export class Constructed extends BaseBlock<LocalConstructedValueBlock, LocalConstructedValueBlockJson> {
+
+  static {
+    typeStore.Constructed = this;
+  }
+
+  public static override NAME = "CONSTRUCTED";
+
+  constructor(parameters: ConstructedParams = {}) {
+    super(parameters, LocalConstructedValueBlock);
+
+    this.idBlock.isConstructed = true;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    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;
+  }
+
+  /**
+   * @internal
+   */
+  public override onAsciiEncoding(): string {
+    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 as typeof Constructed).NAME;
+
+    return values.length
+      ? `${blockName} :\n${values.join("\n")}` // items
+      : `${blockName} :`; // empty
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/DATE.ts b/comm/third_party/asn1js/src/DATE.ts
new file mode 100644
index 0000000000..3a6f73d144
--- /dev/null
+++ b/comm/third_party/asn1js/src/DATE.ts
@@ -0,0 +1,22 @@
+import { typeStore } from "./TypeStore";
+import { Utf8StringParams, Utf8String, Utf8StringJson } from "./Utf8String";
+
+export type DATEParams = Utf8StringParams;
+export type DATEJson = Utf8StringJson;
+
+export class DATE extends Utf8String {
+
+  static {
+    typeStore.DATE = this;
+  }
+
+  public static override NAME = "DATE";
+
+  constructor(parameters: DATEParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 31; // DATE
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/DateTime.ts b/comm/third_party/asn1js/src/DateTime.ts
new file mode 100644
index 0000000000..a30f47dbe4
--- /dev/null
+++ b/comm/third_party/asn1js/src/DateTime.ts
@@ -0,0 +1,22 @@
+import { typeStore } from "./TypeStore";
+import { Utf8StringParams, Utf8String, Utf8StringJson } from "./Utf8String";
+
+export type DateTimeParams = Utf8StringParams;
+export type DateTimeJson = Utf8StringJson;
+
+export class DateTime extends Utf8String {
+
+  static {
+    typeStore.DateTime = this;
+  }
+
+  public static override NAME = "DateTime";
+
+  constructor(parameters: DateTimeParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 33; // DateTime
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Duration.ts b/comm/third_party/asn1js/src/Duration.ts
new file mode 100644
index 0000000000..618894e158
--- /dev/null
+++ b/comm/third_party/asn1js/src/Duration.ts
@@ -0,0 +1,21 @@
+import { typeStore } from "./TypeStore";
+import { Utf8StringParams, Utf8String, Utf8StringJson } from "./Utf8String";
+
+export type DurationParams = Utf8StringParams;
+export type DurationJson = Utf8StringJson;
+
+export class Duration extends Utf8String {
+
+  static {
+    typeStore.Duration = this;
+  }
+  public static override NAME = "Duration";
+
+  constructor(parameters: DurationParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 34; // Duration
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/EndOfContent.ts b/comm/third_party/asn1js/src/EndOfContent.ts
new file mode 100644
index 0000000000..b0e8ccf6c9
--- /dev/null
+++ b/comm/third_party/asn1js/src/EndOfContent.ts
@@ -0,0 +1,23 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { END_OF_CONTENT_NAME } from "./internals/constants";
+import { LocalEndOfContentValueBlock } from "./internals/LocalEndOfContentValueBlock";
+import { typeStore } from "./TypeStore";
+
+export type EndOfContentParams = BaseBlockParams;
+export type EndOfContentJson = BaseBlockJson;
+
+export class EndOfContent extends BaseBlock<LocalEndOfContentValueBlock> {
+
+  static {
+    typeStore.EndOfContent = this;
+  }
+  public static override NAME = END_OF_CONTENT_NAME;
+
+  constructor(parameters: EndOfContentParams = {}) {
+    super(parameters, LocalEndOfContentValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 0; // EndOfContent
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Enumerated.ts b/comm/third_party/asn1js/src/Enumerated.ts
new file mode 100644
index 0000000000..53249a3cf9
--- /dev/null
+++ b/comm/third_party/asn1js/src/Enumerated.ts
@@ -0,0 +1,22 @@
+import { IntegerParams, Integer, IntegerJson } from "./Integer";
+import { typeStore } from "./TypeStore";
+
+export type EnumeratedParams = IntegerParams;
+export type EnumeratedJson = IntegerJson;
+
+export class Enumerated extends Integer {
+
+  static {
+    typeStore.Enumerated = this;
+  }
+
+  public static override NAME = "ENUMERATED";
+
+  constructor(parameters: EnumeratedParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 10; // Enumerated
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/GeneralString.ts b/comm/third_party/asn1js/src/GeneralString.ts
new file mode 100644
index 0000000000..f0ce52a607
--- /dev/null
+++ b/comm/third_party/asn1js/src/GeneralString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type GeneralStringParams = LocalSimpleStringBlockParams;
+export type GeneralStringJson = LocalSimpleStringBlockJson;
+
+export class GeneralString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.GeneralString = this;
+  }
+
+  public static override NAME = "GeneralString";
+
+  constructor(parameters: GeneralStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 27; // GeneralString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/GeneralizedTime.ts b/comm/third_party/asn1js/src/GeneralizedTime.ts
new file mode 100644
index 0000000000..7743ae1436
--- /dev/null
+++ b/comm/third_party/asn1js/src/GeneralizedTime.ts
@@ -0,0 +1,262 @@
+import * as pvutils from "pvutils";
+import { typeStore } from "./TypeStore";
+import { IUTCTime, UTCTimeParams, UTCTimeJson, UTCTime, DateStringEncoding } from "./UTCTime";
+
+export interface IGeneralizedTime extends IUTCTime {
+  millisecond: number;
+}
+
+export type GeneralizedTimeParams = UTCTimeParams;
+
+export interface GeneralizedTimeJson extends UTCTimeJson {
+  millisecond: number;
+}
+
+export class GeneralizedTime extends UTCTime {
+
+  static {
+    typeStore.GeneralizedTime = this;
+  }
+
+  public static override NAME = "GeneralizedTime";
+
+  public millisecond: number;
+
+  constructor(parameters: GeneralizedTimeParams = {}) {
+    super(parameters);
+
+    this.millisecond ??= 0;
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 24; // GeneralizedTime
+  }
+
+  public override fromDate(inputDate: Date): void {
+    super.fromDate(inputDate);
+    this.millisecond = inputDate.getUTCMilliseconds();
+  }
+
+  public override toDate(): Date {
+    return (new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond)));
+  }
+
+  public override fromString(inputString: string): void {
+    //#region Initial variables
+    let isUTC = false;
+
+    let timeString = "";
+    let dateTimeString = "";
+    let fractionPart = 0;
+
+    let parser;
+
+    let hourDifference = 0;
+    let minuteDifference = 0;
+    //#endregion
+
+    //#region Convert as UTC time
+    if (inputString[inputString.length - 1] === "Z") {
+      timeString = inputString.substring(0, inputString.length - 1);
+
+      isUTC = true;
+    }
+    //#endregion
+    //#region Convert as local time
+    else {
+      const number = new Number(inputString[inputString.length - 1]);
+
+      if (isNaN(number.valueOf()))
+        throw new Error("Wrong input string for conversion");
+
+      timeString = inputString;
+    }
+    //#endregion
+
+    //#region Check that we do not have a "+" and "-" symbols inside UTC time
+    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");
+    }
+    //#endregion
+    //#region Get "UTC time difference" in case of local time
+    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;
+        }
+      }
+    }
+    //#endregion
+
+    //#region Get position of fraction point
+    let fractionPointPosition = timeString.indexOf("."); // Check for "full stop" symbol
+    if (fractionPointPosition === -1)
+      fractionPointPosition = timeString.indexOf(","); // Check for "comma" symbol
+    //#endregion
+
+    //#region Get fraction part
+    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;
+    //#endregion
+
+    //#region Parse internal date
+    switch (true) {
+      case (dateTimeString.length === 8): // "YYYYMMDD"
+        parser = /(\d{4})(\d{2})(\d{2})/ig;
+        if (fractionPointPosition !== -1)
+          throw new Error("Wrong input string for conversion"); // Here we should not have a "fraction point"
+        break;
+      case (dateTimeString.length === 10): // "YYYYMMDDHH"
+        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): // "YYYYMMDDHHMM"
+        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): // "YYYYMMDDHHMMSS"
+        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");
+    }
+    //#endregion
+
+    //#region Put parsed values at right places
+    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");
+      }
+    }
+    //#endregion
+
+    //#region Get final date
+    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();
+    }
+    //#endregion
+  }
+
+  public override toString(encoding: DateStringEncoding = "iso"): string {
+    if (encoding === "iso") {
+      const outputArray = [];
+
+      outputArray.push(pvutils.padNumber(this.year, 4));
+      outputArray.push(pvutils.padNumber(this.month, 2));
+      outputArray.push(pvutils.padNumber(this.day, 2));
+      outputArray.push(pvutils.padNumber(this.hour, 2));
+      outputArray.push(pvutils.padNumber(this.minute, 2));
+      outputArray.push(pvutils.padNumber(this.second, 2));
+      if (this.millisecond !== 0) {
+        outputArray.push(".");
+        outputArray.push(pvutils.padNumber(this.millisecond, 3));
+      }
+      outputArray.push("Z");
+
+      return outputArray.join("");
+    }
+
+    return super.toString(encoding);
+  }
+
+  public override toJSON(): GeneralizedTimeJson {
+    return {
+      ...super.toJSON(),
+      millisecond: this.millisecond,
+    };
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/GraphicString.ts b/comm/third_party/asn1js/src/GraphicString.ts
new file mode 100644
index 0000000000..3d2ab07577
--- /dev/null
+++ b/comm/third_party/asn1js/src/GraphicString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type GraphicStringParams = LocalSimpleStringBlockParams;
+export type GraphicStringJson = LocalSimpleStringBlockJson;
+
+export class GraphicString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.GraphicString = this;
+  }
+
+  public static override NAME = "GraphicString";
+
+  constructor(parameters: GraphicStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 25; // GraphicString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/HexBlock.ts b/comm/third_party/asn1js/src/HexBlock.ts
new file mode 100644
index 0000000000..cca34da5de
--- /dev/null
+++ b/comm/third_party/asn1js/src/HexBlock.ts
@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import * as pvtsutils from "pvtsutils";
+import { IBerConvertible } from "./types";
+import { EMPTY_BUFFER, EMPTY_VIEW } from "./internals/constants";
+import { LocalBaseBlockConstructor } from "./internals/LocalBaseBlock";
+import { checkBufferParams } from "./internals/utils";
+
+export interface IHexBlock {
+  isHexOnly: boolean;
+  valueHex: pvtsutils.BufferSource;
+}
+
+export interface HexBlockJson extends Omit<IHexBlock, "valueHex"> {
+  valueHex: string;
+}
+
+export type HexBlockParams = Partial<IHexBlock>;
+/**
+ * Class used as a base block for all remaining ASN.1 classes
+ */
+export function HexBlock<T extends LocalBaseBlockConstructor>(BaseClass: T) {
+  return class Some extends BaseClass implements IHexBlock, IBerConvertible {
+
+    public static override NAME = "hexBlock";
+
+    public isHexOnly: boolean;
+    /**
+     * Binary data in ArrayBuffer representation
+     *
+     * @deprecated since version 3.0.0
+     */
+    public get valueHex(): ArrayBuffer {
+      return this.valueHexView.slice().buffer;
+    }
+    /**
+     * Binary data in ArrayBuffer representation
+     *
+     * @deprecated since version 3.0.0
+     */
+    public set valueHex(value: ArrayBuffer) {
+      this.valueHexView = new Uint8Array(value);
+    }
+    /**
+     * Binary data in Uint8Array representation
+     *
+     * @since 3.0.0
+     */
+    public valueHexView: Uint8Array;
+
+    constructor(...args: any[]) {
+      super(...args);
+
+      const params: HexBlockParams = args[0] || {};
+      this.isHexOnly = params.isHexOnly ?? false;
+      this.valueHexView = params.valueHex ? pvtsutils.BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
+    }
+
+    public fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+      // Basic check for parameters
+      const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
+      if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+        return -1;
+      }
+
+      const endLength = inputOffset + inputLength;
+
+      // Initial checks
+      this.valueHexView = view.subarray(inputOffset, endLength);
+      if (!this.valueHexView.length) {
+        this.warnings.push("Zero buffer length");
+
+        return inputOffset;
+      }
+
+      this.blockLength = inputLength;
+
+      return endLength;
+    }
+
+    public toBER(sizeOnly = false): ArrayBuffer {
+      if (!this.isHexOnly) {
+        this.error = "Flag 'isHexOnly' is not set, abort";
+
+        return EMPTY_BUFFER;
+      }
+
+      if (sizeOnly) {
+        return new ArrayBuffer(this.valueHexView.byteLength);
+      }
+
+      // Don't copy data if View is not offset
+      return (this.valueHexView.byteLength === this.valueHexView.buffer.byteLength)
+        ? this.valueHexView.buffer
+        : this.valueHexView.slice().buffer;
+    }
+
+    /**
+     * Returns a JSON representation of an object
+     * @returns JSON object
+     */
+    public override toJSON() {
+      return {
+        ...super.toJSON(),
+        isHexOnly: this.isHexOnly,
+        valueHex: pvtsutils.Convert.ToHex(this.valueHexView),
+      };
+    }
+
+  };
+}
diff --git a/comm/third_party/asn1js/src/IA5String.ts b/comm/third_party/asn1js/src/IA5String.ts
new file mode 100644
index 0000000000..f0021cec51
--- /dev/null
+++ b/comm/third_party/asn1js/src/IA5String.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type IA5StringParams = LocalSimpleStringBlockParams;
+export type IA5StringJson = LocalSimpleStringBlockJson;
+
+export class IA5String extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.IA5String = this;
+  }
+
+  public static override NAME = "IA5String";
+
+  constructor(parameters: IA5StringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 22; // IA5String
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Integer.ts b/comm/third_party/asn1js/src/Integer.ts
new file mode 100644
index 0000000000..fd3d1d9e70
--- /dev/null
+++ b/comm/third_party/asn1js/src/Integer.ts
@@ -0,0 +1,103 @@
+import * as pvtsutils from "pvtsutils";
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { LocalIntegerValueBlockParams, LocalIntegerValueBlock, LocalIntegerValueBlockJson } from "./internals/LocalIntegerValueBlock";
+import { assertBigInt } from "./internals/utils";
+import { typeStore } from "./TypeStore";
+import { ViewWriter } from "./ViewWriter";
+
+export interface IntegerParams extends BaseBlockParams, LocalIntegerValueBlockParams { }
+export type IntegerJson = BaseBlockJson<LocalIntegerValueBlockJson>;
+
+export class Integer extends BaseBlock<LocalIntegerValueBlock, LocalIntegerValueBlockJson> {
+
+  static {
+    typeStore.Integer = this;
+  }
+
+  public static override NAME = "INTEGER";
+
+  constructor(parameters: IntegerParams = {}) {
+    super(parameters, LocalIntegerValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 2; // Integer
+  }
+
+  /**
+   * Converts Integer into BigInt
+   * @throws Throws Error if BigInt is not supported
+   * @since 3.0.0
+   */
+  public toBigInt(): bigint {
+    assertBigInt();
+
+    return BigInt(this.valueBlock.toString());
+  }
+
+  /**
+   * Creates Integer from BigInt value
+   * @param value BigInt value
+   * @returns ASN.1 Integer
+   * @throws Throws Error if BigInt is not supported
+   * @since 3.0.0
+   */
+  public static fromBigInt(value: number | string | bigint | boolean): Integer {
+    assertBigInt();
+
+    const bigIntValue = BigInt(value);
+    const writer = new ViewWriter();
+
+    const hex = bigIntValue.toString(16).replace(/^-/, "");
+    const view = new Uint8Array(pvtsutils.Convert.FromHex(hex));
+
+    if (bigIntValue < 0) {
+      // a negative number
+      const first = new Uint8Array(view.length + (view[0] & 0x80 ? 1 : 0));
+      first[0] |= 0x80;
+
+      const firstInt = BigInt(`0x${pvtsutils.Convert.ToHex(first)}`);
+      const secondInt = firstInt + bigIntValue;
+      const second = pvtsutils.BufferSourceConverter.toUint8Array(pvtsutils.Convert.FromHex(secondInt.toString(16)));
+      second[0] |= 0x80;
+
+      writer.write(second);
+    } else {
+      // a positive number
+      if (view[0] & 0x80) {
+        writer.write(new Uint8Array([0]));
+      }
+      writer.write(view);
+    }
+
+    const res = new Integer({
+      valueHex: writer.final(),
+    });
+
+    return res;
+  }
+
+  public convertToDER(): Integer {
+    const integer = new Integer({ valueHex: this.valueBlock.valueHexView });
+
+    integer.valueBlock.toDER();
+
+    return integer;
+  }
+
+  /**
+   * Convert current Integer value from DER to BER format
+   * @returns
+   */
+  public convertFromDER(): Integer {
+    return new Integer({
+      valueHex: this.valueBlock.valueHexView[0] === 0
+        ? this.valueBlock.valueHexView.subarray(1)
+        : this.valueBlock.valueHexView,
+    });
+  }
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof Integer).NAME} : ${this.valueBlock.toString()}`;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Null.ts b/comm/third_party/asn1js/src/Null.ts
new file mode 100644
index 0000000000..8c4c4c580d
--- /dev/null
+++ b/comm/third_party/asn1js/src/Null.ts
@@ -0,0 +1,65 @@
+import { ViewWriter } from "./ViewWriter";
+import { ValueBlock, ValueBlockJson } from "./ValueBlock";
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { typeStore } from "./TypeStore";
+
+export type NullParams = BaseBlockParams;
+export type NullJson = BaseBlockJson<ValueBlockJson>;
+
+export class Null extends BaseBlock<ValueBlock, ValueBlockJson> {
+
+  static {
+    typeStore.Null = this;
+  }
+
+  public static override NAME = "NULL";
+
+  constructor(parameters: NullParams = {}) {
+    super(parameters, ValueBlock); // We will not have a call to "Null value block" because of specified FROM_BER and TO_BER functions
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 5; // Null
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    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);
+  }
+
+  public override toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    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;
+  }
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof Null).NAME}`;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/NumericString.ts b/comm/third_party/asn1js/src/NumericString.ts
new file mode 100644
index 0000000000..a917fd1dc2
--- /dev/null
+++ b/comm/third_party/asn1js/src/NumericString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type NumericStringParams = LocalSimpleStringBlockParams;
+export type NumericStringJson = LocalSimpleStringBlockJson;
+
+export class NumericString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.NumericString = this;
+  }
+
+  public static override NAME = "NumericString";
+
+  constructor(parameters: NumericStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 18; // NumericString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/ObjectIdentifier.ts b/comm/third_party/asn1js/src/ObjectIdentifier.ts
new file mode 100644
index 0000000000..7608a3cf7d
--- /dev/null
+++ b/comm/third_party/asn1js/src/ObjectIdentifier.ts
@@ -0,0 +1,53 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { LocalObjectIdentifierValueBlockParams, LocalObjectIdentifierValueBlock, LocalObjectIdentifierValueBlockJson } from "./internals/LocalObjectIdentifierValueBlock";
+import { typeStore } from "./TypeStore";
+
+export interface ObjectIdentifierParams extends BaseBlockParams, LocalObjectIdentifierValueBlockParams { }
+export interface ObjectIdentifierJson extends BaseBlockJson<LocalObjectIdentifierValueBlockJson> {
+  value: string;
+}
+
+export class ObjectIdentifier extends BaseBlock<LocalObjectIdentifierValueBlock, LocalObjectIdentifierValueBlockJson> {
+
+  static {
+    typeStore.ObjectIdentifier = this;
+  }
+
+  public static override NAME = "OBJECT IDENTIFIER";
+
+  /**
+   * Gets string representation of Object Identifier
+   * @since 3.0.0
+   */
+  public getValue(): string {
+    return this.valueBlock.toString();
+  }
+
+  /**
+   * Sets Object Identifier value from string
+   * @param value String value
+   * @since 3.0.0
+   */
+  public setValue(value: string): void {
+    this.valueBlock.fromString(value);
+  }
+
+  constructor(parameters: ObjectIdentifierParams = {}) {
+    super(parameters, LocalObjectIdentifierValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 6; // OBJECT IDENTIFIER
+  }
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof ObjectIdentifier).NAME} : ${this.valueBlock.toString() || "empty"}`;
+  }
+
+  public override toJSON(): ObjectIdentifierJson {
+    return {
+      ...super.toJSON(),
+      value: this.getValue(),
+    };
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/OctetString.ts b/comm/third_party/asn1js/src/OctetString.ts
new file mode 100644
index 0000000000..df57e9bc6e
--- /dev/null
+++ b/comm/third_party/asn1js/src/OctetString.ts
@@ -0,0 +1,103 @@
+import * as pvtsutils from "pvtsutils";
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { Constructed } from "./Constructed";
+import { LocalOctetStringValueBlockParams, LocalOctetStringValueBlock, LocalOctetStringValueBlockJson } from "./internals/LocalOctetStringValueBlock";
+import { OCTET_STRING_NAME } from "./internals/constants";
+import { localFromBER } from "./parser";
+import { typeStore } from "./TypeStore";
+
+export interface OctetStringParams extends BaseBlockParams, LocalOctetStringValueBlockParams { }
+export type OctetStringJson = BaseBlockJson<LocalOctetStringValueBlockJson>;
+
+export class OctetString extends BaseBlock<LocalOctetStringValueBlock, LocalOctetStringValueBlockJson> {
+
+  static {
+    typeStore.OctetString = this;
+  }
+
+  public static override NAME = OCTET_STRING_NAME;
+
+  constructor({
+    idBlock = {},
+    lenBlock = {},
+    ...parameters
+  }: OctetStringParams = {}) {
+    parameters.isConstructed ??= !!parameters.value?.length;
+    super({
+      idBlock: {
+        isConstructed: parameters.isConstructed,
+        ...idBlock,
+      },
+      lenBlock: {
+        ...lenBlock,
+        isIndefiniteForm: !!parameters.isIndefiniteForm,
+      },
+      ...parameters,
+    }, LocalOctetStringValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 4; // OctetString
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    this.valueBlock.isConstructed = this.idBlock.isConstructed;
+    this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
+
+    // Ability to encode empty OCTET STRING
+    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 as OctetString];
+          }
+        }
+      } catch (e) {
+        // nothing
+      }
+    }
+
+    return super.fromBER(inputBuffer, inputOffset, inputLength);
+  }
+
+  protected override onAsciiEncoding(): string {
+    if (this.valueBlock.isConstructed || (this.valueBlock.value && this.valueBlock.value.length)) {
+      return Constructed.prototype.onAsciiEncoding.call(this);
+    }
+
+    return `${(this.constructor as typeof OctetString).NAME} : ${pvtsutils.Convert.ToHex(this.valueBlock.valueHexView)}`;
+  }
+
+  /**
+   * Returns OctetString value. If OctetString is constructed, returns concatenated internal OctetString values
+   * @returns Array buffer
+   * @since 3.0.0
+   */
+  public getValue(): ArrayBuffer {
+    if (!this.idBlock.isConstructed) {
+      return this.valueBlock.valueHexView.slice().buffer;
+    }
+
+    const array: ArrayBuffer[] = [];
+    for (const content of this.valueBlock.value) {
+      if (content instanceof OctetString) {
+        array.push(content.valueBlock.valueHexView);
+      }
+    }
+
+    return pvtsutils.BufferSourceConverter.concat(array);
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Primitive.ts b/comm/third_party/asn1js/src/Primitive.ts
new file mode 100644
index 0000000000..49b25c343b
--- /dev/null
+++ b/comm/third_party/asn1js/src/Primitive.ts
@@ -0,0 +1,22 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { LocalPrimitiveValueBlock, LocalPrimitiveValueBlockJson, LocalPrimitiveValueBlockParams } from "./internals/LocalPrimitiveValueBlock";
+import { typeStore } from "./TypeStore";
+
+export interface PrimitiveParams extends BaseBlockParams, LocalPrimitiveValueBlockParams { }
+export type PrimitiveJson = BaseBlockJson<LocalPrimitiveValueBlockJson>;
+
+export class Primitive extends BaseBlock<LocalPrimitiveValueBlock, LocalPrimitiveValueBlockJson> {
+
+  static {
+    typeStore.Primitive = this;
+  }
+
+  public static override NAME = "PRIMITIVE";
+
+  constructor(parameters: PrimitiveParams = {}) {
+    super(parameters, LocalPrimitiveValueBlock);
+
+    this.idBlock.isConstructed = false;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/PrintableString.ts b/comm/third_party/asn1js/src/PrintableString.ts
new file mode 100644
index 0000000000..3eca544079
--- /dev/null
+++ b/comm/third_party/asn1js/src/PrintableString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type PrintableStringParams = LocalSimpleStringBlockParams;
+export type PrintableStringJson = LocalSimpleStringBlockJson;
+
+export class PrintableString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.PrintableString = this;
+  }
+
+  public static override NAME = "PrintableString";
+
+  constructor(parameters: PrintableStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 19; // PrintableString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/RawData.ts b/comm/third_party/asn1js/src/RawData.ts
new file mode 100644
index 0000000000..86228739fc
--- /dev/null
+++ b/comm/third_party/asn1js/src/RawData.ts
@@ -0,0 +1,51 @@
+import * as pvtsutils from "pvtsutils";
+import { IBerConvertible } from "./types";
+import { EMPTY_VIEW } from "./internals/constants";
+
+export interface IRawData {
+  data: ArrayBuffer;
+}
+
+export type RawDataParams = Partial<IRawData>;
+
+/**
+ * Special class providing ability to have "toBER/fromBER" for raw ArrayBuffer
+ */
+export class RawData implements IBerConvertible {
+
+
+  /**
+   * @deprecated Since v3.0.0
+   */
+  public get data(): ArrayBuffer {
+    return this.dataView.slice().buffer;
+  }
+
+  /**
+   * @deprecated Since v3.0.0
+   */
+  public set data(value: ArrayBuffer) {
+    this.dataView = pvtsutils.BufferSourceConverter.toUint8Array(value);
+  }
+
+  /**
+   * @since 3.0.0
+   */
+  public dataView: Uint8Array;
+
+  constructor({ data = EMPTY_VIEW }: RawDataParams = {}) {
+    this.dataView = pvtsutils.BufferSourceConverter.toUint8Array(data);
+  }
+
+  public fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    const endLength = inputOffset + inputLength;
+    this.dataView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer).subarray(inputOffset, endLength);
+
+    return endLength;
+  }
+
+  public toBER(sizeOnly?: boolean): ArrayBuffer {
+    return this.dataView.slice().buffer;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/RelativeObjectIdentifier.ts b/comm/third_party/asn1js/src/RelativeObjectIdentifier.ts
new file mode 100644
index 0000000000..997220eae4
--- /dev/null
+++ b/comm/third_party/asn1js/src/RelativeObjectIdentifier.ts
@@ -0,0 +1,54 @@
+import { BaseBlock, BaseBlockJson, BaseBlockParams } from "./BaseBlock";
+import { LocalRelativeObjectIdentifierValueBlockParams, LocalRelativeObjectIdentifierValueBlock, LocalRelativeObjectIdentifierValueBlockJson } from "./internals/LocalRelativeObjectIdentifierValueBlock";
+import { typeStore } from "./TypeStore";
+
+
+export interface RelativeObjectIdentifierParams extends BaseBlockParams, LocalRelativeObjectIdentifierValueBlockParams { }
+export interface RelativeObjectIdentifierJson extends BaseBlockJson<LocalRelativeObjectIdentifierValueBlockJson> {
+  value: string;
+}
+
+export class RelativeObjectIdentifier extends BaseBlock<LocalRelativeObjectIdentifierValueBlock, LocalRelativeObjectIdentifierValueBlockJson> {
+
+  static {
+    typeStore.RelativeObjectIdentifier = this;
+  }
+
+  /**
+   * Gets string representation of Relative Object Identifier
+   * @since 3.0.0
+   */
+  public getValue(): string {
+    return this.valueBlock.toString();
+  }
+
+  /**
+   * Sets Relative Object Identifier value from string
+   * @param value String value
+   * @since 3.0.0
+   */
+  public setValue(value: string): void {
+    this.valueBlock.fromString(value);
+  }
+
+  public static override NAME = "RelativeObjectIdentifier";
+
+  constructor(parameters: RelativeObjectIdentifierParams = {}) {
+    super(parameters, LocalRelativeObjectIdentifierValueBlock);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 13; // RELATIVE OBJECT IDENTIFIER
+  }
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof RelativeObjectIdentifier).NAME} : ${this.valueBlock.toString() || "empty"}`;
+  }
+
+  public override toJSON(): RelativeObjectIdentifierJson {
+    return {
+      ...super.toJSON(),
+      value: this.getValue(),
+    };
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Repeated.ts b/comm/third_party/asn1js/src/Repeated.ts
new file mode 100644
index 0000000000..38142fa533
--- /dev/null
+++ b/comm/third_party/asn1js/src/Repeated.ts
@@ -0,0 +1,26 @@
+import { IAny, Any } from "./Any";
+
+export interface IRepeated extends IAny {
+  value: Any;
+  local: boolean;
+}
+
+export type RepeatedParams = Partial<IRepeated>;
+
+export class Repeated extends Any {
+
+  public value: Any;
+  public local: boolean;
+
+  constructor({
+    value = new Any(),
+    local = false,
+    ...parameters
+  }: RepeatedParams = {}) {
+    super(parameters);
+
+    this.value = value;
+    this.local = local; // Could local or global array to store elements
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Sequence.ts b/comm/third_party/asn1js/src/Sequence.ts
new file mode 100644
index 0000000000..3303283bb2
--- /dev/null
+++ b/comm/third_party/asn1js/src/Sequence.ts
@@ -0,0 +1,22 @@
+import { ConstructedParams, Constructed, ConstructedJson } from "./Constructed";
+import { typeStore } from "./TypeStore";
+
+export type SequenceParams = ConstructedParams;
+export type SequenceJson = ConstructedJson;
+
+export class Sequence extends Constructed {
+
+  static {
+    typeStore.Sequence = this;
+  }
+
+  public static override NAME = "SEQUENCE";
+
+  constructor(parameters: SequenceParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 16; // Sequence
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Set.ts b/comm/third_party/asn1js/src/Set.ts
new file mode 100644
index 0000000000..1bbdec447c
--- /dev/null
+++ b/comm/third_party/asn1js/src/Set.ts
@@ -0,0 +1,22 @@
+import { ConstructedParams, Constructed, ConstructedJson } from "./Constructed";
+import { typeStore } from "./TypeStore";
+
+export type SetParams = ConstructedParams;
+export type SetJson = ConstructedJson;
+
+export class Set extends Constructed {
+
+  static {
+    typeStore.Set = this;
+  }
+
+  public static override NAME = "SET";
+
+  constructor(parameters: SetParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 17; // Set
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/TIME.ts b/comm/third_party/asn1js/src/TIME.ts
new file mode 100644
index 0000000000..97fee031b0
--- /dev/null
+++ b/comm/third_party/asn1js/src/TIME.ts
@@ -0,0 +1,22 @@
+import { typeStore } from "./TypeStore";
+import { Utf8StringParams, Utf8String, Utf8StringJson } from "./Utf8String";
+
+export type TIMEParams = Utf8StringParams;
+export type TIMEJson = Utf8StringJson;
+
+export class TIME extends Utf8String {
+
+  static {
+    typeStore.TIME = this;
+  }
+
+  public static override NAME = "TIME";
+
+  constructor(parameters: TIMEParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 14; // Time
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/TeletexString.ts b/comm/third_party/asn1js/src/TeletexString.ts
new file mode 100644
index 0000000000..0f7e38d36c
--- /dev/null
+++ b/comm/third_party/asn1js/src/TeletexString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type TeletexStringParams = LocalSimpleStringBlockParams;
+export type TeletexStringJson = LocalSimpleStringBlockJson;
+
+export class TeletexString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.TeletexString = this;
+  }
+
+  public static override NAME = "TeletexString";
+
+  constructor(parameters: TeletexStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 20; // TeletexString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/TimeOfDay.ts b/comm/third_party/asn1js/src/TimeOfDay.ts
new file mode 100644
index 0000000000..78c8fac4ec
--- /dev/null
+++ b/comm/third_party/asn1js/src/TimeOfDay.ts
@@ -0,0 +1,22 @@
+import { typeStore } from "./TypeStore";
+import { Utf8StringParams, Utf8String, Utf8StringJson } from "./Utf8String";
+
+export type TimeOfDayParams = Utf8StringParams;
+export type TimeOfDayJson = Utf8StringJson;
+
+export class TimeOfDay extends Utf8String {
+
+  static {
+    typeStore.TimeOfDay = this;
+  }
+
+  public static override NAME = "TimeOfDay";
+
+  constructor(parameters: TimeOfDayParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 32; // TimeOfDay
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/TypeStore.ts b/comm/third_party/asn1js/src/TypeStore.ts
new file mode 100644
index 0000000000..17b86ae97d
--- /dev/null
+++ b/comm/third_party/asn1js/src/TypeStore.ts
@@ -0,0 +1,71 @@
+import type { BaseBlock } from "./BaseBlock";
+import type { BitString } from "./BitString";
+import type { BmpString } from "./BmpString";
+import type { Boolean as AsnBoolean } from "./Boolean";
+import type { CharacterString } from "./CharacterString";
+import type { Constructed } from "./Constructed";
+import type { DATE } from "./DATE";
+import type { DateTime } from "./DateTime";
+import type { Duration } from "./Duration";
+import type { EndOfContent } from "./EndOfContent";
+import type { Enumerated } from "./Enumerated";
+import type { GeneralizedTime } from "./GeneralizedTime";
+import type { GeneralString } from "./GeneralString";
+import type { GraphicString } from "./GraphicString";
+import type { IA5String } from "./IA5String";
+import type { Integer } from "./Integer";
+import type { Null } from "./Null";
+import type { NumericString } from "./NumericString";
+import type { ObjectIdentifier } from "./ObjectIdentifier";
+import type { OctetString } from "./OctetString";
+import type { Primitive } from "./Primitive";
+import type { PrintableString } from "./PrintableString";
+import type { RelativeObjectIdentifier } from "./RelativeObjectIdentifier";
+import type { Sequence } from "./Sequence";
+import type { Set } from "./Set";
+import type { TeletexString } from "./TeletexString";
+import type { TIME } from "./TIME";
+import type { TimeOfDay } from "./TimeOfDay";
+import type { UniversalString } from "./UniversalString";
+import type { UTCTime } from "./UTCTime";
+import type { Utf8String } from "./Utf8String";
+import type { VideotexString } from "./VideotexString";
+import type { VisibleString } from "./VisibleString";
+
+export type AsnType = BaseBlock | EndOfContent | AsnBoolean | Integer | BitString | OctetString | Null | ObjectIdentifier | Enumerated | Utf8String | RelativeObjectIdentifier | TIME | Sequence | Set | NumericString | PrintableString | TeletexString | VideotexString | IA5String | UTCTime | GeneralizedTime | GraphicString | VisibleString | GeneralString | UniversalString | CharacterString | BmpString | DATE | TimeOfDay | DateTime | Duration | Constructed | Primitive;
+
+export interface TypeStore {
+  BitString: typeof BitString;
+  BmpString: typeof BmpString;
+  Boolean: typeof AsnBoolean;
+  CharacterString: typeof CharacterString;
+  Constructed: typeof Constructed;
+  DATE: typeof DATE;
+  DateTime: typeof DateTime;
+  Duration: typeof Duration;
+  EndOfContent: typeof EndOfContent;
+  Enumerated: typeof Enumerated;
+  GeneralizedTime: typeof GeneralizedTime;
+  GeneralString: typeof GeneralString;
+  GraphicString: typeof GraphicString;
+  IA5String: typeof IA5String;
+  Integer: typeof Integer;
+  Null: typeof Null;
+  NumericString: typeof NumericString;
+  ObjectIdentifier: typeof ObjectIdentifier;
+  OctetString: typeof OctetString;
+  Primitive: typeof Primitive;
+  PrintableString: typeof PrintableString;
+  RelativeObjectIdentifier: typeof RelativeObjectIdentifier;
+  Sequence: typeof Sequence;
+  Set: typeof Set;
+  TeletexString: typeof TeletexString;
+  TIME: typeof TIME;
+  TimeOfDay: typeof TimeOfDay;
+  UniversalString: typeof UniversalString;
+  UTCTime: typeof UTCTime;
+  Utf8String: typeof Utf8String;
+  VideotexString: typeof VideotexString;
+  VisibleString: typeof VisibleString;
+}
+export const typeStore = {} as TypeStore;
diff --git a/comm/third_party/asn1js/src/UTCTime.ts b/comm/third_party/asn1js/src/UTCTime.ts
new file mode 100644
index 0000000000..a387556051
--- /dev/null
+++ b/comm/third_party/asn1js/src/UTCTime.ts
@@ -0,0 +1,172 @@
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { BaseBlockJson, StringEncoding } from "./BaseBlock";
+import { LocalSimpleStringValueBlockJson } from "./internals/LocalSimpleStringValueBlock";
+import { IDateConvertible } from "./types";
+import { typeStore } from "./TypeStore";
+import { VisibleStringParams, VisibleString } from "./VisibleString";
+
+export interface IUTCTime {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+}
+
+export interface UTCTimeParams extends VisibleStringParams {
+  value?: string;
+  valueDate?: Date;
+}
+export interface UTCTimeJson extends BaseBlockJson<LocalSimpleStringValueBlockJson>, IUTCTime { }
+
+export type DateStringEncoding = StringEncoding | "iso";
+
+export class UTCTime extends VisibleString implements IUTCTime, IDateConvertible {
+
+  static {
+    typeStore.UTCTime = this;
+  }
+
+  public static override NAME = "UTCTime";
+
+  public year: number;
+  public month: number;
+  public day: number;
+  public hour: number;
+  public minute: number;
+  public second: number;
+
+  constructor({
+    value,
+    valueDate,
+    ...parameters
+  }: UTCTimeParams = {}) {
+    super(parameters);
+
+    this.year = 0;
+    this.month = 0;
+    this.day = 0;
+    this.hour = 0;
+    this.minute = 0;
+    this.second = 0;
+
+    //#region Create UTCTime from ASN.1 UTC string value
+    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);
+    }
+    //#endregion
+    //#region Create GeneralizedTime from JavaScript Date type
+    if (valueDate) {
+      this.fromDate(valueDate);
+      this.valueBlock.valueHexView = new Uint8Array(this.toBuffer());
+    }
+    //#endregion
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 23; // UTCTime
+  }
+
+  public override fromBuffer(inputBuffer: ArrayBuffer | Uint8Array): void {
+    this.fromString(String.fromCharCode.apply(null, pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer) as unknown as number[]));
+  }
+
+  /**
+   * Function converting ASN.1 internal string into ArrayBuffer
+   * @returns
+   */
+  public toBuffer(): ArrayBuffer {
+    const str = this.toString(); // TODO use this.valueBlock.value and update 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;
+  }
+
+  /**
+   * Function converting "Date" object into ASN.1 internal string
+   * @param {!Date} inputDate JavaScript "Date" object
+   */
+  public fromDate(inputDate: Date): void {
+    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();
+  }
+
+  public toDate(): Date {
+    return (new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second)));
+  }
+
+  public override fromString(inputString: string): void {
+    //#region Parse input string
+    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;
+    }
+    //#endregion
+    //#region Store parsed values
+    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);
+    //#endregion
+  }
+
+  public override toString(encoding: DateStringEncoding = "iso"): string {
+    if (encoding === "iso") {
+      const outputArray = new Array(7);
+
+      outputArray[0] = pvutils.padNumber(((this.year < 2000) ? (this.year - 1900) : (this.year - 2000)), 2);
+      outputArray[1] = pvutils.padNumber(this.month, 2);
+      outputArray[2] = pvutils.padNumber(this.day, 2);
+      outputArray[3] = pvutils.padNumber(this.hour, 2);
+      outputArray[4] = pvutils.padNumber(this.minute, 2);
+      outputArray[5] = pvutils.padNumber(this.second, 2);
+      outputArray[6] = "Z";
+
+      return outputArray.join("");
+    }
+
+    return super.toString(encoding);
+  }
+
+  protected override onAsciiEncoding(): string {
+    return `${(this.constructor as typeof UTCTime).NAME} : ${this.toDate().toISOString()}`;
+  }
+
+  public override toJSON(): UTCTimeJson {
+    return {
+      ...super.toJSON(),
+      year: this.year,
+      month: this.month,
+      day: this.day,
+      hour: this.hour,
+      minute: this.minute,
+      second: this.second,
+    };
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/UniversalString.ts b/comm/third_party/asn1js/src/UniversalString.ts
new file mode 100644
index 0000000000..fce5b1d0ac
--- /dev/null
+++ b/comm/third_party/asn1js/src/UniversalString.ts
@@ -0,0 +1,24 @@
+import { LocalUniversalStringValueBlockParams, LocalUniversalStringValueBlock, LocalUniversalStringValueBlockJson } from "./internals/LocalUniversalStringValueBlockParams";
+import { typeStore } from "./TypeStore";
+
+export type UniversalStringParams = LocalUniversalStringValueBlockParams;
+export type UniversalStringJson = LocalUniversalStringValueBlockJson;
+
+export class UniversalString extends LocalUniversalStringValueBlock {
+
+  static {
+    typeStore.UniversalString = this;
+  }
+
+  public static override NAME = "UniversalString";
+
+  constructor({
+    ...parameters
+  }: UniversalStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 28; // UniversalString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/Utf8String.ts b/comm/third_party/asn1js/src/Utf8String.ts
new file mode 100644
index 0000000000..2713cd1b95
--- /dev/null
+++ b/comm/third_party/asn1js/src/Utf8String.ts
@@ -0,0 +1,24 @@
+import { BaseBlockJson } from "./BaseBlock";
+import { BaseStringBlockParams } from "./BaseStringBlock";
+import { LocalUtf8StringValueBlockParams, LocalUtf8StringValueBlock, LocalUtf8StringValueBlockJson } from "./internals/LocalUtf8StringValueBlock";
+import { typeStore } from "./TypeStore";
+
+export interface Utf8StringParams extends BaseStringBlockParams, LocalUtf8StringValueBlockParams { }
+export type Utf8StringJson = BaseBlockJson<LocalUtf8StringValueBlockJson>;
+
+export class Utf8String extends LocalUtf8StringValueBlock {
+
+  static {
+    typeStore.Utf8String = this;
+  }
+
+  public static override NAME = "UTF8String";
+
+  constructor(parameters: Utf8StringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 12; // Utf8String
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/ValueBlock.ts b/comm/third_party/asn1js/src/ValueBlock.ts
new file mode 100644
index 0000000000..9463214aef
--- /dev/null
+++ b/comm/third_party/asn1js/src/ValueBlock.ts
@@ -0,0 +1,21 @@
+import { IBerConvertible } from "./types";
+import * as internals from "./internals/LocalBaseBlock";
+import { ViewWriter } from "./ViewWriter";
+
+export type IValueBlock = internals.ILocalBaseBlock;
+export type ValueBlockParams = internals.LocalBaseBlockParams;
+export type ValueBlockJson = internals.LocalBaseBlockJson;
+
+export class ValueBlock extends internals.LocalBaseBlock implements IValueBlock, IBerConvertible {
+
+  public static override NAME = "valueBlock";
+
+  public fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
+  }
+
+  public toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/VideotexString.ts b/comm/third_party/asn1js/src/VideotexString.ts
new file mode 100644
index 0000000000..d1867b602e
--- /dev/null
+++ b/comm/third_party/asn1js/src/VideotexString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type VideotexStringParams = LocalSimpleStringBlockParams;
+export type VideotexStringJson = LocalSimpleStringBlockJson;
+
+export class VideotexString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.VideotexString = this;
+  }
+
+  public static override NAME = "VideotexString";
+
+  constructor(parameters: VideotexStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 21; // VideotexString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/ViewWriter.ts b/comm/third_party/asn1js/src/ViewWriter.ts
new file mode 100644
index 0000000000..1df3a1170c
--- /dev/null
+++ b/comm/third_party/asn1js/src/ViewWriter.ts
@@ -0,0 +1,22 @@
+import * as utils from "./internals/utils";
+
+export class ViewWriter {
+
+  public items: ArrayBuffer[] = [];
+
+  /**
+   * Writes buffer
+   * @param buf
+   */
+  public write(buf: ArrayBuffer): void {
+    this.items.push(buf);
+  }
+
+  /**
+   * Concatenates all buffers
+   * @returns Concatenated buffer
+   */
+  public final(): ArrayBuffer {
+    return utils.concat(this.items);
+  }
+}
diff --git a/comm/third_party/asn1js/src/VisibleString.ts b/comm/third_party/asn1js/src/VisibleString.ts
new file mode 100644
index 0000000000..aead80a4cc
--- /dev/null
+++ b/comm/third_party/asn1js/src/VisibleString.ts
@@ -0,0 +1,22 @@
+import { LocalSimpleStringBlockParams, LocalSimpleStringBlock, LocalSimpleStringBlockJson } from "./internals/LocalSimpleStringBlock";
+import { typeStore } from "./TypeStore";
+
+export type VisibleStringParams = LocalSimpleStringBlockParams;
+export type VisibleStringJson = LocalSimpleStringBlockJson;
+
+export class VisibleString extends LocalSimpleStringBlock {
+
+  static {
+    typeStore.VisibleString = this;
+  }
+
+  public static override NAME = "VisibleString";
+
+  constructor(parameters: VisibleStringParams = {}) {
+    super(parameters);
+
+    this.idBlock.tagClass = 1; // UNIVERSAL
+    this.idBlock.tagNumber = 26; // VisibleString
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/index.ts b/comm/third_party/asn1js/src/index.ts
new file mode 100644
index 0000000000..a4b15b34af
--- /dev/null
+++ b/comm/third_party/asn1js/src/index.ts
@@ -0,0 +1,59 @@
+export * from "./types";
+
+// basic
+export * from "./ViewWriter";
+export * from "./HexBlock";
+export * from "./ValueBlock";
+export * from "./BaseBlock";
+export * from "./BaseStringBlock";
+
+export * from "./Primitive";
+export * from "./Constructed";
+export * from "./EndOfContent";
+
+// common
+export * from "./Null";
+export * from "./Boolean";
+export * from "./OctetString";
+export * from "./BitString";
+export * from "./Integer";
+export * from "./Enumerated";
+export * from "./ObjectIdentifier";
+export * from "./RelativeObjectIdentifier";
+export * from "./Sequence";
+export * from "./Set";
+
+// strings
+export * from "./Utf8String";
+export * from "./BmpString";
+export * from "./UniversalString";
+export * from "./NumericString";
+export * from "./PrintableString";
+export * from "./TeletexString";
+export * from "./VideotexString";
+export * from "./IA5String";
+export * from "./GraphicString";
+export * from "./VisibleString";
+export * from "./GeneralString";
+export * from "./CharacterString";
+
+// date and time
+export * from "./UTCTime";
+export * from "./GeneralizedTime";
+export * from "./DATE";
+export * from "./TimeOfDay";
+export * from "./DateTime";
+export * from "./Duration";
+export * from "./TIME";
+
+// schema types
+export * from "./Any";
+export * from "./Choice";
+export * from "./Repeated";
+
+// special
+export * from "./RawData";
+
+export { FromBerResult, fromBER } from "./parser";
+export * from "./schema";
+export { AsnType } from "./TypeStore";
\ No newline at end of file
diff --git a/comm/third_party/asn1js/src/internals/LocalBaseBlock.ts b/comm/third_party/asn1js/src/internals/LocalBaseBlock.ts
new file mode 100644
index 0000000000..c144c49d10
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalBaseBlock.ts
@@ -0,0 +1,93 @@
+import * as pvtsutils from "pvtsutils";
+import { EMPTY_STRING, EMPTY_VIEW } from "./constants";
+
+export interface ILocalBaseBlock {
+  blockLength: number;
+  error: string;
+  warnings: string[];
+}
+
+export interface LocalBaseBlockJson extends ILocalBaseBlock {
+  blockName: string;
+  valueBeforeDecode: string;
+}
+
+export interface LocalBaseBlockParams extends Partial<ILocalBaseBlock> {
+  valueBeforeDecode?: pvtsutils.BufferSource;
+}
+
+export interface LocalBaseBlockConstructor<T extends LocalBaseBlock = LocalBaseBlock> {
+  new(...args: any[]): T;
+  prototype: T;
+  NAME: string;
+  blockName(): string;
+}
+
+/**
+ * Class used as a base block for all remaining ASN.1 classes
+ */
+export class LocalBaseBlock implements ILocalBaseBlock {
+
+  /**
+   * Name of the block
+   */
+  public static NAME = "baseBlock";
+  /**
+   * Aux function, need to get a block name. Need to have it here for inheritance
+   * @returns Returns name of the block
+   */
+  public static blockName(): string {
+    return this.NAME;
+  }
+
+  public blockLength: number;
+  public error: string;
+  public warnings: string[];
+  /**
+   * @deprecated since version 3.0.0
+   */
+  public get valueBeforeDecode(): ArrayBuffer {
+    return this.valueBeforeDecodeView.slice().buffer;
+  }
+  /**
+   * @deprecated since version 3.0.0
+   */
+  public set valueBeforeDecode(value: ArrayBuffer) {
+    this.valueBeforeDecodeView = new Uint8Array(value);
+  }
+  /**
+   * @since 3.0.0
+   */
+  public valueBeforeDecodeView: Uint8Array;
+
+  /**
+   * Creates and initializes an object instance of that class
+   * @param param0 Initialization parameters
+   */
+  constructor({
+    blockLength = 0,
+    error = EMPTY_STRING,
+    warnings = [],
+    valueBeforeDecode = EMPTY_VIEW,
+  }: LocalBaseBlockParams = {}) {
+    this.blockLength = blockLength;
+    this.error = error;
+    this.warnings = warnings;
+    this.valueBeforeDecodeView = pvtsutils.BufferSourceConverter.toUint8Array(valueBeforeDecode);
+  }
+
+  /**
+   * Returns a JSON representation of an object
+   * @returns JSON object
+   */
+  public toJSON(): LocalBaseBlockJson {
+    return {
+      blockName: (this.constructor as typeof LocalBaseBlock).NAME,
+      blockLength: this.blockLength,
+      error: this.error,
+      warnings: this.warnings,
+      valueBeforeDecode: pvtsutils.Convert.ToHex(this.valueBeforeDecodeView),
+    };
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalBitStringValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalBitStringValueBlock.ts
new file mode 100644
index 0000000000..1720b55d82
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalBitStringValueBlock.ts
@@ -0,0 +1,168 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import * as pvtsutils from "pvtsutils";
+import { ViewWriter } from "../ViewWriter";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { BIT_STRING_NAME, EMPTY_BUFFER, END_OF_CONTENT_NAME } from "./constants";
+import { LocalConstructedValueBlockParams, LocalConstructedValueBlockJson, LocalConstructedValueBlock } from "./LocalConstructedValueBlock";
+import { localFromBER } from "../parser";
+import { checkBufferParams } from "./utils";
+import type { BitString } from "../BitString";
+
+export interface ILocalBitStringValueBlock {
+  unusedBits: number;
+  isConstructed: boolean;
+}
+
+export interface LocalBitStringValueBlockParams extends HexBlockParams, LocalConstructedValueBlockParams, Partial<ILocalBitStringValueBlock> {
+  value?: BitString[];
+}
+
+export interface LocalBitStringValueBlockJson extends HexBlockJson, LocalConstructedValueBlockJson, ILocalBitStringValueBlock { }
+
+export class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) implements ILocalBitStringValueBlock {
+
+  public static override NAME = "BitStringValueBlock";
+
+  public unusedBits: number;
+  public isConstructed: boolean;
+
+  constructor({
+    unusedBits = 0,
+    isConstructed = false,
+    ...parameters
+  }: LocalBitStringValueBlockParams = {}) {
+    super(parameters);
+
+    this.unusedBits = unusedBits;
+    this.isConstructed = isConstructed;
+    this.blockLength = this.valueHexView.byteLength;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    // Ability to decode zero-length BitString value
+    if (!inputLength) {
+      return inputOffset;
+    }
+
+    let resultOffset = -1;
+
+    // If the BIT STRING supposed to be a constructed value
+    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 as typeof LocalBitStringValueBlock).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 as unknown as LocalBitStringValueBlock;
+        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 = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+
+    //If the BitString supposed to be a primitive value
+    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 as BitString];
+          }
+        }
+      } catch (e) {
+        // nothing
+      }
+    }
+
+    // Copy input buffer to internal buffer
+    this.valueHexView = intBuffer.subarray(1);
+    this.blockLength = intBuffer.length;
+
+    return (inputOffset + inputLength);
+  }
+
+  public override toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    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;
+  }
+
+  public override toJSON(): LocalBitStringValueBlockJson {
+    return {
+      ...super.toJSON(),
+      unusedBits: this.unusedBits,
+      isConstructed: this.isConstructed,
+    } as LocalBitStringValueBlockJson;
+  }
+}
+
+export interface LocalBitStringValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalBmpStringValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalBmpStringValueBlock.ts
new file mode 100644
index 0000000000..6245512755
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalBmpStringValueBlock.ts
@@ -0,0 +1,21 @@
+import * as pvtsutils from "pvtsutils";
+import { LocalSimpleStringBlock, LocalSimpleStringBlockJson, LocalSimpleStringBlockParams } from "./LocalSimpleStringBlock";
+
+export type LocalBmpStringValueBlockParams = LocalSimpleStringBlockParams;
+export type LocalBmpStringValueBlockJson = LocalSimpleStringBlockJson;
+
+export class LocalBmpStringValueBlock extends LocalSimpleStringBlock {
+
+  public static override NAME = "BmpStringValueBlock";
+
+  public override fromBuffer(inputBuffer: ArrayBuffer | Uint8Array): void {
+    this.valueBlock.value = pvtsutils.Convert.ToUtf16String(inputBuffer);
+    this.valueBlock.valueHexView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+  }
+
+  public override fromString(inputString: string): void {
+    this.valueBlock.value = inputString;
+    this.valueBlock.valueHexView = new Uint8Array(pvtsutils.Convert.FromUtf16String(inputString));
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalBooleanValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalBooleanValueBlock.ts
new file mode 100644
index 0000000000..a4cdb35dee
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalBooleanValueBlock.ts
@@ -0,0 +1,96 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { checkBufferParams } from "./utils";
+
+export interface ILocalBooleanValueBlock {
+  value: boolean;
+}
+
+export interface LocalBooleanValueBlockParams extends ValueBlockParams, HexBlockParams, Partial<ILocalBooleanValueBlock> { }
+
+export interface LocalBooleanValueBlockJson extends ValueBlockJson, HexBlockJson, ILocalBooleanValueBlock { }
+
+export class LocalBooleanValueBlock extends HexBlock(ValueBlock) implements ILocalBooleanValueBlock {
+
+  public static override NAME = "BooleanValueBlock";
+
+  public get value(): boolean {
+    for (const octet of this.valueHexView) {
+      if (octet > 0) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  public set value(value: boolean) {
+    this.valueHexView[0] = value ? 0xFF : 0x00;
+  }
+
+  constructor({
+    value,
+    ...parameters
+  }: LocalBooleanValueBlockParams = {}) {
+    super(parameters);
+
+    if (parameters.valueHex) {
+      this.valueHexView = pvtsutils.BufferSourceConverter.toUint8Array(parameters.valueHex);
+    } else {
+      this.valueHexView = new Uint8Array(1);
+    }
+
+    if (value) {
+      this.value = value;
+    }
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    const inputView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+    // Basic check for parameters
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+      return -1;
+    }
+
+    // Getting Uint8Array
+    this.valueHexView = inputView.subarray(inputOffset, inputOffset + inputLength);
+
+    if (inputLength > 1)
+      this.warnings.push("Boolean value encoded in more then 1 octet");
+
+    this.isHexOnly = true;
+    pvutils.utilDecodeTC.call(this);
+    this.blockLength = inputLength;
+
+    return (inputOffset + inputLength);
+  }
+
+  public override toBER(): ArrayBuffer {
+    return this.valueHexView.slice();
+  }
+
+  public override toJSON(): LocalBooleanValueBlockJson {
+    return {
+      ...super.toJSON(),
+      value: this.value,
+    };
+  }
+}
+
+export interface LocalBooleanValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalConstructedValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalConstructedValueBlock.ts
new file mode 100644
index 0000000000..db3ba9f35e
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalConstructedValueBlock.ts
@@ -0,0 +1,128 @@
+import * as pvtsutils from "pvtsutils";
+import { LocalBaseBlockJson } from "./LocalBaseBlock";
+import { EMPTY_BUFFER, END_OF_CONTENT_NAME } from "./constants";
+import type { BaseBlock } from "../BaseBlock";
+import { ValueBlock, ValueBlockParams } from "../ValueBlock";
+import { ViewWriter } from "../ViewWriter";
+import { localFromBER } from "../parser";
+import { checkBufferParams } from "./utils";
+import type { Any } from "../Any";
+
+export type ConstructedItem = BaseBlock | Any;
+
+export interface ILocalConstructedValueBlock {
+  value: ConstructedItem[];
+  isIndefiniteForm: boolean;
+}
+
+export interface LocalConstructedValueBlockParams extends ValueBlockParams, Partial<ILocalConstructedValueBlock> { }
+
+export interface LocalConstructedValueBlockJson extends LocalBaseBlockJson, Omit<ILocalConstructedValueBlock, "value"> {
+  value: LocalBaseBlockJson[];
+}
+
+function checkLen(indefiniteLength: boolean, length: number): number {
+  if (indefiniteLength) {
+    return 1;
+  }
+
+  return length;
+}
+
+export class LocalConstructedValueBlock extends ValueBlock implements ILocalConstructedValueBlock {
+
+  public static override NAME = "ConstructedValueBlock";
+
+  public value: BaseBlock[];
+  public isIndefiniteForm: boolean;
+
+  constructor({
+    value = [],
+    isIndefiniteForm = false,
+    ...parameters
+  }: LocalConstructedValueBlockParams = {}) {
+    super(parameters);
+
+    this.value = value as BaseBlock[]; // It's possible to set Any type for Schema declaration
+    this.isIndefiniteForm = isIndefiniteForm;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    const view = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+
+    // Basic check for parameters
+    if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+      return -1;
+    }
+
+    this.valueBeforeDecodeView = view.subarray(inputOffset, inputOffset + inputLength);
+
+    // Initial checks
+    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 as typeof BaseBlock).NAME === END_OF_CONTENT_NAME) {
+        break;
+      }
+    }
+
+    if (this.isIndefiniteForm) {
+      if ((this.value[this.value.length - 1].constructor as typeof BaseBlock).NAME === END_OF_CONTENT_NAME) {
+        this.value.pop();
+      } else {
+        this.warnings.push("No EndOfContent block encoded");
+      }
+    }
+
+    return currentOffset;
+  }
+
+  public override toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    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;
+  }
+
+  public override toJSON(): LocalConstructedValueBlockJson {
+    const object: LocalConstructedValueBlockJson = {
+      ...super.toJSON(),
+      isIndefiniteForm: this.isIndefiniteForm,
+      value: [],
+    };
+
+    for (const value of this.value) {
+      object.value.push(value.toJSON());
+    }
+
+    return object;
+  }
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalEndOfContentValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalEndOfContentValueBlock.ts
new file mode 100644
index 0000000000..4a1db86681
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalEndOfContentValueBlock.ts
@@ -0,0 +1,16 @@
+import { ValueBlock } from "../ValueBlock";
+import { EMPTY_BUFFER } from "./constants";
+
+export class LocalEndOfContentValueBlock extends ValueBlock {
+
+  public static override = "EndOfContentValueBlock";
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    // There is no "value block" for EndOfContent type and we need to return the same offset
+    return inputOffset;
+  }
+
+  public override toBER(sizeOnly?: boolean): ArrayBuffer {
+    return EMPTY_BUFFER;
+  }
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalIdentificationBlock.ts b/comm/third_party/asn1js/src/internals/LocalIdentificationBlock.ts
new file mode 100644
index 0000000000..d97c874b7a
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalIdentificationBlock.ts
@@ -0,0 +1,280 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { EMPTY_BUFFER, EMPTY_VIEW } from "./constants";
+import { LocalBaseBlock, LocalBaseBlockJson } from "./LocalBaseBlock";
+import { checkBufferParams } from "./utils";
+
+
+export interface ILocalIdentificationBlock {
+  tagClass: number;
+  tagNumber: number;
+  isConstructed: boolean;
+}
+
+export interface LocalIdentificationBlockParams {
+  idBlock?: Partial<ILocalIdentificationBlock> & HexBlockParams;
+}
+
+export interface LocalIdentificationBlockJson extends HexBlockJson, LocalBaseBlockJson, ILocalIdentificationBlock { }
+
+
+export class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) implements ILocalIdentificationBlock {
+
+  public static override NAME = "identificationBlock";
+
+  public tagClass: number;
+  public tagNumber: number;
+  public isConstructed: boolean;
+
+  constructor({
+    idBlock = {},
+  }: LocalIdentificationBlockParams = {}) {
+    super();
+
+    if (idBlock) {
+      //#region Properties from hexBlock class
+      this.isHexOnly = idBlock.isHexOnly ?? false;
+      this.valueHexView = idBlock.valueHex ? pvtsutils.BufferSourceConverter.toUint8Array(idBlock.valueHex) : EMPTY_VIEW;
+      //#endregion
+      this.tagClass = idBlock.tagClass ?? -1;
+      this.tagNumber = idBlock.tagNumber ?? -1;
+      this.isConstructed = idBlock.isConstructed ?? false;
+    } else {
+      this.tagClass = -1;
+      this.tagNumber = -1;
+      this.isConstructed = false;
+    }
+  }
+
+  public override toBER(sizeOnly = false): ArrayBuffer {
+    let firstOctet = 0;
+
+    switch (this.tagClass) {
+      case 1:
+        firstOctet |= 0x00; // UNIVERSAL
+        break;
+      case 2:
+        firstOctet |= 0x40; // APPLICATION
+        break;
+      case 3:
+        firstOctet |= 0x80; // CONTEXT-SPECIFIC
+        break;
+      case 4:
+        firstOctet |= 0xC0; // PRIVATE
+        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 = pvutils.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;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    const inputView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+
+    // Basic check for parameters
+    if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
+      return -1;
+    }
+
+    // Getting Uint8Array from ArrayBuffer
+    const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
+
+    // Initial checks
+    if (intBuffer.length === 0) {
+      this.error = "Zero buffer length";
+
+      return -1;
+    }
+
+    //#region Find tag class
+    const tagClassMask = intBuffer[0] & 0xC0;
+
+    switch (tagClassMask) {
+      case 0x00:
+        this.tagClass = (1); // UNIVERSAL
+        break;
+      case 0x40:
+        this.tagClass = (2); // APPLICATION
+        break;
+      case 0x80:
+        this.tagClass = (3); // CONTEXT-SPECIFIC
+        break;
+      case 0xC0:
+        this.tagClass = (4); // PRIVATE
+        break;
+      default:
+        this.error = "Unknown tag class";
+
+        return -1;
+    }
+    //#endregion
+    // Find it's constructed or not
+    this.isConstructed = (intBuffer[0] & 0x20) === 0x20;
+
+    // Find tag number
+    this.isHexOnly = false;
+    const tagNumberMask = intBuffer[0] & 0x1F;
+
+    if (tagNumberMask !== 0x1F) {
+      // Simple case (tag number < 31)
+      this.tagNumber = (tagNumberMask);
+      this.blockLength = 1;
+    } else {
+      // Tag number bigger or equal to 31
+      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;
+        }
+
+        // In case if tag number length is greater than 255 bytes (rare but possible case)
+        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; // Write last byte to buffer
+
+
+      //#region Cut buffer
+      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);
+      //#endregion
+      //#region Try to convert long tag number to short form
+      if (this.blockLength <= 9)
+        this.tagNumber = pvutils.utilFromBase(intTagNumberBuffer, 7);
+      else {
+        this.isHexOnly = true;
+        this.warnings.push("Tag too long, represented as hex-coded");
+      }
+      //#endregion
+    }
+    //#endregion
+    //#endregion
+    //#region Check if constructed encoding was using for primitive type
+    if (((this.tagClass === 1)) &&
+      (this.isConstructed)) {
+      switch (this.tagNumber) {
+        case 1: // Boolean
+        case 2: // REAL
+        case 5: // Null
+        case 6: // OBJECT IDENTIFIER
+        case 9: // REAL
+        case 13: // RELATIVE OBJECT IDENTIFIER
+        case 14: // Time
+        case 23:
+        case 24:
+        case 31:
+        case 32:
+        case 33:
+        case 34:
+          this.error = "Constructed encoding used for primitive type";
+
+          return -1;
+        default:
+      }
+    }
+    //#endregion
+
+    return (inputOffset + this.blockLength); // Return current offset in input buffer
+  }
+
+  public override toJSON(): LocalIdentificationBlockJson {
+    return {
+      ...super.toJSON(),
+      tagClass: this.tagClass,
+      tagNumber: this.tagNumber,
+      isConstructed: this.isConstructed,
+    };
+  }
+}
+
+export interface LocalIdentificationBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
\ No newline at end of file
diff --git a/comm/third_party/asn1js/src/internals/LocalIntegerValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalIntegerValueBlock.ts
new file mode 100644
index 0000000000..3a7b299caf
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalIntegerValueBlock.ts
@@ -0,0 +1,330 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import * as pvutils from "pvutils";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { IDerConvertible } from "../types";
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { powers2, digitsString } from "./constants";
+
+function viewAdd(first: Uint8Array, second: Uint8Array): Uint8Array {
+  //#region Initial variables
+  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;
+  //#endregion
+  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 = pvutils.utilConcatView(new Uint8Array([value % 10]), firstViewCopy);
+        break;
+      default:
+        firstViewCopy[firstViewCopyLength - counter] = value % 10;
+    }
+  }
+
+  if (c[0] > 0)
+    firstViewCopy = pvutils.utilConcatView(c, firstViewCopy);
+
+  return firstViewCopy;
+}
+
+function power2(n: number): Uint8Array {
+  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 = pvutils.utilConcatView(c, digits);
+
+      powers2.push(digits);
+    }
+  }
+
+  return powers2[n];
+}
+
+function viewSub(first: Uint8Array, second: Uint8Array): Uint8Array {
+  //#region Initial variables
+  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;
+  //#endregion
+  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();
+}
+
+export interface ILocalIntegerValueBlock {
+  value: number;
+}
+
+export interface LocalIntegerValueBlockParams extends HexBlockParams, ValueBlockParams, Partial<ILocalIntegerValueBlock> { }
+
+export interface LocalIntegerValueBlockJson extends HexBlockJson, ValueBlockJson {
+  valueDec: number;
+}
+
+export class LocalIntegerValueBlock extends HexBlock(ValueBlock) implements IDerConvertible {
+  protected setValueHex(): void {
+    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 = pvutils.utilDecodeTC.call(this);
+      }
+    }
+  }
+
+  public static override NAME = "IntegerValueBlock";
+
+  static {
+    Object.defineProperty(this.prototype, "valueHex", {
+      set: function (this: LocalIntegerValueBlock, v: ArrayBuffer) {
+        this.valueHexView = new Uint8Array(v);
+
+        this.setValueHex();
+      },
+      get: function (this: LocalIntegerValueBlock) {
+        return this.valueHexView.slice().buffer;
+      },
+    });
+  }
+
+  private _valueDec = 0;
+
+  constructor({
+    value,
+    ...parameters
+  }: LocalIntegerValueBlockParams = {}) {
+    super(parameters);
+
+    if (parameters.valueHex) {
+      this.setValueHex();
+    }
+
+    if (value !== undefined) {
+      this.valueDec = value;
+    }
+  }
+
+  public set valueDec(v: number) {
+    this._valueDec = v;
+
+    this.isHexOnly = false;
+    this.valueHexView = new Uint8Array(pvutils.utilEncodeTC(v));
+  }
+
+  public get valueDec(): number {
+    return this._valueDec;
+  }
+
+  public fromDER(inputBuffer: ArrayBuffer, inputOffset: number, inputLength: number, expectedLength = 0): number {
+    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;
+  }
+
+  public toDER(sizeOnly = false): ArrayBuffer {
+    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;
+      default:
+    }
+
+    return this.toBER(sizeOnly);
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer, inputOffset: number, inputLength: number): number {
+    const resultOffset = super.fromBER(inputBuffer, inputOffset, inputLength);
+    if (resultOffset === -1) {
+      return resultOffset;
+    }
+
+    this.setValueHex();
+
+    return resultOffset;
+  }
+
+  public override toBER(sizeOnly?: boolean): ArrayBuffer {
+    return sizeOnly
+      ? new ArrayBuffer(this.valueHexView.length)
+      : this.valueHexView.slice().buffer;
+  }
+
+  public override toJSON(): LocalIntegerValueBlockJson {
+    return {
+      ...super.toJSON(),
+      valueDec: this.valueDec,
+    };
+  }
+
+  public override toString(): string {
+    //#region Initial variables
+    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;
+    //#endregion
+    //#region Calculate number
+    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;
+      }
+    }
+    //#endregion
+    //#region Print number
+    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);
+    //#endregion
+
+    return result;
+  }
+
+}
+
+export interface LocalIntegerValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalLengthBlock.ts b/comm/third_party/asn1js/src/internals/LocalLengthBlock.ts
new file mode 100644
index 0000000000..a4c7940b02
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalLengthBlock.ts
@@ -0,0 +1,182 @@
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { IBerConvertible } from "../types";
+import { EMPTY_BUFFER } from "./constants";
+import { LocalBaseBlock, LocalBaseBlockJson } from "./LocalBaseBlock";
+import { checkBufferParams } from "./utils";
+
+export interface ILocalLengthBlock {
+  isIndefiniteForm: boolean;
+  longFormUsed: boolean;
+  length: number;
+}
+
+export interface LocalLengthBlockParams {
+  lenBlock?: Partial<ILocalLengthBlock>;
+}
+
+export interface LocalLengthBlockJson extends LocalBaseBlockJson, ILocalLengthBlock {
+  isIndefiniteForm: boolean;
+  longFormUsed: boolean;
+  length: number;
+}
+
+export class LocalLengthBlock extends LocalBaseBlock implements ILocalLengthBlock, IBerConvertible {
+
+  public static override NAME = "lengthBlock";
+
+  public isIndefiniteForm: boolean;
+  public longFormUsed: boolean;
+  public length: number;
+
+  constructor({
+    lenBlock = {},
+  }: LocalLengthBlockParams = {}) {
+    super();
+
+    this.isIndefiniteForm = lenBlock.isIndefiniteForm ?? false;
+    this.longFormUsed = lenBlock.longFormUsed ?? false;
+    this.length = lenBlock.length ?? 0;
+  }
+
+
+  public fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    const view = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+    // Basic check for parameters
+    if (!checkBufferParams(this, view, inputOffset, inputLength)) {
+      return -1;
+    }
+    //#region Getting Uint8Array from ArrayBuffer
+    const intBuffer = view.subarray(inputOffset, inputOffset + inputLength);
+    //#endregion
+    //#region Initial checks
+    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;
+    }
+    //#endregion
+    //#region Check for length form type
+    this.isIndefiniteForm = intBuffer[0] === 0x80;
+    //#endregion
+    //#region Stop working in case of indefinite length form
+    if (this.isIndefiniteForm) {
+      this.blockLength = 1;
+
+      return (inputOffset + this.blockLength);
+    }
+    //#endregion
+    //#region Check is long form of length encoding using
+    this.longFormUsed = !!(intBuffer[0] & 0x80);
+    //#endregion
+    //#region Stop working in case of short form of length value
+    if (this.longFormUsed === false) {
+      this.length = (intBuffer[0]);
+      this.blockLength = 1;
+
+      return (inputOffset + this.blockLength);
+    }
+    //#endregion
+    //#region Calculate length value in case of long form
+    const count = intBuffer[0] & 0x7F;
+
+    if (count > 8) // Too big length value
+    {
+      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 = pvutils.utilFromBase(lengthBufferView, 8);
+
+    if (this.longFormUsed && (this.length <= 127))
+      this.warnings.push("Unnecessary usage of long length form");
+
+    this.blockLength = count + 1;
+    //#endregion
+
+    return (inputOffset + this.blockLength); // Return current offset in input buffer
+  }
+
+  public toBER(sizeOnly = false): ArrayBuffer {
+    //#region Initial variables
+    let retBuf: ArrayBuffer;
+    let retView: Uint8Array;
+    //#endregion
+    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 = pvutils.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;
+  }
+
+  public override toJSON(): LocalLengthBlockJson {
+    return {
+      ...super.toJSON(),
+      isIndefiniteForm: this.isIndefiniteForm,
+      longFormUsed: this.longFormUsed,
+      length: this.length,
+    };
+  }
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalObjectIdentifierValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalObjectIdentifierValueBlock.ts
new file mode 100644
index 0000000000..a24b9e947a
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalObjectIdentifierValueBlock.ts
@@ -0,0 +1,192 @@
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { EMPTY_BUFFER, EMPTY_STRING } from "./constants";
+import * as utils from "./utils";
+import { LocalSidValueBlockJson, LocalSidValueBlock } from "./LocalSidValueBlock";
+import { IStringConvertible } from "../types";
+
+
+export interface ILocalObjectIdentifierValueBlock {
+  value: string;
+}
+
+export interface LocalObjectIdentifierValueBlockParams extends ValueBlockParams, Partial<ILocalObjectIdentifierValueBlock> { }
+
+export interface LocalObjectIdentifierValueBlockJson extends ValueBlockJson, ILocalObjectIdentifierValueBlock {
+  sidArray: LocalSidValueBlockJson[];
+}
+
+export class LocalObjectIdentifierValueBlock extends ValueBlock implements IStringConvertible {
+
+  public static override NAME = "ObjectIdentifierValueBlock";
+
+  public value: LocalSidValueBlock[] = [];
+
+  constructor({
+    value = EMPTY_STRING,
+    ...parameters
+  }: LocalObjectIdentifierValueBlockParams = {}) {
+    super(parameters);
+
+    if (value) {
+      this.fromString(value);
+    }
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    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;
+  }
+  public override toBER(sizeOnly?: boolean): ArrayBuffer {
+    const retBuffers: ArrayBuffer[] = [];
+
+    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 utils.concat(retBuffers);
+  }
+
+  public fromString(string: string): void {
+    this.value = []; // Clear existing SID values
+
+    let pos1 = 0;
+    let pos2 = 0;
+
+    let sid = "";
+
+    let flag = false;
+
+    // const sids = string.split(".");
+    // for (const sid of sids) {
+
+    // }
+    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 = []; // clear SID array
+
+            return;
+        }
+
+        const parsedSID = parseInt(sid, 10);
+        if (isNaN(parsedSID))
+          return;
+
+        sidBlock.valueDec = parsedSID + plus;
+
+        flag = false;
+      } else {
+        const sidBlock = new LocalSidValueBlock();
+        if ((sid as any) > Number.MAX_SAFE_INTEGER) { // TODO remove as any
+          utils.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);
+  }
+
+  public override toString(): string {
+    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;
+  }
+
+  public override toJSON(): LocalObjectIdentifierValueBlockJson {
+    const object: LocalObjectIdentifierValueBlockJson = {
+      ...super.toJSON(),
+      value: this.toString(),
+      sidArray: [],
+    };
+
+    for (let i = 0; i < this.value.length; i++) {
+      object.sidArray.push(this.value[i].toJSON());
+    }
+
+    return object;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalOctetStringValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalOctetStringValueBlock.ts
new file mode 100644
index 0000000000..fb2dfd562b
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalOctetStringValueBlock.ts
@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { ViewWriter } from "../ViewWriter";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { END_OF_CONTENT_NAME, OCTET_STRING_NAME } from "./constants";
+import { LocalConstructedValueBlockParams, LocalConstructedValueBlockJson, LocalConstructedValueBlock } from "./LocalConstructedValueBlock";
+import type { OctetString } from "../OctetString";
+
+export interface ILocalOctetStringValueBlock {
+  isConstructed: boolean;
+}
+
+export interface LocalOctetStringValueBlockParams extends HexBlockParams, LocalConstructedValueBlockParams, Partial<ILocalOctetStringValueBlock> {
+  value?: OctetString[];
+}
+
+export interface LocalOctetStringValueBlockJson extends HexBlockJson, LocalConstructedValueBlockJson, ILocalOctetStringValueBlock { }
+
+export class LocalOctetStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
+
+  public static override NAME = "OctetStringValueBlock";
+
+  public isConstructed: boolean;
+
+  constructor({
+    isConstructed = false,
+    ...parameters
+  }: LocalOctetStringValueBlockParams = {}) {
+    super(parameters);
+
+    this.isConstructed = isConstructed;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer, inputOffset: number, inputLength: number): number {
+    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 as typeof LocalOctetStringValueBlock).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;
+  }
+
+  public override toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    if (this.isConstructed)
+      return LocalConstructedValueBlock.prototype.toBER.call(this, sizeOnly, writer);
+
+    return sizeOnly
+      ? new ArrayBuffer(this.valueHexView.byteLength)
+      : this.valueHexView.slice().buffer;
+  }
+
+  public override toJSON(): LocalOctetStringValueBlockJson {
+    return {
+      ...super.toJSON(),
+      isConstructed: this.isConstructed,
+    } as LocalOctetStringValueBlockJson;
+  }
+
+}
+
+export interface LocalOctetStringValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalPrimitiveValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalPrimitiveValueBlock.ts
new file mode 100644
index 0000000000..7fe2408b96
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalPrimitiveValueBlock.ts
@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { HexBlock, HexBlockJson, HexBlockParams } from "../HexBlock";
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+
+export interface LocalPrimitiveValueBlockParams extends HexBlockParams, ValueBlockParams { }
+export interface LocalPrimitiveValueBlockJson extends HexBlockJson, ValueBlockJson { }
+
+export class LocalPrimitiveValueBlock extends HexBlock(ValueBlock) {
+
+  public static override NAME = "PrimitiveValueBlock";
+
+  constructor({
+    isHexOnly = true,
+    ...parameters
+  }: LocalPrimitiveValueBlockParams = {}) {
+    super(parameters);
+
+    this.isHexOnly = isHexOnly;
+  }
+
+}
+
+export interface LocalPrimitiveValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalRelativeObjectIdentifierValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalRelativeObjectIdentifierValueBlock.ts
new file mode 100644
index 0000000000..13237f50ec
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalRelativeObjectIdentifierValueBlock.ts
@@ -0,0 +1,140 @@
+import { ViewWriter } from "../ViewWriter";
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { EMPTY_BUFFER, EMPTY_STRING } from "./constants";
+import * as utils from "./utils";
+import { LocalRelativeSidValueBlockJson, LocalRelativeSidValueBlock } from "./LocalRelativeSidValueBlock";
+import { IStringConvertible } from "../types";
+
+export interface ILocalRelativeObjectIdentifierValueBlock {
+  value: string;
+}
+
+export interface LocalRelativeObjectIdentifierValueBlockParams extends ValueBlockParams, Partial<ILocalRelativeObjectIdentifierValueBlock> { }
+
+export interface LocalRelativeObjectIdentifierValueBlockJson extends ValueBlockJson, ILocalRelativeObjectIdentifierValueBlock {
+  sidArray: LocalRelativeSidValueBlockJson[];
+}
+
+export class LocalRelativeObjectIdentifierValueBlock extends ValueBlock implements IStringConvertible {
+
+  public static override NAME = "RelativeObjectIdentifierValueBlock";
+
+  public value: LocalRelativeSidValueBlock[] = [];
+
+  constructor({
+    value = EMPTY_STRING,
+    ...parameters
+  }: LocalRelativeObjectIdentifierValueBlockParams = {}) {
+    super(parameters);
+
+    if (value) {
+      this.fromString(value);
+    }
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    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;
+  }
+
+  public override toBER(sizeOnly?: boolean, writer?: ViewWriter): ArrayBuffer {
+    const retBuffers: ArrayBuffer[] = [];
+
+    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 utils.concat(retBuffers);
+  }
+
+  public fromString(string: string): boolean {
+    this.value = []; // Clear existing SID values
+
+    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;
+  }
+
+  public override toString(): string {
+    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;
+  }
+
+  public override toJSON(): LocalRelativeObjectIdentifierValueBlockJson {
+    const object: LocalRelativeObjectIdentifierValueBlockJson = {
+      ...super.toJSON(),
+      value: this.toString(),
+      sidArray: [],
+    };
+
+    for (let i = 0; i < this.value.length; i++)
+      object.sidArray.push(this.value[i].toJSON());
+
+    return object;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalRelativeSidValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalRelativeSidValueBlock.ts
new file mode 100644
index 0000000000..3a10c617aa
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalRelativeSidValueBlock.ts
@@ -0,0 +1,140 @@
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { LocalBaseBlock } from "./LocalBaseBlock";
+import { EMPTY_BUFFER } from "./constants";
+import { checkBufferParams } from "./utils";
+
+export interface ILocalRelativeSidValueBlock {
+  valueDec: number;
+}
+
+export interface LocalRelativeSidValueBlockParams extends HexBlockParams, ValueBlockParams, Partial<ILocalRelativeSidValueBlock> { }
+
+export interface LocalRelativeSidValueBlockJson extends HexBlockJson, ValueBlockJson, ILocalRelativeSidValueBlock { }
+
+export class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) implements ILocalRelativeSidValueBlock {
+
+  public static override NAME = "relativeSidBlock";
+
+  public valueDec: number;
+
+  constructor({
+    valueDec = 0,
+    ...parameters
+  }: LocalRelativeSidValueBlockParams = {}) {
+    super(parameters);
+
+    this.valueDec = valueDec;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    if (inputLength === 0)
+      return inputOffset;
+
+    const inputView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+
+    // Basic check for parameters
+    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;
+    }
+
+    //#region Adjust size of valueHex buffer
+    const tempView = new Uint8Array(this.blockLength);
+
+    for (let i = 0; i < this.blockLength; i++)
+      tempView[i] = this.valueHexView[i];
+
+    this.valueHexView = tempView;
+    //#endregion
+    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 = pvutils.utilFromBase(this.valueHexView, 7);
+    else {
+      this.isHexOnly = true;
+      this.warnings.push("Too big SID for decoding, hex only");
+    }
+
+    return (inputOffset + this.blockLength);
+  }
+
+  public override toBER(sizeOnly?: boolean): ArrayBuffer {
+    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 = pvutils.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;
+  }
+
+  public override toString(): string {
+    let result = "";
+
+    if (this.isHexOnly)
+      result = pvtsutils.Convert.ToHex(this.valueHexView);
+    else {
+      result = this.valueDec.toString();
+    }
+
+    return result;
+  }
+
+  public override toJSON(): LocalRelativeSidValueBlockJson {
+    return {
+      ...super.toJSON(),
+      valueDec: this.valueDec,
+    };
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalSidValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalSidValueBlock.ts
new file mode 100644
index 0000000000..a9a45ba359
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalSidValueBlock.ts
@@ -0,0 +1,197 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import * as pvtsutils from "pvtsutils";
+import * as pvutils from "pvutils";
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { EMPTY_BUFFER } from "./constants";
+import * as utils from "./utils";
+
+export interface ILocalSidValueBlock {
+  valueDec: number;
+  isFirstSid: boolean;
+}
+
+export interface LocalSidValueBlockParams extends HexBlockParams, ValueBlockParams, Partial<ILocalSidValueBlock> { }
+
+export interface LocalSidValueBlockJson extends HexBlockJson, ValueBlockJson, ILocalSidValueBlock { }
+
+export class LocalSidValueBlock extends HexBlock(ValueBlock) implements ILocalSidValueBlock {
+
+  public static override NAME = "sidBlock";
+
+  public valueDec: number;
+  public isFirstSid: boolean;
+
+  constructor({
+    valueDec = -1,
+    isFirstSid = false,
+    ...parameters
+  }: LocalSidValueBlockParams = {}) {
+    super(parameters);
+
+    this.valueDec = valueDec;
+    this.isFirstSid = isFirstSid;
+  }
+
+  public override fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number {
+    if (!inputLength) {
+      return inputOffset;
+    }
+    const inputView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+
+    // Basic check for parameters
+    if (!utils.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;
+    }
+
+    //#region Adjust size of valueHex buffer
+    const tempView = new Uint8Array(this.blockLength);
+
+    for (let i = 0; i < this.blockLength; i++) {
+      tempView[i] = this.valueHexView[i];
+    }
+
+    this.valueHexView = tempView;
+    //#endregion
+
+    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 = pvutils.utilFromBase(this.valueHexView, 7);
+    else {
+      this.isHexOnly = true;
+      this.warnings.push("Too big SID for decoding, hex only");
+    }
+
+    return (inputOffset + this.blockLength);
+  }
+
+  public set valueBigInt(value: bigint) {
+
+    utils.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);
+  }
+
+  public override toBER(sizeOnly?: boolean): ArrayBuffer {
+    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 = pvutils.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;
+  }
+
+  public override toString(): string {
+    let result = "";
+
+    if (this.isHexOnly)
+      result = pvtsutils.Convert.ToHex(this.valueHexView);
+    else {
+      if (this.isFirstSid) {
+        let sidValue = this.valueDec;
+
+        if (this.valueDec <= 39)
+          result = "0.";
+        else {
+          if (this.valueDec <= 79) {
+            result = "1.";
+            sidValue -= 40;
+          }
+          else {
+            result = "2.";
+            sidValue -= 80;
+          }
+        }
+
+        result += sidValue.toString();
+      }
+
+      else
+        result = this.valueDec.toString();
+    }
+
+    return result;
+  }
+
+  public override toJSON(): LocalSidValueBlockJson {
+    return {
+      ...super.toJSON(),
+      valueDec: this.valueDec,
+      isFirstSid: this.isFirstSid,
+    };
+  }
+
+}
+
+export interface LocalSidValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalSimpleStringBlock.ts b/comm/third_party/asn1js/src/internals/LocalSimpleStringBlock.ts
new file mode 100644
index 0000000000..a52c9e2898
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalSimpleStringBlock.ts
@@ -0,0 +1,34 @@
+import * as pvtsutils from "pvtsutils";
+import { BaseBlockParams } from "../BaseBlock";
+import { BaseStringBlock } from "../BaseStringBlock";
+import { LocalSimpleStringValueBlock, LocalSimpleStringValueBlockJson, LocalSimpleStringValueBlockParams } from "./LocalSimpleStringValueBlock";
+
+export interface LocalSimpleStringBlockParams extends BaseBlockParams, LocalSimpleStringValueBlockParams { }
+export type LocalSimpleStringBlockJson = LocalSimpleStringValueBlockJson;
+
+export class LocalSimpleStringBlock extends BaseStringBlock<LocalSimpleStringValueBlock, LocalSimpleStringValueBlockJson> {
+
+  public static override NAME = "SIMPLE STRING";
+
+  constructor({
+    ...parameters
+  }: LocalSimpleStringBlockParams = {}) {
+    super(parameters, LocalSimpleStringValueBlock);
+  }
+
+  public override fromBuffer(inputBuffer: ArrayBuffer | Uint8Array): void {
+    this.valueBlock.value = String.fromCharCode.apply(null, pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer) as unknown as number[]);
+  }
+
+  public fromString(inputString: string): void {
+    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;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalSimpleStringValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalSimpleStringValueBlock.ts
new file mode 100644
index 0000000000..f2ee09a8a3
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalSimpleStringValueBlock.ts
@@ -0,0 +1,11 @@
+import { ILocalStringValueBlock, LocalStringValueBlockParams, LocalStringValueBlockJson, LocalStringValueBlock } from "./LocalStringValueBlock";
+
+export type ILocalSimpleStringValueBlock = ILocalStringValueBlock;
+export type LocalSimpleStringValueBlockParams = LocalStringValueBlockParams;
+export type LocalSimpleStringValueBlockJson = LocalStringValueBlockJson;
+
+export class LocalSimpleStringValueBlock extends LocalStringValueBlock {
+
+  public static override NAME = "SimpleStringValueBlock";
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalStringValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalStringValueBlock.ts
new file mode 100644
index 0000000000..dfd0ee19e3
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalStringValueBlock.ts
@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { HexBlockJson, HexBlockParams, HexBlock } from "../HexBlock";
+import { ValueBlock, ValueBlockJson, ValueBlockParams } from "../ValueBlock";
+import { EMPTY_STRING } from "./constants";
+import { LocalUtf8StringValueBlockParams, LocalUtf8StringValueBlockJson } from "./LocalUtf8StringValueBlock";
+
+export interface ILocalStringValueBlock {
+  value: string;
+}
+
+export interface LocalStringValueBlockParams extends Omit<HexBlockParams, "isHexOnly">, ValueBlockParams, Partial<ILocalStringValueBlock> { }
+
+export interface LocalStringValueBlockJson extends HexBlockJson, ValueBlockJson, ILocalStringValueBlock { }
+
+export abstract class LocalStringValueBlock extends HexBlock(ValueBlock) implements ILocalStringValueBlock {
+
+  public static override NAME = "StringValueBlock";
+
+  public value: string;
+
+  constructor({
+    ...parameters
+  }: LocalUtf8StringValueBlockParams = {}) {
+    super(parameters);
+
+    this.isHexOnly = true;
+    this.value = EMPTY_STRING; // String representation of decoded ArrayBuffer
+  }
+
+  public override toJSON(): LocalUtf8StringValueBlockJson {
+    return {
+      ...super.toJSON(),
+      value: this.value,
+    };
+  }
+
+}
+
+export interface LocalStringValueBlock {
+  /**
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueBeforeDecode: ArrayBuffer;
+  /**
+   * Binary data in ArrayBuffer representation
+   *
+   * @deprecated since version 3.0.0
+   */
+  // @ts-ignore
+  valueHex: ArrayBuffer;
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalUniversalStringValueBlockParams.ts b/comm/third_party/asn1js/src/internals/LocalUniversalStringValueBlockParams.ts
new file mode 100644
index 0000000000..6b3b09359a
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalUniversalStringValueBlockParams.ts
@@ -0,0 +1,45 @@
+import * as pvutils from "pvutils";
+import { LocalSimpleStringBlock, LocalSimpleStringBlockJson, LocalSimpleStringBlockParams } from "./LocalSimpleStringBlock";
+
+export type LocalUniversalStringValueBlockParams = LocalSimpleStringBlockParams;
+export type LocalUniversalStringValueBlockJson = LocalSimpleStringBlockJson;
+
+export class LocalUniversalStringValueBlock extends LocalSimpleStringBlock {
+
+  public static override NAME = "UniversalStringValueBlock";
+
+  public override fromBuffer(inputBuffer: ArrayBuffer | Uint8Array): void {
+    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) as unknown as number[]);
+  }
+
+  public override fromString(inputString: string): void {
+    const strLength = inputString.length;
+
+    const valueHexView = this.valueBlock.valueHexView = new Uint8Array(strLength * 4);
+
+    for (let i = 0; i < strLength; i++) {
+      const codeBuf = pvutils.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;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/LocalUtf8StringValueBlock.ts b/comm/third_party/asn1js/src/internals/LocalUtf8StringValueBlock.ts
new file mode 100644
index 0000000000..7d578d8950
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/LocalUtf8StringValueBlock.ts
@@ -0,0 +1,27 @@
+import * as pvtsutils from "pvtsutils";
+import { LocalSimpleStringBlock, LocalSimpleStringBlockJson, LocalSimpleStringBlockParams } from "./LocalSimpleStringBlock";
+
+export type LocalUtf8StringValueBlockParams = LocalSimpleStringBlockParams;
+export type LocalUtf8StringValueBlockJson = LocalSimpleStringBlockJson;
+
+export class LocalUtf8StringValueBlock extends LocalSimpleStringBlock {
+
+  public static override NAME = "Utf8StringValueBlock";
+
+  public override fromBuffer(inputBuffer: ArrayBuffer | Uint8Array): void {
+    this.valueBlock.valueHexView = pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer);
+    try {
+      this.valueBlock.value = pvtsutils.Convert.ToUtf8String(inputBuffer);
+    }
+    catch (ex) {
+      this.warnings.push(`Error during "decodeURIComponent": ${ex}, using raw string`);
+      this.valueBlock.value = pvtsutils.Convert.ToBinary(inputBuffer);
+    }
+  }
+
+  public override fromString(inputString: string): void {
+    this.valueBlock.valueHexView = new Uint8Array(pvtsutils.Convert.FromUtf8String(inputString));
+    this.valueBlock.value = inputString;
+  }
+
+}
diff --git a/comm/third_party/asn1js/src/internals/constants.ts b/comm/third_party/asn1js/src/internals/constants.ts
new file mode 100644
index 0000000000..beb0bd9eb8
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/constants.ts
@@ -0,0 +1,20 @@
+// Declaration of global variables
+
+export const powers2 = [new Uint8Array([1])];
+export const digitsString = "0123456789";
+export const NAME = "name";
+export const VALUE_HEX_VIEW = "valueHexView";
+export const IS_HEX_ONLY = "isHexOnly";
+export const ID_BLOCK = "idBlock";
+export const TAG_CLASS = "tagClass";
+export const TAG_NUMBER = "tagNumber";
+export const IS_CONSTRUCTED = "isConstructed";
+export const FROM_BER = "fromBER";
+export const TO_BER = "toBER";
+export const LOCAL = "local";
+export const EMPTY_STRING = "";
+export const EMPTY_BUFFER = new ArrayBuffer(0);
+export const EMPTY_VIEW = new Uint8Array(0);
+export const END_OF_CONTENT_NAME = "EndOfContent";
+export const OCTET_STRING_NAME = "OCTET STRING";
+export const BIT_STRING_NAME = "BIT STRING";
diff --git a/comm/third_party/asn1js/src/internals/utils.ts b/comm/third_party/asn1js/src/internals/utils.ts
new file mode 100644
index 0000000000..84d1f3164f
--- /dev/null
+++ b/comm/third_party/asn1js/src/internals/utils.ts
@@ -0,0 +1,81 @@
+// Utility functions
+
+import type { LocalBaseBlock } from "./LocalBaseBlock";
+
+/**
+ * Throws an exception if BigInt is not supported
+ * @throws Throws Error if BigInt is not supported
+ */
+export function assertBigInt(): void {
+  if (typeof BigInt === "undefined") {
+    throw new Error("BigInt is not defined. Your environment doesn't implement BigInt.");
+  }
+}
+
+/**
+ * Concatenates buffers from the list
+ * @param buffers List of buffers
+ * @returns Concatenated buffer
+ */
+export function concat(buffers: ArrayBuffer[]): ArrayBuffer {
+  let outputLength = 0;
+  let prevLength = 0;
+
+  // Calculate output length
+  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;
+}
+
+/**
+ * Check input "Uint8Array" for common functions
+ * @param baseBlock
+ * @param inputBuffer
+ * @param inputOffset
+ * @param inputLength
+ * @returns
+ */
+export function checkBufferParams(baseBlock: LocalBaseBlock, inputBuffer: Uint8Array, inputOffset: number, inputLength: number): boolean {
+  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;
+}
\ No newline at end of file
diff --git a/comm/third_party/asn1js/src/parser.ts b/comm/third_party/asn1js/src/parser.ts
new file mode 100644
index 0000000000..51ab7dfcd8
--- /dev/null
+++ b/comm/third_party/asn1js/src/parser.ts
@@ -0,0 +1,301 @@
+import * as pvtsutils from "pvtsutils";
+import { ValueBlock } from "./ValueBlock";
+import { BaseBlock } from "./BaseBlock";
+import { LocalBaseBlock } from "./internals/LocalBaseBlock";
+import { AsnType, typeStore } from "./TypeStore";
+import { checkBufferParams } from "./internals/utils";
+
+export interface FromBerResult {
+  offset: number;
+  result: AsnType;
+}
+
+/**
+ * Local function changing a type for ASN.1 classes
+ * @param inputObject Incoming object
+ * @param newType Target type to convert
+ * @returns Converted object
+ */
+function localChangeType<T extends BaseBlock>(inputObject: BaseBlock, newType: new () => T): T {
+  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;
+}
+
+/**
+ * Internal library function for decoding ASN.1 BER
+ * @param inputBuffer ASN.1 BER encoded array
+ * @param inputOffset Offset in ASN.1 BER encoded array where decoding should be started
+ * @param inputLength Maximum length of array of bytes which can be using in this function
+ * @returns
+ */
+export function localFromBER(inputBuffer: Uint8Array, inputOffset = 0, inputLength = inputBuffer.length): FromBerResult {
+  const incomingOffset = inputOffset; // Need to store initial offset since "inputOffset" is changing in the function
+
+  // Create a basic ASN.1 type since we need to return errors and warnings from the function
+  let returnObject = new BaseBlock({}, ValueBlock);
+
+  // Basic check for parameters
+  const baseBlock = new LocalBaseBlock();
+  if (!checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength)) {
+    returnObject.error = baseBlock.error;
+
+    return {
+      offset: -1,
+      result: returnObject
+    };
+  }
+
+  // Getting Uint8Array subarray
+  const intBuffer = inputBuffer.subarray(inputOffset, inputOffset + inputLength);
+
+  // Initial checks
+  if (!intBuffer.length) {
+    returnObject.error = "Zero buffer length";
+
+    return {
+      offset: -1,
+      result: returnObject
+    };
+  }
+
+  // Decode identification block of ASN.1 BER structure
+  // console.time("idBlock");
+  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
+    };
+  }
+  // console.timeEnd("idBlock");
+
+  inputOffset = resultOffset;
+  inputLength -= returnObject.idBlock.blockLength;
+
+  // Decode length block of ASN.1 BER structure
+  // console.time("lengthBlock");
+  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
+    };
+  }
+  // console.timeEnd("lengthBlock");
+
+  inputOffset = resultOffset;
+  inputLength -= returnObject.lenBlock.blockLength;
+
+  // Check for using indefinite length form in encoding for primitive types
+  if (!returnObject.idBlock.isConstructed &&
+    returnObject.lenBlock.isIndefiniteForm) {
+    returnObject.error = "Indefinite length form used for primitive encoding form";
+
+    return {
+      offset: -1,
+      result: returnObject
+    };
+  }
+
+  // Switch ASN.1 block type
+  let newASN1Type: new () => AsnType = BaseBlock as any;
+
+  switch (returnObject.idBlock.tagClass) {
+    // UNIVERSAL
+    case 1:
+      // Check for reserved tag numbers
+      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: // EndOfContent
+          // Check for EndOfContent type
+          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: // Boolean
+          newASN1Type = typeStore.Boolean;
+          break;
+        case 2: // Integer
+          newASN1Type = typeStore.Integer;
+          break;
+        case 3: // BitString
+          newASN1Type = typeStore.BitString;
+          break;
+        case 4: // OctetString
+          newASN1Type = typeStore.OctetString;
+          break;
+        case 5: // Null
+          newASN1Type = typeStore.Null;
+          break;
+        case 6: // ObjectIdentifier
+          newASN1Type = typeStore.ObjectIdentifier;
+          break;
+        case 10: // Enumerated
+          newASN1Type = typeStore.Enumerated;
+          break;
+        case 12: // Utf8String
+          newASN1Type = typeStore.Utf8String;
+          break;
+        case 13: // RelativeObjectIdentifier
+          newASN1Type = typeStore.RelativeObjectIdentifier;
+          break;
+        case 14: // TIME
+          newASN1Type = typeStore.TIME;
+          break;
+        case 15:
+          returnObject.error = "[UNIVERSAL 15] is reserved by ASN.1 standard";
+
+          return {
+            offset: -1,
+            result: returnObject
+          };
+        case 16: // Sequence
+          newASN1Type = typeStore.Sequence;
+          break;
+        case 17: // Set
+          newASN1Type = typeStore.Set;
+          break;
+        case 18: // NumericString
+          newASN1Type = typeStore.NumericString;
+          break;
+        case 19: // PrintableString
+          newASN1Type = typeStore.PrintableString;
+          break;
+        case 20: // TeletexString
+          newASN1Type = typeStore.TeletexString;
+          break;
+        case 21: // VideotexString
+          newASN1Type = typeStore.VideotexString;
+          break;
+        case 22: // IA5String
+          newASN1Type = typeStore.IA5String;
+          break;
+        case 23: // UTCTime
+          newASN1Type = typeStore.UTCTime;
+          break;
+        case 24: // GeneralizedTime
+          newASN1Type = typeStore.GeneralizedTime;
+          break;
+        case 25: // GraphicString
+          newASN1Type = typeStore.GraphicString;
+          break;
+        case 26: // VisibleString
+          newASN1Type = typeStore.VisibleString;
+          break;
+        case 27: // GeneralString
+          newASN1Type = typeStore.GeneralString;
+          break;
+        case 28: // UniversalString
+          newASN1Type = typeStore.UniversalString;
+          break;
+        case 29: // CharacterString
+          newASN1Type = typeStore.CharacterString;
+          break;
+        case 30: // BmpString
+          newASN1Type = typeStore.BmpString;
+          break;
+        case 31: // DATE
+          newASN1Type = typeStore.DATE;
+          break;
+        case 32: // TimeOfDay
+          newASN1Type = typeStore.TimeOfDay;
+          break;
+        case 33: // DateTime
+          newASN1Type = typeStore.DateTime;
+          break;
+        case 34: // Duration
+          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;
+    // All other tag classes
+    case 2: // APPLICATION
+    case 3: // CONTEXT-SPECIFIC
+    case 4: // PRIVATE
+    default: {
+      newASN1Type = returnObject.idBlock.isConstructed
+        ? typeStore.Constructed
+        : typeStore.Primitive;
+    }
+  }
+
+
+  // Change type and perform BER decoding
+  returnObject = localChangeType(returnObject, newASN1Type);
+  // console.time("valueBlock");
+  resultOffset = returnObject.fromBER(inputBuffer, inputOffset, returnObject.lenBlock.isIndefiniteForm ? inputLength : returnObject.lenBlock.length);
+
+  // Coping incoming buffer for entire ASN.1 block
+  returnObject.valueBeforeDecodeView = inputBuffer.subarray(incomingOffset, incomingOffset + returnObject.blockLength);
+  // console.timeEnd("valueBlock");
+
+  return {
+    offset: resultOffset,
+    result: returnObject
+  };
+}
+
+/**
+ * Major function for decoding ASN.1 BER array into internal library structures
+ * @param inputBuffer ASN.1 BER encoded array of bytes
+ */
+export function fromBER(inputBuffer: pvtsutils.BufferSource): FromBerResult {
+  if (!inputBuffer.byteLength) {
+    const result = new BaseBlock({}, ValueBlock);
+    result.error = "Input buffer has zero length";
+
+    return {
+      offset: -1,
+      result
+    };
+  }
+
+  return localFromBER(pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength);
+}
diff --git a/comm/third_party/asn1js/src/schema.ts b/comm/third_party/asn1js/src/schema.ts
new file mode 100644
index 0000000000..4f07e92a13
--- /dev/null
+++ b/comm/third_party/asn1js/src/schema.ts
@@ -0,0 +1,475 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import * as pvtsutils from "pvtsutils";
+import { IS_CONSTRUCTED, EMPTY_STRING, NAME, ID_BLOCK, FROM_BER, TO_BER, TAG_CLASS, TAG_NUMBER, IS_HEX_ONLY, LOCAL, VALUE_HEX_VIEW } from "./internals/constants";
+import { Any } from "./Any";
+import { Choice } from "./Choice";
+import { Repeated } from "./Repeated";
+import { localFromBER } from "./parser";
+import { AsnType, typeStore } from "./TypeStore";
+
+export type AsnSchemaType = AsnType | Any | Choice | Repeated;
+
+export interface CompareSchemaSuccess {
+  verified: true;
+  result: AsnType & { [key: string]: any; };
+}
+
+export interface CompareSchemaFail {
+  verified: false;
+  name?: string;
+  result: AsnType | { error: string; };
+}
+
+export type CompareSchemaResult = CompareSchemaSuccess | CompareSchemaFail;
+
+/**
+ * Compare of two ASN.1 object trees
+ * @param root Root of input ASN.1 object tree
+ * @param inputData Input ASN.1 object tree
+ * @param inputSchema Input ASN.1 schema to compare with
+ * @return Returns result of comparison
+ */
+export function compareSchema(root: AsnType, inputData: AsnType, inputSchema: AsnSchemaType): CompareSchemaResult {
+  //#region Special case for Choice schema element type
+  if (inputSchema instanceof Choice) {
+    const choiceResult = false;
+
+    for (let j = 0; j < inputSchema.value.length; j++) {
+      const result = compareSchema(root, inputData, inputSchema.value[j]);
+      if (result.verified) {
+        return {
+          verified: true,
+          result: root
+        };
+      }
+    }
+
+    if (choiceResult === false) {
+      const _result: CompareSchemaResult = {
+        verified: false,
+        result: {
+          error: "Wrong values for Choice type"
+        },
+      };
+
+      if (inputSchema.hasOwnProperty(NAME))
+        _result.name = inputSchema.name;
+
+      return _result;
+    }
+  }
+  //#endregion
+  //#region Special case for Any schema element type
+  if (inputSchema instanceof Any) {
+    //#region Add named component of ASN.1 schema
+    if (inputSchema.hasOwnProperty(NAME))
+      (root as any)[inputSchema.name] = inputData; // TODO Such call may replace original field of the object (eg idBlock)
+
+
+    //#endregion
+    return {
+      verified: true,
+      result: root
+    };
+  }
+  //#endregion
+  //#region Initial check
+  if ((root instanceof Object) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong root object" }
+    };
+  }
+
+  if ((inputData instanceof Object) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 data" }
+    };
+  }
+
+  if ((inputSchema instanceof Object) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  if ((ID_BLOCK in inputSchema) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+  //#endregion
+  //#region Comparing idBlock properties in ASN.1 data and ASN.1 schema
+  //#region Encode and decode ASN.1 schema idBlock
+  /// <remarks>This encoding/decoding is necessary because could be an errors in schema definition</remarks>
+  if ((FROM_BER in inputSchema.idBlock) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  if ((TO_BER in inputSchema.idBlock) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  const encodedId = inputSchema.idBlock.toBER(false);
+  if (encodedId.byteLength === 0) {
+    return {
+      verified: false,
+      result: { error: "Error encoding idBlock for ASN.1 schema" }
+    };
+  }
+
+  const decodedOffset = inputSchema.idBlock.fromBER(encodedId, 0, encodedId.byteLength);
+  if (decodedOffset === -1) {
+    return {
+      verified: false,
+      result: { error: "Error decoding idBlock for ASN.1 schema" }
+    };
+  }
+  //#endregion
+  //#region tagClass
+  if (inputSchema.idBlock.hasOwnProperty(TAG_CLASS) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  if (inputSchema.idBlock.tagClass !== inputData.idBlock.tagClass) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  //#endregion
+  //#region tagNumber
+  if (inputSchema.idBlock.hasOwnProperty(TAG_NUMBER) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  if (inputSchema.idBlock.tagNumber !== inputData.idBlock.tagNumber) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  //#endregion
+  //#region isConstructed
+  if (inputSchema.idBlock.hasOwnProperty(IS_CONSTRUCTED) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  if (inputSchema.idBlock.isConstructed !== inputData.idBlock.isConstructed) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  //#endregion
+  //#region isHexOnly
+  if (!(IS_HEX_ONLY in inputSchema.idBlock)) // Since 'isHexOnly' is an inherited property
+  {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema" }
+    };
+  }
+
+  if (inputSchema.idBlock.isHexOnly !== inputData.idBlock.isHexOnly) {
+    return {
+      verified: false,
+      result: root
+    };
+  }
+  //#endregion
+  //#region valueHex
+  if (inputSchema.idBlock.isHexOnly) {
+    if ((VALUE_HEX_VIEW in inputSchema.idBlock) === false) // Since 'valueHex' is an inherited property
+    {
+      return {
+        verified: false,
+        result: { error: "Wrong ASN.1 schema" }
+      };
+    }
+
+    const schemaView = inputSchema.idBlock.valueHexView;
+    const asn1View = inputData.idBlock.valueHexView;
+
+    if (schemaView.length !== asn1View.length) {
+      return {
+        verified: false,
+        result: root
+      };
+    }
+
+    for (let i = 0; i < schemaView.length; i++) {
+      if (schemaView[i] !== asn1View[1]) {
+        return {
+          verified: false,
+          result: root
+        };
+      }
+    }
+  }
+  //#endregion
+  //#endregion
+  //#region Add named component of ASN.1 schema
+  if (inputSchema.name) {
+    inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+    if (inputSchema.name)
+      (root as any)[inputSchema.name] = inputData; // TODO check field existence. If exists throw an error
+  }
+  //#endregion
+  //#region Getting next ASN.1 block for comparison
+  if (inputSchema instanceof typeStore.Constructed) {
+    // TODO not clear how it works for OctetString and BitString
+    //* if (inputSchema.idBlock.isConstructed) {
+    let admission = 0;
+    let result: CompareSchemaResult = {
+      verified: false,
+      result: {
+        error: "Unknown error",
+      }
+    };
+
+    let maxLength = inputSchema.valueBlock.value.length;
+
+    if (maxLength > 0) {
+      if (inputSchema.valueBlock.value[0] instanceof Repeated) {
+        // @ts-ignore
+        maxLength = inputData.valueBlock.value.length; // TODO debug it
+      }
+    }
+
+    //#region Special case when constructive value has no elements
+    if (maxLength === 0) {
+      return {
+        verified: true,
+        result: root
+      };
+    }
+    //#endregion
+    //#region Special case when "inputData" has no values and "inputSchema" has all optional values
+    // @ts-ignore
+    // TODO debug it
+    if ((inputData.valueBlock.value.length === 0) &&
+      (inputSchema.valueBlock.value.length !== 0)) {
+      let _optional = true;
+
+      for (let i = 0; i < inputSchema.valueBlock.value.length; i++)
+        _optional = _optional && (inputSchema.valueBlock.value[i].optional || false);
+
+      if (_optional) {
+        return {
+          verified: true,
+          result: root
+        };
+      }
+
+      //#region Delete early added name of block
+      if (inputSchema.name) {
+        inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+        if (inputSchema.name)
+          delete (root as any)[inputSchema.name];
+      }
+      //#endregion
+      root.error = "Inconsistent object length";
+
+      return {
+        verified: false,
+        result: root
+      };
+    }
+    //#endregion
+    for (let i = 0; i < maxLength; i++) {
+      //#region Special case when there is an OPTIONAL element of ASN.1 schema at the end
+      // @ts-ignore
+      if ((i - admission) >= inputData.valueBlock.value.length) {
+        if (inputSchema.valueBlock.value[i].optional === false) {
+          const _result: CompareSchemaResult = {
+            verified: false,
+            result: root
+          };
+
+          root.error = "Inconsistent length between ASN.1 data and schema";
+
+          //#region Delete early added name of block
+          if (inputSchema.name) {
+            inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+            if (inputSchema.name) {
+              delete (root as any)[inputSchema.name];
+              _result.name = inputSchema.name;
+            }
+          }
+          //#endregion
+
+          return _result;
+        }
+      }
+
+      //#endregion
+      else {
+        //#region Special case for Repeated type of ASN.1 schema element
+        if (inputSchema.valueBlock.value[0] instanceof Repeated) {
+          // @ts-ignore
+          result = compareSchema(root, inputData.valueBlock.value[i], inputSchema.valueBlock.value[0].value);
+          if (result.verified === false) {
+            if (inputSchema.valueBlock.value[0].optional)
+              admission++;
+            else {
+              //#region Delete early added name of block
+              if (inputSchema.name) {
+                inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+                if (inputSchema.name)
+                  delete (root as any)[inputSchema.name];
+              }
+              //#endregion
+
+              return result;
+            }
+          }
+
+          if ((NAME in inputSchema.valueBlock.value[0]) && (inputSchema.valueBlock.value[0].name.length > 0)) {
+            let arrayRoot: Record<string, any> = {};
+
+            if ((LOCAL in inputSchema.valueBlock.value[0]) && (inputSchema.valueBlock.value[0].local))
+              arrayRoot = inputData;
+
+            else
+              arrayRoot = root;
+
+            if (typeof arrayRoot[inputSchema.valueBlock.value[0].name] === "undefined")
+              arrayRoot[inputSchema.valueBlock.value[0].name] = [];
+
+            // @ts-ignore
+            arrayRoot[inputSchema.valueBlock.value[0].name].push(inputData.valueBlock.value[i]);
+          }
+        }
+
+        //#endregion
+        else {
+          // @ts-ignore
+          result = compareSchema(root, inputData.valueBlock.value[i - admission], inputSchema.valueBlock.value[i]);
+          if (result.verified === false) {
+            if (inputSchema.valueBlock.value[i].optional)
+              admission++;
+            else {
+              //#region Delete early added name of block
+              if (inputSchema.name) {
+                inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+                if (inputSchema.name)
+                  delete (root as any)[inputSchema.name];
+              }
+              //#endregion
+
+              return result;
+            }
+          }
+        }
+      }
+    }
+
+    if (result.verified === false) // The situation may take place if last element is OPTIONAL and verification failed
+    {
+      const _result: CompareSchemaResult = {
+        verified: false,
+        result: root
+      };
+
+      //#region Delete early added name of block
+      if (inputSchema.name) {
+        inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+        if (inputSchema.name) {
+          delete (root as any)[inputSchema.name];
+          _result.name = inputSchema.name;
+        }
+      }
+      //#endregion
+
+      return _result;
+    }
+
+    return {
+      verified: true,
+      result: root
+    };
+  }
+  //#endregion
+  //#region Ability to parse internal value for primitive-encoded value (value of OctetString, for example)
+  if (inputSchema.primitiveSchema &&
+    (VALUE_HEX_VIEW in inputData.valueBlock)) {
+    //#region Decoding of raw ASN.1 data
+    const asn1 = localFromBER(inputData.valueBlock.valueHexView);
+    if (asn1.offset === -1) {
+      const _result: CompareSchemaResult = {
+        verified: false,
+        result: asn1.result
+      };
+
+      //#region Delete early added name of block
+      if (inputSchema.name) {
+        inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
+        if (inputSchema.name) {
+          delete (root as any)[inputSchema.name];
+          _result.name = inputSchema.name;
+        }
+      }
+      //#endregion
+
+      return _result;
+    }
+    //#endregion
+
+    return compareSchema(root, asn1.result, inputSchema.primitiveSchema);
+  }
+
+  return {
+    verified: true,
+    result: root
+  };
+  //#endregion
+}
+/**
+ * ASN.1 schema verification for ArrayBuffer data
+ * @param  inputBuffer Input BER-encoded ASN.1 data
+ * @param  inputSchema Input ASN.1 schema to verify against to
+ * @return
+ */
+
+export function verifySchema(inputBuffer: pvtsutils.BufferSource, inputSchema: AsnSchemaType): CompareSchemaResult {
+  //#region Initial check
+  if ((inputSchema instanceof Object) === false) {
+    return {
+      verified: false,
+      result: { error: "Wrong ASN.1 schema type" }
+    };
+  }
+  //#endregion
+  //#region Decoding of raw ASN.1 data
+  const asn1 = localFromBER(pvtsutils.BufferSourceConverter.toUint8Array(inputBuffer));
+  if (asn1.offset === -1) {
+    return {
+      verified: false,
+      result: asn1.result
+    };
+  }
+  //#endregion
+  //#region Compare ASN.1 struct with input schema
+
+  return compareSchema(asn1.result, asn1.result, inputSchema);
+  //#endregion
+}
diff --git a/comm/third_party/asn1js/src/types.ts b/comm/third_party/asn1js/src/types.ts
new file mode 100644
index 0000000000..60b5ee414a
--- /dev/null
+++ b/comm/third_party/asn1js/src/types.ts
@@ -0,0 +1,62 @@
+
+export interface IBerConvertible {
+
+  /**
+   * Base function for converting block from BER encoded array of bytes
+   * @param inputBuffer ASN.1 BER encoded array
+   * @param inputOffset Offset in ASN.1 BER encoded array where decoding should be started
+   * @param inputLength Maximum length of array of bytes which can be using in this function
+   * @returns Offset after least decoded byte
+   */
+  fromBER(inputBuffer: ArrayBuffer | Uint8Array, inputOffset: number, inputLength: number): number;
+  /**
+   * Encoding of current ASN.1 block into ASN.1 encoded array (BER rules)
+   * @param sizeOnly Flag that we need only a size of encoding, not a real array of bytes
+   * @returns ASN.1 BER encoded array
+   */
+  toBER(sizeOnly?: boolean): ArrayBuffer;
+}
+
+export interface IDerConvertible {
+  /**
+   * Base function for converting block from DER encoded array of bytes
+   * @param inputBuffer ASN.1 DER encoded array
+   * @param inputOffset Offset in ASN.1 DER encoded array where decoding should be started
+   * @param inputLength Maximum length of array of bytes which can be using in this function
+   * @param expectedLength Expected length of converted VALUE_HEX buffer
+   * @returns Offset after least decoded byte
+   */
+  fromDER(inputBuffer: ArrayBuffer, inputOffset: number, inputLength: number, expectedLength?: number): number;
+  /**
+   * Encoding of current ASN.1 block into ASN.1 encoded array (DER rules)
+   * @param sizeOnly Flag that we need only a size of encoding, not a real array of bytes
+   * @returns ASN.1 DER encoded array
+   */
+  toDER(sizeOnly?: boolean): ArrayBuffer;
+}
+
+export interface IStringConvertible {
+  /**
+   * Returns a string representation of an object
+   * @returns String representation of the class object
+   */
+  toString(): string;
+  /**
+   * Creates a class object from the string
+   * @param data Input string to convert from
+   */
+  fromString(data: string): void;
+}
+
+export interface IDateConvertible {
+  /**
+   * Converts a class object into the JavaScrip Date Object
+   * @returns Date object
+   */
+  toDate(): Date;
+  /**
+   * Creates a class object from the JavaScript Date object
+   * @param date Date object
+   */
+  fromDate(date: Date): void;
+}
\ No newline at end of file
diff --git a/comm/third_party/asn1js/tsconfig.json b/comm/third_party/asn1js/tsconfig.json
new file mode 100644
index 0000000000..87c32e8273
--- /dev/null
+++ b/comm/third_party/asn1js/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "lib": [
+      "ES2019"
+    ],
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "skipLibCheck": true,
+    "noErrorTruncation": true,
+    "experimentalDecorators": true
+  }
+}
\ No newline at end of file
diff --git a/comm/third_party/asn1js/yarn.lock b/comm/third_party/asn1js/yarn.lock
new file mode 100644
index 0000000000..25c091ea34
--- /dev/null
+++ b/comm/third_party/asn1js/yarn.lock
@@ -0,0 +1,2373 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@ampproject/remapping@^2.1.0":
+  "integrity" "sha512-hoyByceqwKirw7w3Z7gnIIZC3Wx3J484Y3L/cMpXFbr7d9ZQj2mODrirNzcJa+SM3UlpWXYvKV4RlRpFXlWgXg=="
+  "resolved" "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.1.2.tgz"
+  "version" "2.1.2"
+  dependencies:
+    "@jridgewell/trace-mapping" "^0.3.0"
+
+"@babel/code-frame@^7.16.7":
+  "integrity" "sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg=="
+  "resolved" "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.16.7.tgz"
+  "version" "7.16.7"
+  dependencies:
+    "@babel/highlight" "^7.16.7"
+
+"@babel/compat-data@^7.17.7":
+  "integrity" "sha512-p8pdE6j0a29TNGebNm7NzYZWB3xVZJBZ7XGs42uAKzQo8VQ3F0By/cQCtUEABwIqw5zo6WA4NbmxsfzADzMKnQ=="
+  "resolved" "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.17.7.tgz"
+  "version" "7.17.7"
+
+"@babel/core@^7.0.0", "@babel/core@^7.7.5":
+  "integrity" "sha512-5ug+SfZCpDAkVp9SFIZAzlW18rlzsOcJGaetCjkySnrXXDUw9AR8cDUm1iByTmdWM6yxX6/zycaV76w3YTF2gw=="
+  "resolved" "https://registry.npmjs.org/@babel/core/-/core-7.17.9.tgz"
+  "version" "7.17.9"
+  dependencies:
+    "@ampproject/remapping" "^2.1.0"
+    "@babel/code-frame" "^7.16.7"
+    "@babel/generator" "^7.17.9"
+    "@babel/helper-compilation-targets" "^7.17.7"
+    "@babel/helper-module-transforms" "^7.17.7"
+    "@babel/helpers" "^7.17.9"
+    "@babel/parser" "^7.17.9"
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.17.9"
+    "@babel/types" "^7.17.0"
+    "convert-source-map" "^1.7.0"
+    "debug" "^4.1.0"
+    "gensync" "^1.0.0-beta.2"
+    "json5" "^2.2.1"
+    "semver" "^6.3.0"
+
+"@babel/generator@^7.17.9":
+  "integrity" "sha512-rAdDousTwxbIxbz5I7GEQ3lUip+xVCXooZNbsydCWs3xA7ZsYOv+CFRdzGxRX78BmQHu9B1Eso59AOZQOJDEdQ=="
+  "resolved" "https://registry.npmjs.org/@babel/generator/-/generator-7.17.9.tgz"
+  "version" "7.17.9"
+  dependencies:
+    "@babel/types" "^7.17.0"
+    "jsesc" "^2.5.1"
+    "source-map" "^0.5.0"
+
+"@babel/helper-compilation-targets@^7.17.7":
+  "integrity" "sha512-UFzlz2jjd8kroj0hmCFV5zr+tQPi1dpC2cRsDV/3IEW8bJfCPrPpmcSN6ZS8RqIq4LXcmpipCQFPddyFA5Yc7w=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.17.7.tgz"
+  "version" "7.17.7"
+  dependencies:
+    "@babel/compat-data" "^7.17.7"
+    "@babel/helper-validator-option" "^7.16.7"
+    "browserslist" "^4.17.5"
+    "semver" "^6.3.0"
+
+"@babel/helper-environment-visitor@^7.16.7":
+  "integrity" "sha512-SLLb0AAn6PkUeAfKJCCOl9e1R53pQlGAfc4y4XuMRZfqeMYLE0dM1LMhqbGAlGQY0lfw5/ohoYWAe9V1yibRag=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.16.7.tgz"
+  "version" "7.16.7"
+  dependencies:
+    "@babel/types" "^7.16.7"
+
+"@babel/helper-function-name@^7.17.9":
+  "integrity" "sha512-7cRisGlVtiVqZ0MW0/yFB4atgpGLWEHUVYnb448hZK4x+vih0YO5UoS11XIYtZYqHd0dIPMdUSv8q5K4LdMnIg=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.17.9.tgz"
+  "version" "7.17.9"
+  dependencies:
+    "@babel/template" "^7.16.7"
+    "@babel/types" "^7.17.0"
+
+"@babel/helper-hoist-variables@^7.16.7":
+  "integrity" "sha512-m04d/0Op34H5v7pbZw6pSKP7weA6lsMvfiIAMeIvkY/R4xQtBSMFEigu9QTZ2qB/9l22vsxtM8a+Q8CzD255fg=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.16.7.tgz"
+  "version" "7.16.7"
+  dependencies:
+    "@babel/types" "^7.16.7"
+
+"@babel/helper-module-imports@^7.16.7":
+  "integrity" "sha512-LVtS6TqjJHFc+nYeITRo6VLXve70xmq7wPhWTqDJusJEgGmkAACWwMiTNrvfoQo6hEhFwAIixNkvB0jPXDL8Wg=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.16.7.tgz"
+  "version" "7.16.7"
+  dependencies:
+    "@babel/types" "^7.16.7"
+
+"@babel/helper-module-transforms@^7.17.7":
+  "integrity" "sha512-VmZD99F3gNTYB7fJRDTi+u6l/zxY0BE6OIxPSU7a50s6ZUQkHwSDmV92FfM+oCG0pZRVojGYhkR8I0OGeCVREw=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.17.7.tgz"
+  "version" "7.17.7"
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-module-imports" "^7.16.7"
+    "@babel/helper-simple-access" "^7.17.7"
+    "@babel/helper-split-export-declaration" "^7.16.7"
+    "@babel/helper-validator-identifier" "^7.16.7"
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.17.3"
+    "@babel/types" "^7.17.0"
+
+"@babel/helper-simple-access@^7.17.7":
+  "integrity" "sha512-txyMCGroZ96i+Pxr3Je3lzEJjqwaRC9buMUgtomcrLe5Nd0+fk1h0LLA+ixUF5OW7AhHuQ7Es1WcQJZmZsz2XA=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.17.7.tgz"
+  "version" "7.17.7"
+  dependencies:
+    "@babel/types" "^7.17.0"
+
+"@babel/helper-split-export-declaration@^7.16.7":
+  "integrity" "sha512-xbWoy/PFoxSWazIToT9Sif+jJTlrMcndIsaOKvTA6u7QEo7ilkRZpjew18/W3c7nm8fXdUDXh02VXTbZ0pGDNw=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.16.7.tgz"
+  "version" "7.16.7"
+  dependencies:
+    "@babel/types" "^7.16.7"
+
+"@babel/helper-validator-identifier@^7.16.7":
+  "integrity" "sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.16.7.tgz"
+  "version" "7.16.7"
+
+"@babel/helper-validator-option@^7.16.7":
+  "integrity" "sha512-TRtenOuRUVo9oIQGPC5G9DgK4743cdxvtOw0weQNpZXaS16SCBi5MNjZF8vba3ETURjZpTbVn7Vvcf2eAwFozQ=="
+  "resolved" "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.16.7.tgz"
+  "version" "7.16.7"
+
+"@babel/helpers@^7.17.9":
+  "integrity" "sha512-cPCt915ShDWUEzEp3+UNRktO2n6v49l5RSnG9M5pS24hA+2FAc5si+Pn1i4VVbQQ+jh+bIZhPFQOJOzbrOYY1Q=="
+  "resolved" "https://registry.npmjs.org/@babel/helpers/-/helpers-7.17.9.tgz"
+  "version" "7.17.9"
+  dependencies:
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.17.9"
+    "@babel/types" "^7.17.0"
+
+"@babel/highlight@^7.16.7":
+  "integrity" "sha512-J9PfEKCbFIv2X5bjTMiZu6Vf341N05QIY+d6FvVKynkG1S7G0j3I0QoRtWIrXhZ+/Nlb5Q0MzqL7TokEJ5BNHg=="
+  "resolved" "https://registry.npmjs.org/@babel/highlight/-/highlight-7.17.9.tgz"
+  "version" "7.17.9"
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.16.7"
+    "chalk" "^2.0.0"
+    "js-tokens" "^4.0.0"
+
+"@babel/parser@^7.16.7", "@babel/parser@^7.17.9":
+  "integrity" "sha512-vqUSBLP8dQHFPdPi9bc5GK9vRkYHJ49fsZdtoJ8EQ8ibpwk5rPKfvNIwChB0KVXcIjcepEBBd2VHC5r9Gy8ueg=="
+  "resolved" "https://registry.npmjs.org/@babel/parser/-/parser-7.17.9.tgz"
+  "version" "7.17.9"
+
+"@babel/template@^7.16.7":
+  "integrity" "sha512-I8j/x8kHUrbYRTUxXrrMbfCa7jxkE7tZre39x3kjr9hvI82cK1FfqLygotcWN5kdPGWcLdWMHpSBavse5tWw3w=="
+  "resolved" "https://registry.npmjs.org/@babel/template/-/template-7.16.7.tgz"
+  "version" "7.16.7"
+  dependencies:
+    "@babel/code-frame" "^7.16.7"
+    "@babel/parser" "^7.16.7"
+    "@babel/types" "^7.16.7"
+
+"@babel/traverse@^7.17.3", "@babel/traverse@^7.17.9":
+  "integrity" "sha512-PQO8sDIJ8SIwipTPiR71kJQCKQYB5NGImbOviK8K+kg5xkNSYXLBupuX9QhatFowrsvo9Hj8WgArg3W7ijNAQw=="
+  "resolved" "https://registry.npmjs.org/@babel/traverse/-/traverse-7.17.9.tgz"
+  "version" "7.17.9"
+  dependencies:
+    "@babel/code-frame" "^7.16.7"
+    "@babel/generator" "^7.17.9"
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-function-name" "^7.17.9"
+    "@babel/helper-hoist-variables" "^7.16.7"
+    "@babel/helper-split-export-declaration" "^7.16.7"
+    "@babel/parser" "^7.17.9"
+    "@babel/types" "^7.17.0"
+    "debug" "^4.1.0"
+    "globals" "^11.1.0"
+
+"@babel/types@^7.16.7", "@babel/types@^7.17.0":
+  "integrity" "sha512-TmKSNO4D5rzhL5bjWFcVHHLETzfQ/AmbKpKPOSjlP0WoHZ6L911fgoOKY4Alp/emzG4cHJdyN49zpgkbXFEHHw=="
+  "resolved" "https://registry.npmjs.org/@babel/types/-/types-7.17.0.tgz"
+  "version" "7.17.0"
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.16.7"
+    "to-fast-properties" "^2.0.0"
+
+"@cspotcode/source-map-consumer@0.8.0":
+  "integrity" "sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg=="
+  "resolved" "https://registry.npmjs.org/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz"
+  "version" "0.8.0"
+
+"@cspotcode/source-map-support@0.7.0":
+  "integrity" "sha512-X4xqRHqN8ACt2aHVe51OxeA2HjbcL4MqFqXkrmQszJ1NOUuUu5u6Vqx/0lZSVNku7velL5FC/s5uEAj1lsBMhA=="
+  "resolved" "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.7.0.tgz"
+  "version" "0.7.0"
+  dependencies:
+    "@cspotcode/source-map-consumer" "0.8.0"
+
+"@esbuild/linux-x64@0.17.6":
+  "integrity" "sha512-a3yHLmOodHrzuNgdpB7peFGPx1iJ2x6m+uDvhP2CKdr2CwOaqEFMeSqYAHU7hG+RjCq8r2NFujcd/YsEsFgTGw=="
+  "resolved" "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.17.6.tgz"
+  "version" "0.17.6"
+
+"@eslint/eslintrc@^1.2.3":
+  "integrity" "sha512-uGo44hIwoLGNyduRpjdEpovcbMdd+Nv7amtmJxnKmI8xj6yd5LncmSwDa5NgX/41lIFJtkjD6YdVfgEzPfJ5UA=="
+  "resolved" "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.2.3.tgz"
+  "version" "1.2.3"
+  dependencies:
+    "ajv" "^6.12.4"
+    "debug" "^4.3.2"
+    "espree" "^9.3.2"
+    "globals" "^13.9.0"
+    "ignore" "^5.2.0"
+    "import-fresh" "^3.2.1"
+    "js-yaml" "^4.1.0"
+    "minimatch" "^3.1.2"
+    "strip-json-comments" "^3.1.1"
+
+"@humanwhocodes/config-array@^0.9.2":
+  "integrity" "sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw=="
+  "resolved" "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.9.5.tgz"
+  "version" "0.9.5"
+  dependencies:
+    "@humanwhocodes/object-schema" "^1.2.1"
+    "debug" "^4.1.1"
+    "minimatch" "^3.0.4"
+
+"@humanwhocodes/object-schema@^1.2.1":
+  "integrity" "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA=="
+  "resolved" "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz"
+  "version" "1.2.1"
+
+"@istanbuljs/load-nyc-config@^1.0.0":
+  "integrity" "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ=="
+  "resolved" "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz"
+  "version" "1.1.0"
+  dependencies:
+    "camelcase" "^5.3.1"
+    "find-up" "^4.1.0"
+    "get-package-type" "^0.1.0"
+    "js-yaml" "^3.13.1"
+    "resolve-from" "^5.0.0"
+
+"@istanbuljs/schema@^0.1.2":
+  "integrity" "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA=="
+  "resolved" "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz"
+  "version" "0.1.3"
+
+"@jridgewell/resolve-uri@^3.0.3":
+  "integrity" "sha512-R7xHtBSNm+9SyvpJkdQl+qrM3Hm2fea3Ef197M3mUug+v+yR+Rhfbs7PBtcBUVnIWJ4JcAdjvij+c8hXS9p5aw=="
+  "resolved" "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.0.6.tgz"
+  "version" "3.0.6"
+
+"@jridgewell/sourcemap-codec@^1.4.10":
+  "integrity" "sha512-Fg32GrJo61m+VqYSdRSjRXMjQ06j8YIYfcTqndLYVAaHmroZHLJZCydsWBOTDqXS2v+mjxohBWEMfg97GXmYQg=="
+  "resolved" "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.11.tgz"
+  "version" "1.4.11"
+
+"@jridgewell/trace-mapping@^0.3.0":
+  "integrity" "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ=="
+  "resolved" "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz"
+  "version" "0.3.9"
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.0.3"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+
+"@nodelib/fs.scandir@2.1.5":
+  "integrity" "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="
+  "resolved" "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"
+  "version" "2.1.5"
+  dependencies:
+    "@nodelib/fs.stat" "2.0.5"
+    "run-parallel" "^1.1.9"
+
+"@nodelib/fs.stat@^2.0.2", "@nodelib/fs.stat@2.0.5":
+  "integrity" "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="
+  "resolved" "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
+  "version" "2.0.5"
+
+"@nodelib/fs.walk@^1.2.3":
+  "integrity" "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="
+  "resolved" "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz"
+  "version" "1.2.8"
+  dependencies:
+    "@nodelib/fs.scandir" "2.1.5"
+    "fastq" "^1.6.0"
+
+"@rollup/pluginutils@^4.1.2":
+  "integrity" "sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ=="
+  "resolved" "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-4.2.1.tgz"
+  "version" "4.2.1"
+  dependencies:
+    "estree-walker" "^2.0.1"
+    "picomatch" "^2.2.2"
+
+"@tsconfig/node10@^1.0.7":
+  "integrity" "sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg=="
+  "resolved" "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.8.tgz"
+  "version" "1.0.8"
+
+"@tsconfig/node12@^1.0.7":
+  "integrity" "sha512-/yBMcem+fbvhSREH+s14YJi18sp7J9jpuhYByADT2rypfajMZZN4WQ6zBGgBKp53NKmqI36wFYDb3yaMPurITw=="
+  "resolved" "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.9.tgz"
+  "version" "1.0.9"
+
+"@tsconfig/node14@^1.0.0":
+  "integrity" "sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg=="
+  "resolved" "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.1.tgz"
+  "version" "1.0.1"
+
+"@tsconfig/node16@^1.0.2":
+  "integrity" "sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA=="
+  "resolved" "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.2.tgz"
+  "version" "1.0.2"
+
+"@types/json-schema@^7.0.9":
+  "integrity" "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ=="
+  "resolved" "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz"
+  "version" "7.0.11"
+
+"@types/mocha@^9.1.1":
+  "integrity" "sha512-Z61JK7DKDtdKTWwLeElSEBcWGRLY8g95ic5FoQqI9CMx0ns/Ghep3B4DfcEimiKMvtamNVULVNKEsiwV3aQmXw=="
+  "resolved" "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz"
+  "version" "9.1.1"
+
+"@types/node@*", "@types/node@^17.0.32":
+  "integrity" "sha512-eAIcfAvhf/BkHcf4pkLJ7ECpBAhh9kcxRBpip9cTiO+hf+aJrsxYxBeS6OXvOd9WqNAJmavXVpZvY1rBjNsXmw=="
+  "resolved" "https://registry.npmjs.org/@types/node/-/node-17.0.32.tgz"
+  "version" "17.0.32"
+
+"@types/resolve@0.0.8":
+  "integrity" "sha512-auApPaJf3NPfe18hSoJkp8EbZzer2ISk7o8mCC3M9he/a04+gbMF97NkpD2S8riMGvm4BMRI59/SZQSaLTKpsQ=="
+  "resolved" "https://registry.npmjs.org/@types/resolve/-/resolve-0.0.8.tgz"
+  "version" "0.0.8"
+  dependencies:
+    "@types/node" "*"
+
+"@typescript-eslint/eslint-plugin@^5.23.0":
+  "integrity" "sha512-hEcSmG4XodSLiAp1uxv/OQSGsDY6QN3TcRU32gANp+19wGE1QQZLRS8/GV58VRUoXhnkuJ3ZxNQ3T6Z6zM59DA=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@typescript-eslint/scope-manager" "5.23.0"
+    "@typescript-eslint/type-utils" "5.23.0"
+    "@typescript-eslint/utils" "5.23.0"
+    "debug" "^4.3.2"
+    "functional-red-black-tree" "^1.0.1"
+    "ignore" "^5.1.8"
+    "regexpp" "^3.2.0"
+    "semver" "^7.3.5"
+    "tsutils" "^3.21.0"
+
+"@typescript-eslint/experimental-utils@^5.0.0":
+  "integrity" "sha512-rKxoCUtAHwEH6IcAoVpqipY6Th+YKW7WFspAKu0IFdbdKZpveFBeqxxE9Xn+GWikhq1o03V3VXbxIe+GdhggiQ=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-5.22.0.tgz"
+  "version" "5.22.0"
+  dependencies:
+    "@typescript-eslint/utils" "5.22.0"
+
+"@typescript-eslint/parser@^5.0.0", "@typescript-eslint/parser@^5.23.0":
+  "integrity" "sha512-V06cYUkqcGqpFjb8ttVgzNF53tgbB/KoQT/iB++DOIExKmzI9vBJKjZKt/6FuV9c+zrDsvJKbJ2DOCYwX91cbw=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@typescript-eslint/scope-manager" "5.23.0"
+    "@typescript-eslint/types" "5.23.0"
+    "@typescript-eslint/typescript-estree" "5.23.0"
+    "debug" "^4.3.2"
+
+"@typescript-eslint/scope-manager@5.22.0":
+  "integrity" "sha512-yA9G5NJgV5esANJCO0oF15MkBO20mIskbZ8ijfmlKIvQKg0ynVKfHZ15/nhAJN5m8Jn3X5qkwriQCiUntC9AbA=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.22.0.tgz"
+  "version" "5.22.0"
+  dependencies:
+    "@typescript-eslint/types" "5.22.0"
+    "@typescript-eslint/visitor-keys" "5.22.0"
+
+"@typescript-eslint/scope-manager@5.23.0":
+  "integrity" "sha512-EhjaFELQHCRb5wTwlGsNMvzK9b8Oco4aYNleeDlNuL6qXWDF47ch4EhVNPh8Rdhf9tmqbN4sWDk/8g+Z/J8JVw=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@typescript-eslint/types" "5.23.0"
+    "@typescript-eslint/visitor-keys" "5.23.0"
+
+"@typescript-eslint/type-utils@5.23.0":
+  "integrity" "sha512-iuI05JsJl/SUnOTXA9f4oI+/4qS/Zcgk+s2ir+lRmXI+80D8GaGwoUqs4p+X+4AxDolPpEpVUdlEH4ADxFy4gw=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@typescript-eslint/utils" "5.23.0"
+    "debug" "^4.3.2"
+    "tsutils" "^3.21.0"
+
+"@typescript-eslint/types@5.22.0":
+  "integrity" "sha512-T7owcXW4l0v7NTijmjGWwWf/1JqdlWiBzPqzAWhobxft0SiEvMJB56QXmeCQjrPuM8zEfGUKyPQr/L8+cFUBLw=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.22.0.tgz"
+  "version" "5.22.0"
+
+"@typescript-eslint/types@5.23.0":
+  "integrity" "sha512-NfBsV/h4dir/8mJwdZz7JFibaKC3E/QdeMEDJhiAE3/eMkoniZ7MjbEMCGXw6MZnZDMN3G9S0mH/6WUIj91dmw=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.23.0.tgz"
+  "version" "5.23.0"
+
+"@typescript-eslint/typescript-estree@5.22.0":
+  "integrity" "sha512-EyBEQxvNjg80yinGE2xdhpDYm41so/1kOItl0qrjIiJ1kX/L/L8WWGmJg8ni6eG3DwqmOzDqOhe6763bF92nOw=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.22.0.tgz"
+  "version" "5.22.0"
+  dependencies:
+    "@typescript-eslint/types" "5.22.0"
+    "@typescript-eslint/visitor-keys" "5.22.0"
+    "debug" "^4.3.2"
+    "globby" "^11.0.4"
+    "is-glob" "^4.0.3"
+    "semver" "^7.3.5"
+    "tsutils" "^3.21.0"
+
+"@typescript-eslint/typescript-estree@5.23.0":
+  "integrity" "sha512-xE9e0lrHhI647SlGMl+m+3E3CKPF1wzvvOEWnuE3CCjjT7UiRnDGJxmAcVKJIlFgK6DY9RB98eLr1OPigPEOGg=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@typescript-eslint/types" "5.23.0"
+    "@typescript-eslint/visitor-keys" "5.23.0"
+    "debug" "^4.3.2"
+    "globby" "^11.0.4"
+    "is-glob" "^4.0.3"
+    "semver" "^7.3.5"
+    "tsutils" "^3.21.0"
+
+"@typescript-eslint/utils@5.22.0":
+  "integrity" "sha512-HodsGb037iobrWSUMS7QH6Hl1kppikjA1ELiJlNSTYf/UdMEwzgj0WIp+lBNb6WZ3zTwb0tEz51j0Wee3iJ3wQ=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.22.0.tgz"
+  "version" "5.22.0"
+  dependencies:
+    "@types/json-schema" "^7.0.9"
+    "@typescript-eslint/scope-manager" "5.22.0"
+    "@typescript-eslint/types" "5.22.0"
+    "@typescript-eslint/typescript-estree" "5.22.0"
+    "eslint-scope" "^5.1.1"
+    "eslint-utils" "^3.0.0"
+
+"@typescript-eslint/utils@5.23.0":
+  "integrity" "sha512-dbgaKN21drqpkbbedGMNPCtRPZo1IOUr5EI9Jrrh99r5UW5Q0dz46RKXeSBoPV+56R6dFKpbrdhgUNSJsDDRZA=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@types/json-schema" "^7.0.9"
+    "@typescript-eslint/scope-manager" "5.23.0"
+    "@typescript-eslint/types" "5.23.0"
+    "@typescript-eslint/typescript-estree" "5.23.0"
+    "eslint-scope" "^5.1.1"
+    "eslint-utils" "^3.0.0"
+
+"@typescript-eslint/visitor-keys@5.22.0":
+  "integrity" "sha512-DbgTqn2Dv5RFWluG88tn0pP6Ex0ROF+dpDO1TNNZdRtLjUr6bdznjA6f/qNqJLjd2PgguAES2Zgxh/JzwzETDg=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.22.0.tgz"
+  "version" "5.22.0"
+  dependencies:
+    "@typescript-eslint/types" "5.22.0"
+    "eslint-visitor-keys" "^3.0.0"
+
+"@typescript-eslint/visitor-keys@5.23.0":
+  "integrity" "sha512-Vd4mFNchU62sJB8pX19ZSPog05B0Y0CE2UxAZPT5k4iqhRYjPnqyY3woMxCd0++t9OTqkgjST+1ydLBi7e2Fvg=="
+  "resolved" "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.23.0.tgz"
+  "version" "5.23.0"
+  dependencies:
+    "@typescript-eslint/types" "5.23.0"
+    "eslint-visitor-keys" "^3.0.0"
+
+"@ungap/promise-all-settled@1.1.2":
+  "integrity" "sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q=="
+  "resolved" "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz"
+  "version" "1.1.2"
+
+"@yarn-tool/resolve-package@^1.0.40":
+  "integrity" "sha512-RJcBGTVywUqYGRtGkPSgJC/ozf0wK/xjUy66tXkbpL35U0o1oef4S0v23euxA/CiukqBWr2fRGtGY6FidESdTg=="
+  "resolved" "https://registry.npmjs.org/@yarn-tool/resolve-package/-/resolve-package-1.0.46.tgz"
+  "version" "1.0.46"
+  dependencies:
+    "pkg-dir" "< 6 >= 5"
+    "tslib" "^2.3.1"
+    "upath2" "^3.1.12"
+
+"acorn-jsx@^5.3.2":
+  "integrity" "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="
+  "resolved" "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
+  "version" "5.3.2"
+
+"acorn-walk@^8.1.1":
+  "integrity" "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA=="
+  "resolved" "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz"
+  "version" "8.2.0"
+
+"acorn@^6.0.0 || ^7.0.0 || ^8.0.0", "acorn@^8.4.1", "acorn@^8.7.1":
+  "integrity" "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A=="
+  "resolved" "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz"
+  "version" "8.7.1"
+
+"aggregate-error@^3.0.0":
+  "integrity" "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA=="
+  "resolved" "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz"
+  "version" "3.1.0"
+  dependencies:
+    "clean-stack" "^2.0.0"
+    "indent-string" "^4.0.0"
+
+"ajv@^6.10.0", "ajv@^6.12.4":
+  "integrity" "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="
+  "resolved" "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
+  "version" "6.12.6"
+  dependencies:
+    "fast-deep-equal" "^3.1.1"
+    "fast-json-stable-stringify" "^2.0.0"
+    "json-schema-traverse" "^0.4.1"
+    "uri-js" "^4.2.2"
+
+"ansi-colors@4.1.1":
+  "integrity" "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA=="
+  "resolved" "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz"
+  "version" "4.1.1"
+
+"ansi-regex@^5.0.1":
+  "integrity" "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="
+  "resolved" "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
+  "version" "5.0.1"
+
+"ansi-styles@^3.2.1":
+  "integrity" "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA=="
+  "resolved" "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz"
+  "version" "3.2.1"
+  dependencies:
+    "color-convert" "^1.9.0"
+
+"ansi-styles@^4.0.0", "ansi-styles@^4.1.0":
+  "integrity" "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="
+  "resolved" "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
+  "version" "4.3.0"
+  dependencies:
+    "color-convert" "^2.0.1"
+
+"anymatch@~3.1.2":
+  "integrity" "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg=="
+  "resolved" "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz"
+  "version" "3.1.2"
+  dependencies:
+    "normalize-path" "^3.0.0"
+    "picomatch" "^2.0.4"
+
+"append-transform@^2.0.0":
+  "integrity" "sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg=="
+  "resolved" "https://registry.npmjs.org/append-transform/-/append-transform-2.0.0.tgz"
+  "version" "2.0.0"
+  dependencies:
+    "default-require-extensions" "^3.0.0"
+
+"archy@^1.0.0":
+  "integrity" "sha1-+cjBN1fMHde8N5rHeyxipcKGjEA="
+  "resolved" "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz"
+  "version" "1.0.0"
+
+"arg@^4.1.0":
+  "integrity" "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA=="
+  "resolved" "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz"
+  "version" "4.1.3"
+
+"argparse@^1.0.7":
+  "integrity" "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="
+  "resolved" "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz"
+  "version" "1.0.10"
+  dependencies:
+    "sprintf-js" "~1.0.2"
+
+"argparse@^2.0.1":
+  "integrity" "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+  "resolved" "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
+  "version" "2.0.1"
+
+"array-union@^2.1.0":
+  "integrity" "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw=="
+  "resolved" "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
+  "version" "2.1.0"
+
+"asn1-test-suite@^1.0.2":
+  "integrity" "sha512-qerYt//ST6WaGu6gVT+Hpgnd7Dy/lptAN2AVbAOfaleoiuwbN/61z3USrGU03Yu5645xpgrXvCIuexi9i8m2aA=="
+  "resolved" "https://registry.npmjs.org/asn1-test-suite/-/asn1-test-suite-1.0.2.tgz"
+  "version" "1.0.2"
+
+"balanced-match@^1.0.0":
+  "integrity" "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+  "resolved" "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
+  "version" "1.0.2"
+
+"binary-extensions@^2.0.0":
+  "integrity" "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA=="
+  "resolved" "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz"
+  "version" "2.2.0"
+
+"brace-expansion@^1.1.7":
+  "integrity" "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="
+  "resolved" "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
+  "version" "1.1.11"
+  dependencies:
+    "balanced-match" "^1.0.0"
+    "concat-map" "0.0.1"
+
+"brace-expansion@^2.0.1":
+  "integrity" "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA=="
+  "resolved" "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz"
+  "version" "2.0.1"
+  dependencies:
+    "balanced-match" "^1.0.0"
+
+"braces@^3.0.2", "braces@~3.0.2":
+  "integrity" "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A=="
+  "resolved" "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz"
+  "version" "3.0.2"
+  dependencies:
+    "fill-range" "^7.0.1"
+
+"browser-stdout@1.3.1":
+  "integrity" "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw=="
+  "resolved" "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz"
+  "version" "1.3.1"
+
+"browserslist@^4.17.5":
+  "integrity" "sha512-NBhymBQl1zM0Y5dQT/O+xiLP9/rzOIQdKM/eMJBAq7yBgaB6krIYLGejrwVYnSHZdqjscB1SPuAjHwxjvN6Wdg=="
+  "resolved" "https://registry.npmjs.org/browserslist/-/browserslist-4.20.3.tgz"
+  "version" "4.20.3"
+  dependencies:
+    "caniuse-lite" "^1.0.30001332"
+    "electron-to-chromium" "^1.4.118"
+    "escalade" "^3.1.1"
+    "node-releases" "^2.0.3"
+    "picocolors" "^1.0.0"
+
+"builtin-modules@^3.1.0":
+  "integrity" "sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA=="
+  "resolved" "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.2.0.tgz"
+  "version" "3.2.0"
+
+"caching-transform@^4.0.0":
+  "integrity" "sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA=="
+  "resolved" "https://registry.npmjs.org/caching-transform/-/caching-transform-4.0.0.tgz"
+  "version" "4.0.0"
+  dependencies:
+    "hasha" "^5.0.0"
+    "make-dir" "^3.0.0"
+    "package-hash" "^4.0.0"
+    "write-file-atomic" "^3.0.0"
+
+"callsites@^3.0.0":
+  "integrity" "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="
+  "resolved" "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
+  "version" "3.1.0"
+
+"camelcase@^5.0.0", "camelcase@^5.3.1":
+  "integrity" "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg=="
+  "resolved" "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz"
+  "version" "5.3.1"
+
+"camelcase@^6.0.0":
+  "integrity" "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA=="
+  "resolved" "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz"
+  "version" "6.3.0"
+
+"caniuse-lite@^1.0.30001332":
+  "integrity" "sha512-10T30NYOEQtN6C11YGg411yebhvpnC6Z102+B95eAsN0oB6KUs01ivE8u+G6FMIRtIrVlYXhL+LUwQ3/hXwDWw=="
+  "resolved" "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001332.tgz"
+  "version" "1.0.30001332"
+
+"chalk@^2.0.0":
+  "integrity" "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ=="
+  "resolved" "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz"
+  "version" "2.4.2"
+  dependencies:
+    "ansi-styles" "^3.2.1"
+    "escape-string-regexp" "^1.0.5"
+    "supports-color" "^5.3.0"
+
+"chalk@^4.0.0", "chalk@^4.1.0":
+  "integrity" "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="
+  "resolved" "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
+  "version" "4.1.2"
+  dependencies:
+    "ansi-styles" "^4.1.0"
+    "supports-color" "^7.1.0"
+
+"chokidar@3.5.3":
+  "integrity" "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw=="
+  "resolved" "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz"
+  "version" "3.5.3"
+  dependencies:
+    "anymatch" "~3.1.2"
+    "braces" "~3.0.2"
+    "glob-parent" "~5.1.2"
+    "is-binary-path" "~2.1.0"
+    "is-glob" "~4.0.1"
+    "normalize-path" "~3.0.0"
+    "readdirp" "~3.6.0"
+  optionalDependencies:
+    "fsevents" "~2.3.2"
+
+"clean-stack@^2.0.0":
+  "integrity" "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A=="
+  "resolved" "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz"
+  "version" "2.2.0"
+
+"cliui@^6.0.0":
+  "integrity" "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ=="
+  "resolved" "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz"
+  "version" "6.0.0"
+  dependencies:
+    "string-width" "^4.2.0"
+    "strip-ansi" "^6.0.0"
+    "wrap-ansi" "^6.2.0"
+
+"cliui@^7.0.2":
+  "integrity" "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ=="
+  "resolved" "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz"
+  "version" "7.0.4"
+  dependencies:
+    "string-width" "^4.2.0"
+    "strip-ansi" "^6.0.0"
+    "wrap-ansi" "^7.0.0"
+
+"color-convert@^1.9.0":
+  "integrity" "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg=="
+  "resolved" "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz"
+  "version" "1.9.3"
+  dependencies:
+    "color-name" "1.1.3"
+
+"color-convert@^2.0.1":
+  "integrity" "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="
+  "resolved" "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
+  "version" "2.0.1"
+  dependencies:
+    "color-name" "~1.1.4"
+
+"color-name@~1.1.4":
+  "integrity" "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+  "resolved" "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
+  "version" "1.1.4"
+
+"color-name@1.1.3":
+  "integrity" "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU="
+  "resolved" "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz"
+  "version" "1.1.3"
+
+"commondir@^1.0.1":
+  "integrity" "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs="
+  "resolved" "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz"
+  "version" "1.0.1"
+
+"concat-map@0.0.1":
+  "integrity" "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
+  "resolved" "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
+  "version" "0.0.1"
+
+"convert-source-map@^1.7.0":
+  "integrity" "sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA=="
+  "resolved" "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.8.0.tgz"
+  "version" "1.8.0"
+  dependencies:
+    "safe-buffer" "~5.1.1"
+
+"create-require@^1.1.0":
+  "integrity" "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ=="
+  "resolved" "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz"
+  "version" "1.1.1"
+
+"cross-spawn@^7.0.0", "cross-spawn@^7.0.2":
+  "integrity" "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w=="
+  "resolved" "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz"
+  "version" "7.0.3"
+  dependencies:
+    "path-key" "^3.1.0"
+    "shebang-command" "^2.0.0"
+    "which" "^2.0.1"
+
+"debug@^4.1.0", "debug@^4.1.1", "debug@^4.3.2", "debug@4.3.4":
+  "integrity" "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ=="
+  "resolved" "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz"
+  "version" "4.3.4"
+  dependencies:
+    "ms" "2.1.2"
+
+"decamelize@^1.2.0":
+  "integrity" "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA="
+  "resolved" "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz"
+  "version" "1.2.0"
+
+"decamelize@^4.0.0":
+  "integrity" "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ=="
+  "resolved" "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz"
+  "version" "4.0.0"
+
+"deep-is@^0.1.3":
+  "integrity" "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="
+  "resolved" "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz"
+  "version" "0.1.4"
+
+"default-require-extensions@^3.0.0":
+  "integrity" "sha512-ek6DpXq/SCpvjhpFsLFRVtIxJCRw6fUR42lYMVZuUMK7n8eMz4Uh5clckdBjEpLhn/gEBZo7hDJnJcwdKLKQjg=="
+  "resolved" "https://registry.npmjs.org/default-require-extensions/-/default-require-extensions-3.0.0.tgz"
+  "version" "3.0.0"
+  dependencies:
+    "strip-bom" "^4.0.0"
+
+"diff@^4.0.1":
+  "integrity" "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A=="
+  "resolved" "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz"
+  "version" "4.0.2"
+
+"diff@5.0.0":
+  "integrity" "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w=="
+  "resolved" "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz"
+  "version" "5.0.0"
+
+"dir-glob@^3.0.1":
+  "integrity" "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA=="
+  "resolved" "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
+  "version" "3.0.1"
+  dependencies:
+    "path-type" "^4.0.0"
+
+"doctrine@^3.0.0":
+  "integrity" "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w=="
+  "resolved" "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz"
+  "version" "3.0.0"
+  dependencies:
+    "esutils" "^2.0.2"
+
+"electron-to-chromium@^1.4.118":
+  "integrity" "sha512-maZIKjnYDvF7Fs35nvVcyr44UcKNwybr93Oba2n3HkKDFAtk0svERkLN/HyczJDS3Fo4wU9th9fUQd09ZLtj1w=="
+  "resolved" "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.118.tgz"
+  "version" "1.4.118"
+
+"emoji-regex@^8.0.0":
+  "integrity" "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+  "resolved" "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
+  "version" "8.0.0"
+
+"es6-error@^4.0.1":
+  "integrity" "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg=="
+  "resolved" "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz"
+  "version" "4.1.1"
+
+"esbuild@*":
+  "integrity" "sha512-TKFRp9TxrJDdRWfSsSERKEovm6v30iHnrjlcGhLBOtReE28Yp1VSBRfO3GTaOFMoxsNerx4TjrhzSuma9ha83Q=="
+  "resolved" "https://registry.npmjs.org/esbuild/-/esbuild-0.17.6.tgz"
+  "version" "0.17.6"
+  optionalDependencies:
+    "@esbuild/android-arm" "0.17.6"
+    "@esbuild/android-arm64" "0.17.6"
+    "@esbuild/android-x64" "0.17.6"
+    "@esbuild/darwin-arm64" "0.17.6"
+    "@esbuild/darwin-x64" "0.17.6"
+    "@esbuild/freebsd-arm64" "0.17.6"
+    "@esbuild/freebsd-x64" "0.17.6"
+    "@esbuild/linux-arm" "0.17.6"
+    "@esbuild/linux-arm64" "0.17.6"
+    "@esbuild/linux-ia32" "0.17.6"
+    "@esbuild/linux-loong64" "0.17.6"
+    "@esbuild/linux-mips64el" "0.17.6"
+    "@esbuild/linux-ppc64" "0.17.6"
+    "@esbuild/linux-riscv64" "0.17.6"
+    "@esbuild/linux-s390x" "0.17.6"
+    "@esbuild/linux-x64" "0.17.6"
+    "@esbuild/netbsd-x64" "0.17.6"
+    "@esbuild/openbsd-x64" "0.17.6"
+    "@esbuild/sunos-x64" "0.17.6"
+    "@esbuild/win32-arm64" "0.17.6"
+    "@esbuild/win32-ia32" "0.17.6"
+    "@esbuild/win32-x64" "0.17.6"
+
+"escalade@^3.1.1":
+  "integrity" "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw=="
+  "resolved" "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz"
+  "version" "3.1.1"
+
+"escape-string-regexp@^1.0.5":
+  "integrity" "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
+  "resolved" "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
+  "version" "1.0.5"
+
+"escape-string-regexp@^4.0.0", "escape-string-regexp@4.0.0":
+  "integrity" "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="
+  "resolved" "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
+  "version" "4.0.0"
+
+"eslint-plugin-deprecation@^1.3.2":
+  "integrity" "sha512-z93wbx9w7H/E3ogPw6AZMkkNJ6m51fTZRNZPNQqxQLmx+KKt7aLkMU9wN67s71i+VVHN4tLOZ3zT3QLbnlC0Mg=="
+  "resolved" "https://registry.npmjs.org/eslint-plugin-deprecation/-/eslint-plugin-deprecation-1.3.2.tgz"
+  "version" "1.3.2"
+  dependencies:
+    "@typescript-eslint/experimental-utils" "^5.0.0"
+    "tslib" "^2.3.1"
+    "tsutils" "^3.21.0"
+
+"eslint-scope@^5.1.1":
+  "integrity" "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw=="
+  "resolved" "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz"
+  "version" "5.1.1"
+  dependencies:
+    "esrecurse" "^4.3.0"
+    "estraverse" "^4.1.1"
+
+"eslint-scope@^7.1.1":
+  "integrity" "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw=="
+  "resolved" "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz"
+  "version" "7.1.1"
+  dependencies:
+    "esrecurse" "^4.3.0"
+    "estraverse" "^5.2.0"
+
+"eslint-utils@^3.0.0":
+  "integrity" "sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA=="
+  "resolved" "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz"
+  "version" "3.0.0"
+  dependencies:
+    "eslint-visitor-keys" "^2.0.0"
+
+"eslint-visitor-keys@^2.0.0":
+  "integrity" "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw=="
+  "resolved" "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz"
+  "version" "2.1.0"
+
+"eslint-visitor-keys@^3.0.0", "eslint-visitor-keys@^3.3.0":
+  "integrity" "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA=="
+  "resolved" "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz"
+  "version" "3.3.0"
+
+"eslint@*", "eslint@^6.0.0 || ^7.0.0 || ^8.0.0", "eslint@^8.15.0", "eslint@>=5":
+  "integrity" "sha512-GG5USZ1jhCu8HJkzGgeK8/+RGnHaNYZGrGDzUtigK3BsGESW/rs2az23XqE0WVwDxy1VRvvjSSGu5nB0Bu+6SA=="
+  "resolved" "https://registry.npmjs.org/eslint/-/eslint-8.15.0.tgz"
+  "version" "8.15.0"
+  dependencies:
+    "@eslint/eslintrc" "^1.2.3"
+    "@humanwhocodes/config-array" "^0.9.2"
+    "ajv" "^6.10.0"
+    "chalk" "^4.0.0"
+    "cross-spawn" "^7.0.2"
+    "debug" "^4.3.2"
+    "doctrine" "^3.0.0"
+    "escape-string-regexp" "^4.0.0"
+    "eslint-scope" "^7.1.1"
+    "eslint-utils" "^3.0.0"
+    "eslint-visitor-keys" "^3.3.0"
+    "espree" "^9.3.2"
+    "esquery" "^1.4.0"
+    "esutils" "^2.0.2"
+    "fast-deep-equal" "^3.1.3"
+    "file-entry-cache" "^6.0.1"
+    "functional-red-black-tree" "^1.0.1"
+    "glob-parent" "^6.0.1"
+    "globals" "^13.6.0"
+    "ignore" "^5.2.0"
+    "import-fresh" "^3.0.0"
+    "imurmurhash" "^0.1.4"
+    "is-glob" "^4.0.0"
+    "js-yaml" "^4.1.0"
+    "json-stable-stringify-without-jsonify" "^1.0.1"
+    "levn" "^0.4.1"
+    "lodash.merge" "^4.6.2"
+    "minimatch" "^3.1.2"
+    "natural-compare" "^1.4.0"
+    "optionator" "^0.9.1"
+    "regexpp" "^3.2.0"
+    "strip-ansi" "^6.0.1"
+    "strip-json-comments" "^3.1.0"
+    "text-table" "^0.2.0"
+    "v8-compile-cache" "^2.0.3"
+
+"espree@^9.3.2":
+  "integrity" "sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA=="
+  "resolved" "https://registry.npmjs.org/espree/-/espree-9.3.2.tgz"
+  "version" "9.3.2"
+  dependencies:
+    "acorn" "^8.7.1"
+    "acorn-jsx" "^5.3.2"
+    "eslint-visitor-keys" "^3.3.0"
+
+"esprima@^4.0.0":
+  "integrity" "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="
+  "resolved" "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
+  "version" "4.0.1"
+
+"esquery@^1.4.0":
+  "integrity" "sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w=="
+  "resolved" "https://registry.npmjs.org/esquery/-/esquery-1.4.0.tgz"
+  "version" "1.4.0"
+  dependencies:
+    "estraverse" "^5.1.0"
+
+"esrecurse@^4.3.0":
+  "integrity" "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="
+  "resolved" "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
+  "version" "4.3.0"
+  dependencies:
+    "estraverse" "^5.2.0"
+
+"estraverse@^4.1.1":
+  "integrity" "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="
+  "resolved" "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz"
+  "version" "4.3.0"
+
+"estraverse@^5.1.0", "estraverse@^5.2.0":
+  "integrity" "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="
+  "resolved" "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
+  "version" "5.3.0"
+
+"estree-walker@^0.6.1":
+  "integrity" "sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w=="
+  "resolved" "https://registry.npmjs.org/estree-walker/-/estree-walker-0.6.1.tgz"
+  "version" "0.6.1"
+
+"estree-walker@^2.0.1":
+  "integrity" "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="
+  "resolved" "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz"
+  "version" "2.0.2"
+
+"esutils@^2.0.2":
+  "integrity" "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="
+  "resolved" "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
+  "version" "2.0.3"
+
+"fast-deep-equal@^3.1.1", "fast-deep-equal@^3.1.3":
+  "integrity" "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+  "resolved" "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
+  "version" "3.1.3"
+
+"fast-glob@^3.2.9":
+  "integrity" "sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew=="
+  "resolved" "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.11.tgz"
+  "version" "3.2.11"
+  dependencies:
+    "@nodelib/fs.stat" "^2.0.2"
+    "@nodelib/fs.walk" "^1.2.3"
+    "glob-parent" "^5.1.2"
+    "merge2" "^1.3.0"
+    "micromatch" "^4.0.4"
+
+"fast-json-stable-stringify@^2.0.0":
+  "integrity" "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
+  "resolved" "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
+  "version" "2.1.0"
+
+"fast-levenshtein@^2.0.6":
+  "integrity" "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc="
+  "resolved" "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz"
+  "version" "2.0.6"
+
+"fastq@^1.6.0":
+  "integrity" "sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw=="
+  "resolved" "https://registry.npmjs.org/fastq/-/fastq-1.13.0.tgz"
+  "version" "1.13.0"
+  dependencies:
+    "reusify" "^1.0.4"
+
+"file-entry-cache@^6.0.1":
+  "integrity" "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg=="
+  "resolved" "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz"
+  "version" "6.0.1"
+  dependencies:
+    "flat-cache" "^3.0.4"
+
+"fill-range@^7.0.1":
+  "integrity" "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ=="
+  "resolved" "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz"
+  "version" "7.0.1"
+  dependencies:
+    "to-regex-range" "^5.0.1"
+
+"find-cache-dir@^3.2.0", "find-cache-dir@^3.3.2":
+  "integrity" "sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig=="
+  "resolved" "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.2.tgz"
+  "version" "3.3.2"
+  dependencies:
+    "commondir" "^1.0.1"
+    "make-dir" "^3.0.2"
+    "pkg-dir" "^4.1.0"
+
+"find-up@^4.0.0", "find-up@^4.1.0":
+  "integrity" "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw=="
+  "resolved" "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz"
+  "version" "4.1.0"
+  dependencies:
+    "locate-path" "^5.0.0"
+    "path-exists" "^4.0.0"
+
+"find-up@^5.0.0":
+  "integrity" "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="
+  "resolved" "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
+  "version" "5.0.0"
+  dependencies:
+    "locate-path" "^6.0.0"
+    "path-exists" "^4.0.0"
+
+"find-up@5.0.0":
+  "integrity" "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="
+  "resolved" "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
+  "version" "5.0.0"
+  dependencies:
+    "locate-path" "^6.0.0"
+    "path-exists" "^4.0.0"
+
+"flat-cache@^3.0.4":
+  "integrity" "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg=="
+  "resolved" "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz"
+  "version" "3.0.4"
+  dependencies:
+    "flatted" "^3.1.0"
+    "rimraf" "^3.0.2"
+
+"flat@^5.0.2":
+  "integrity" "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ=="
+  "resolved" "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz"
+  "version" "5.0.2"
+
+"flatted@^3.1.0":
+  "integrity" "sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg=="
+  "resolved" "https://registry.npmjs.org/flatted/-/flatted-3.2.5.tgz"
+  "version" "3.2.5"
+
+"foreground-child@^2.0.0":
+  "integrity" "sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA=="
+  "resolved" "https://registry.npmjs.org/foreground-child/-/foreground-child-2.0.0.tgz"
+  "version" "2.0.0"
+  dependencies:
+    "cross-spawn" "^7.0.0"
+    "signal-exit" "^3.0.2"
+
+"fromentries@^1.2.0":
+  "integrity" "sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg=="
+  "resolved" "https://registry.npmjs.org/fromentries/-/fromentries-1.3.2.tgz"
+  "version" "1.3.2"
+
+"fs-extra@^10.0.0":
+  "integrity" "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ=="
+  "resolved" "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz"
+  "version" "10.1.0"
+  dependencies:
+    "graceful-fs" "^4.2.0"
+    "jsonfile" "^6.0.1"
+    "universalify" "^2.0.0"
+
+"fs.realpath@^1.0.0":
+  "integrity" "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
+  "resolved" "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
+  "version" "1.0.0"
+
+"function-bind@^1.1.1":
+  "integrity" "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+  "resolved" "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz"
+  "version" "1.1.1"
+
+"functional-red-black-tree@^1.0.1":
+  "integrity" "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc="
+  "resolved" "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz"
+  "version" "1.0.1"
+
+"gensync@^1.0.0-beta.2":
+  "integrity" "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="
+  "resolved" "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz"
+  "version" "1.0.0-beta.2"
+
+"get-caller-file@^2.0.1", "get-caller-file@^2.0.5":
+  "integrity" "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="
+  "resolved" "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz"
+  "version" "2.0.5"
+
+"get-package-type@^0.1.0":
+  "integrity" "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q=="
+  "resolved" "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz"
+  "version" "0.1.0"
+
+"glob-parent@^5.1.2", "glob-parent@~5.1.2":
+  "integrity" "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="
+  "resolved" "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
+  "version" "5.1.2"
+  dependencies:
+    "is-glob" "^4.0.1"
+
+"glob-parent@^6.0.1":
+  "integrity" "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="
+  "resolved" "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz"
+  "version" "6.0.2"
+  dependencies:
+    "is-glob" "^4.0.3"
+
+"glob@^7.1.3", "glob@^7.1.4", "glob@^7.1.6", "glob@7.2.0":
+  "integrity" "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q=="
+  "resolved" "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz"
+  "version" "7.2.0"
+  dependencies:
+    "fs.realpath" "^1.0.0"
+    "inflight" "^1.0.4"
+    "inherits" "2"
+    "minimatch" "^3.0.4"
+    "once" "^1.3.0"
+    "path-is-absolute" "^1.0.0"
+
+"globals@^11.1.0":
+  "integrity" "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA=="
+  "resolved" "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz"
+  "version" "11.12.0"
+
+"globals@^13.6.0", "globals@^13.9.0":
+  "integrity" "sha512-EQ7Q18AJlPwp3vUDL4mKA0KXrXyNIQyWon6T6XQiBQF0XHvRsiCSrWmmeATpUzdJN2HhWZU6Pdl0a9zdep5p6A=="
+  "resolved" "https://registry.npmjs.org/globals/-/globals-13.13.0.tgz"
+  "version" "13.13.0"
+  dependencies:
+    "type-fest" "^0.20.2"
+
+"globby@^11.0.4":
+  "integrity" "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g=="
+  "resolved" "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz"
+  "version" "11.1.0"
+  dependencies:
+    "array-union" "^2.1.0"
+    "dir-glob" "^3.0.1"
+    "fast-glob" "^3.2.9"
+    "ignore" "^5.2.0"
+    "merge2" "^1.4.1"
+    "slash" "^3.0.0"
+
+"graceful-fs@^4.1.15", "graceful-fs@^4.1.6", "graceful-fs@^4.2.0":
+  "integrity" "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA=="
+  "resolved" "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz"
+  "version" "4.2.10"
+
+"has-flag@^3.0.0":
+  "integrity" "sha1-tdRU3CGZriJWmfNGfloH87lVuv0="
+  "resolved" "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz"
+  "version" "3.0.0"
+
+"has-flag@^4.0.0":
+  "integrity" "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="
+  "resolved" "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
+  "version" "4.0.0"
+
+"has@^1.0.3":
+  "integrity" "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw=="
+  "resolved" "https://registry.npmjs.org/has/-/has-1.0.3.tgz"
+  "version" "1.0.3"
+  dependencies:
+    "function-bind" "^1.1.1"
+
+"hasha@^5.0.0":
+  "integrity" "sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ=="
+  "resolved" "https://registry.npmjs.org/hasha/-/hasha-5.2.2.tgz"
+  "version" "5.2.2"
+  dependencies:
+    "is-stream" "^2.0.0"
+    "type-fest" "^0.8.0"
+
+"he@1.2.0":
+  "integrity" "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw=="
+  "resolved" "https://registry.npmjs.org/he/-/he-1.2.0.tgz"
+  "version" "1.2.0"
+
+"html-escaper@^2.0.0":
+  "integrity" "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg=="
+  "resolved" "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz"
+  "version" "2.0.2"
+
+"ignore@^5.1.8", "ignore@^5.2.0":
+  "integrity" "sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ=="
+  "resolved" "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz"
+  "version" "5.2.0"
+
+"import-fresh@^3.0.0", "import-fresh@^3.2.1":
+  "integrity" "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw=="
+  "resolved" "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
+  "version" "3.3.0"
+  dependencies:
+    "parent-module" "^1.0.0"
+    "resolve-from" "^4.0.0"
+
+"imurmurhash@^0.1.4":
+  "integrity" "sha1-khi5srkoojixPcT7a21XbyMUU+o="
+  "resolved" "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
+  "version" "0.1.4"
+
+"indent-string@^4.0.0":
+  "integrity" "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg=="
+  "resolved" "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz"
+  "version" "4.0.0"
+
+"inflight@^1.0.4":
+  "integrity" "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk="
+  "resolved" "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
+  "version" "1.0.6"
+  dependencies:
+    "once" "^1.3.0"
+    "wrappy" "1"
+
+"inherits@2":
+  "integrity" "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+  "resolved" "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
+  "version" "2.0.4"
+
+"is-binary-path@~2.1.0":
+  "integrity" "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw=="
+  "resolved" "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
+  "version" "2.1.0"
+  dependencies:
+    "binary-extensions" "^2.0.0"
+
+"is-core-module@^2.8.1":
+  "integrity" "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A=="
+  "resolved" "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz"
+  "version" "2.9.0"
+  dependencies:
+    "has" "^1.0.3"
+
+"is-extglob@^2.1.1":
+  "integrity" "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI="
+  "resolved" "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
+  "version" "2.1.1"
+
+"is-fullwidth-code-point@^3.0.0":
+  "integrity" "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="
+  "resolved" "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
+  "version" "3.0.0"
+
+"is-glob@^4.0.0", "is-glob@^4.0.1", "is-glob@^4.0.3", "is-glob@~4.0.1":
+  "integrity" "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="
+  "resolved" "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
+  "version" "4.0.3"
+  dependencies:
+    "is-extglob" "^2.1.1"
+
+"is-module@^1.0.0":
+  "integrity" "sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE="
+  "resolved" "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz"
+  "version" "1.0.0"
+
+"is-number@^7.0.0":
+  "integrity" "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="
+  "resolved" "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
+  "version" "7.0.0"
+
+"is-plain-obj@^2.1.0":
+  "integrity" "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA=="
+  "resolved" "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz"
+  "version" "2.1.0"
+
+"is-stream@^2.0.0":
+  "integrity" "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="
+  "resolved" "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz"
+  "version" "2.0.1"
+
+"is-typedarray@^1.0.0":
+  "integrity" "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo="
+  "resolved" "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz"
+  "version" "1.0.0"
+
+"is-unicode-supported@^0.1.0":
+  "integrity" "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw=="
+  "resolved" "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz"
+  "version" "0.1.0"
+
+"is-windows@^1.0.2":
+  "integrity" "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA=="
+  "resolved" "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz"
+  "version" "1.0.2"
+
+"isexe@^2.0.0":
+  "integrity" "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA="
+  "resolved" "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
+  "version" "2.0.0"
+
+"istanbul-lib-coverage@^3.0.0", "istanbul-lib-coverage@^3.0.0-alpha.1":
+  "integrity" "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw=="
+  "resolved" "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz"
+  "version" "3.2.0"
+
+"istanbul-lib-hook@^3.0.0":
+  "integrity" "sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ=="
+  "resolved" "https://registry.npmjs.org/istanbul-lib-hook/-/istanbul-lib-hook-3.0.0.tgz"
+  "version" "3.0.0"
+  dependencies:
+    "append-transform" "^2.0.0"
+
+"istanbul-lib-instrument@^4.0.0":
+  "integrity" "sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ=="
+  "resolved" "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz"
+  "version" "4.0.3"
+  dependencies:
+    "@babel/core" "^7.7.5"
+    "@istanbuljs/schema" "^0.1.2"
+    "istanbul-lib-coverage" "^3.0.0"
+    "semver" "^6.3.0"
+
+"istanbul-lib-processinfo@^2.0.2":
+  "integrity" "sha512-kOwpa7z9hme+IBPZMzQ5vdQj8srYgAtaRqeI48NGmAQ+/5yKiHLV0QbYqQpxsdEF0+w14SoB8YbnHKcXE2KnYw=="
+  "resolved" "https://registry.npmjs.org/istanbul-lib-processinfo/-/istanbul-lib-processinfo-2.0.2.tgz"
+  "version" "2.0.2"
+  dependencies:
+    "archy" "^1.0.0"
+    "cross-spawn" "^7.0.0"
+    "istanbul-lib-coverage" "^3.0.0-alpha.1"
+    "make-dir" "^3.0.0"
+    "p-map" "^3.0.0"
+    "rimraf" "^3.0.0"
+    "uuid" "^3.3.3"
+
+"istanbul-lib-report@^3.0.0":
+  "integrity" "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw=="
+  "resolved" "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz"
+  "version" "3.0.0"
+  dependencies:
+    "istanbul-lib-coverage" "^3.0.0"
+    "make-dir" "^3.0.0"
+    "supports-color" "^7.1.0"
+
+"istanbul-lib-source-maps@^4.0.0":
+  "integrity" "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw=="
+  "resolved" "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz"
+  "version" "4.0.1"
+  dependencies:
+    "debug" "^4.1.1"
+    "istanbul-lib-coverage" "^3.0.0"
+    "source-map" "^0.6.1"
+
+"istanbul-reports@^3.0.2":
+  "integrity" "sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw=="
+  "resolved" "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.4.tgz"
+  "version" "3.1.4"
+  dependencies:
+    "html-escaper" "^2.0.0"
+    "istanbul-lib-report" "^3.0.0"
+
+"js-tokens@^4.0.0":
+  "integrity" "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+  "resolved" "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
+  "version" "4.0.0"
+
+"js-yaml@^3.13.1":
+  "integrity" "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g=="
+  "resolved" "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz"
+  "version" "3.14.1"
+  dependencies:
+    "argparse" "^1.0.7"
+    "esprima" "^4.0.0"
+
+"js-yaml@^4.1.0", "js-yaml@4.1.0":
+  "integrity" "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="
+  "resolved" "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
+  "version" "4.1.0"
+  dependencies:
+    "argparse" "^2.0.1"
+
+"jsesc@^2.5.1":
+  "integrity" "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA=="
+  "resolved" "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz"
+  "version" "2.5.2"
+
+"json-schema-traverse@^0.4.1":
+  "integrity" "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
+  "resolved" "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
+  "version" "0.4.1"
+
+"json-stable-stringify-without-jsonify@^1.0.1":
+  "integrity" "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE="
+  "resolved" "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz"
+  "version" "1.0.1"
+
+"json5@^2.2.1":
+  "integrity" "sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA=="
+  "resolved" "https://registry.npmjs.org/json5/-/json5-2.2.1.tgz"
+  "version" "2.2.1"
+
+"jsonfile@^6.0.1":
+  "integrity" "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ=="
+  "resolved" "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz"
+  "version" "6.1.0"
+  dependencies:
+    "universalify" "^2.0.0"
+  optionalDependencies:
+    "graceful-fs" "^4.1.6"
+
+"levn@^0.4.1":
+  "integrity" "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="
+  "resolved" "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz"
+  "version" "0.4.1"
+  dependencies:
+    "prelude-ls" "^1.2.1"
+    "type-check" "~0.4.0"
+
+"locate-path@^5.0.0":
+  "integrity" "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g=="
+  "resolved" "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz"
+  "version" "5.0.0"
+  dependencies:
+    "p-locate" "^4.1.0"
+
+"locate-path@^6.0.0":
+  "integrity" "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="
+  "resolved" "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
+  "version" "6.0.0"
+  dependencies:
+    "p-locate" "^5.0.0"
+
+"lodash.flattendeep@^4.4.0":
+  "integrity" "sha1-+wMJF/hqMTTlvJvsDWngAT3f7bI="
+  "resolved" "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz"
+  "version" "4.4.0"
+
+"lodash.merge@^4.6.2":
+  "integrity" "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="
+  "resolved" "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz"
+  "version" "4.6.2"
+
+"log-symbols@4.1.0":
+  "integrity" "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg=="
+  "resolved" "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz"
+  "version" "4.1.0"
+  dependencies:
+    "chalk" "^4.1.0"
+    "is-unicode-supported" "^0.1.0"
+
+"lru-cache@^6.0.0":
+  "integrity" "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="
+  "resolved" "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
+  "version" "6.0.0"
+  dependencies:
+    "yallist" "^4.0.0"
+
+"magic-string@^0.26.1":
+  "integrity" "sha512-ndThHmvgtieXe8J/VGPjG+Apu7v7ItcD5mhEIvOscWjPF/ccOiLxHaSuCAS2G+3x4GKsAbT8u7zdyamupui8Tg=="
+  "resolved" "https://registry.npmjs.org/magic-string/-/magic-string-0.26.1.tgz"
+  "version" "0.26.1"
+  dependencies:
+    "sourcemap-codec" "^1.4.8"
+
+"make-dir@^3.0.0", "make-dir@^3.0.2":
+  "integrity" "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw=="
+  "resolved" "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz"
+  "version" "3.1.0"
+  dependencies:
+    "semver" "^6.0.0"
+
+"make-error@^1.1.1":
+  "integrity" "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw=="
+  "resolved" "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz"
+  "version" "1.3.6"
+
+"merge2@^1.3.0", "merge2@^1.4.1":
+  "integrity" "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="
+  "resolved" "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
+  "version" "1.4.1"
+
+"micromatch@^4.0.4":
+  "integrity" "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA=="
+  "resolved" "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz"
+  "version" "4.0.5"
+  dependencies:
+    "braces" "^3.0.2"
+    "picomatch" "^2.3.1"
+
+"minimatch@^3.0.4", "minimatch@^3.1.2":
+  "integrity" "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="
+  "resolved" "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
+  "version" "3.1.2"
+  dependencies:
+    "brace-expansion" "^1.1.7"
+
+"minimatch@5.0.1":
+  "integrity" "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g=="
+  "resolved" "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz"
+  "version" "5.0.1"
+  dependencies:
+    "brace-expansion" "^2.0.1"
+
+"mocha@^10.0.0":
+  "integrity" "sha512-0Wl+elVUD43Y0BqPZBzZt8Tnkw9CMUdNYnUsTfOM1vuhJVZL+kiesFYsqwBkEEuEixaiPe5ZQdqDgX2jddhmoA=="
+  "resolved" "https://registry.npmjs.org/mocha/-/mocha-10.0.0.tgz"
+  "version" "10.0.0"
+  dependencies:
+    "@ungap/promise-all-settled" "1.1.2"
+    "ansi-colors" "4.1.1"
+    "browser-stdout" "1.3.1"
+    "chokidar" "3.5.3"
+    "debug" "4.3.4"
+    "diff" "5.0.0"
+    "escape-string-regexp" "4.0.0"
+    "find-up" "5.0.0"
+    "glob" "7.2.0"
+    "he" "1.2.0"
+    "js-yaml" "4.1.0"
+    "log-symbols" "4.1.0"
+    "minimatch" "5.0.1"
+    "ms" "2.1.3"
+    "nanoid" "3.3.3"
+    "serialize-javascript" "6.0.0"
+    "strip-json-comments" "3.1.1"
+    "supports-color" "8.1.1"
+    "workerpool" "6.2.1"
+    "yargs" "16.2.0"
+    "yargs-parser" "20.2.4"
+    "yargs-unparser" "2.0.0"
+
+"ms@2.1.2":
+  "integrity" "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+  "resolved" "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz"
+  "version" "2.1.2"
+
+"ms@2.1.3":
+  "integrity" "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+  "resolved" "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
+  "version" "2.1.3"
+
+"nanoid@3.3.3":
+  "integrity" "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w=="
+  "resolved" "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz"
+  "version" "3.3.3"
+
+"natural-compare@^1.4.0":
+  "integrity" "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc="
+  "resolved" "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz"
+  "version" "1.4.0"
+
+"node-preload@^0.2.1":
+  "integrity" "sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ=="
+  "resolved" "https://registry.npmjs.org/node-preload/-/node-preload-0.2.1.tgz"
+  "version" "0.2.1"
+  dependencies:
+    "process-on-spawn" "^1.0.0"
+
+"node-releases@^2.0.3":
+  "integrity" "sha512-maHFz6OLqYxz+VQyCAtA3PTX4UP/53pa05fyDNc9CwjvJ0yEh6+xBwKsgCxMNhS8taUKBFYxfuiaD9U/55iFaw=="
+  "resolved" "https://registry.npmjs.org/node-releases/-/node-releases-2.0.3.tgz"
+  "version" "2.0.3"
+
+"normalize-path@^3.0.0", "normalize-path@~3.0.0":
+  "integrity" "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="
+  "resolved" "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
+  "version" "3.0.0"
+
+"nyc@^15.1.0":
+  "integrity" "sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A=="
+  "resolved" "https://registry.npmjs.org/nyc/-/nyc-15.1.0.tgz"
+  "version" "15.1.0"
+  dependencies:
+    "@istanbuljs/load-nyc-config" "^1.0.0"
+    "@istanbuljs/schema" "^0.1.2"
+    "caching-transform" "^4.0.0"
+    "convert-source-map" "^1.7.0"
+    "decamelize" "^1.2.0"
+    "find-cache-dir" "^3.2.0"
+    "find-up" "^4.1.0"
+    "foreground-child" "^2.0.0"
+    "get-package-type" "^0.1.0"
+    "glob" "^7.1.6"
+    "istanbul-lib-coverage" "^3.0.0"
+    "istanbul-lib-hook" "^3.0.0"
+    "istanbul-lib-instrument" "^4.0.0"
+    "istanbul-lib-processinfo" "^2.0.2"
+    "istanbul-lib-report" "^3.0.0"
+    "istanbul-lib-source-maps" "^4.0.0"
+    "istanbul-reports" "^3.0.2"
+    "make-dir" "^3.0.0"
+    "node-preload" "^0.2.1"
+    "p-map" "^3.0.0"
+    "process-on-spawn" "^1.0.0"
+    "resolve-from" "^5.0.0"
+    "rimraf" "^3.0.0"
+    "signal-exit" "^3.0.2"
+    "spawn-wrap" "^2.0.0"
+    "test-exclude" "^6.0.0"
+    "yargs" "^15.0.2"
+
+"once@^1.3.0":
+  "integrity" "sha1-WDsap3WWHUsROsF9nFC6753Xa9E="
+  "resolved" "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
+  "version" "1.4.0"
+  dependencies:
+    "wrappy" "1"
+
+"optionator@^0.9.1":
+  "integrity" "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw=="
+  "resolved" "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz"
+  "version" "0.9.1"
+  dependencies:
+    "deep-is" "^0.1.3"
+    "fast-levenshtein" "^2.0.6"
+    "levn" "^0.4.1"
+    "prelude-ls" "^1.2.1"
+    "type-check" "^0.4.0"
+    "word-wrap" "^1.2.3"
+
+"p-limit@^2.2.0":
+  "integrity" "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w=="
+  "resolved" "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz"
+  "version" "2.3.0"
+  dependencies:
+    "p-try" "^2.0.0"
+
+"p-limit@^3.0.2":
+  "integrity" "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="
+  "resolved" "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
+  "version" "3.1.0"
+  dependencies:
+    "yocto-queue" "^0.1.0"
+
+"p-locate@^4.1.0":
+  "integrity" "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A=="
+  "resolved" "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz"
+  "version" "4.1.0"
+  dependencies:
+    "p-limit" "^2.2.0"
+
+"p-locate@^5.0.0":
+  "integrity" "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="
+  "resolved" "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
+  "version" "5.0.0"
+  dependencies:
+    "p-limit" "^3.0.2"
+
+"p-map@^3.0.0":
+  "integrity" "sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ=="
+  "resolved" "https://registry.npmjs.org/p-map/-/p-map-3.0.0.tgz"
+  "version" "3.0.0"
+  dependencies:
+    "aggregate-error" "^3.0.0"
+
+"p-try@^2.0.0":
+  "integrity" "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ=="
+  "resolved" "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz"
+  "version" "2.2.0"
+
+"package-hash@^4.0.0":
+  "integrity" "sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ=="
+  "resolved" "https://registry.npmjs.org/package-hash/-/package-hash-4.0.0.tgz"
+  "version" "4.0.0"
+  dependencies:
+    "graceful-fs" "^4.1.15"
+    "hasha" "^5.0.0"
+    "lodash.flattendeep" "^4.4.0"
+    "release-zalgo" "^1.0.0"
+
+"parent-module@^1.0.0":
+  "integrity" "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="
+  "resolved" "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
+  "version" "1.0.1"
+  dependencies:
+    "callsites" "^3.0.0"
+
+"path-exists@^4.0.0":
+  "integrity" "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="
+  "resolved" "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
+  "version" "4.0.0"
+
+"path-is-absolute@^1.0.0":
+  "integrity" "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
+  "resolved" "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
+  "version" "1.0.1"
+
+"path-is-network-drive@^1.0.13":
+  "integrity" "sha512-Hg74mRN6mmXV+gTm3INjFK40ncAmC/Lo4qoQaSZ+GT3hZzlKdWQSqAjqyPeW0SvObP2W073WyYEBWY9d3wOm3A=="
+  "resolved" "https://registry.npmjs.org/path-is-network-drive/-/path-is-network-drive-1.0.13.tgz"
+  "version" "1.0.13"
+  dependencies:
+    "tslib" "^2.3.1"
+
+"path-key@^3.1.0":
+  "integrity" "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="
+  "resolved" "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
+  "version" "3.1.1"
+
+"path-parse@^1.0.7":
+  "integrity" "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
+  "resolved" "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
+  "version" "1.0.7"
+
+"path-strip-sep@^1.0.10":
+  "integrity" "sha512-JpCy+8LAJQQTO1bQsb/84s1g+/Stm3h39aOpPRBQ/paMUGVPPZChLTOTKHoaCkc/6sKuF7yVsnq5Pe1S6xQGcA=="
+  "resolved" "https://registry.npmjs.org/path-strip-sep/-/path-strip-sep-1.0.10.tgz"
+  "version" "1.0.10"
+  dependencies:
+    "tslib" "^2.3.1"
+
+"path-type@^4.0.0":
+  "integrity" "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="
+  "resolved" "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
+  "version" "4.0.0"
+
+"picocolors@^1.0.0":
+  "integrity" "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ=="
+  "resolved" "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz"
+  "version" "1.0.0"
+
+"picomatch@^2.0.4", "picomatch@^2.2.1", "picomatch@^2.2.2", "picomatch@^2.3.1":
+  "integrity" "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="
+  "resolved" "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
+  "version" "2.3.1"
+
+"pkg-dir@^4.1.0":
+  "integrity" "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ=="
+  "resolved" "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz"
+  "version" "4.2.0"
+  dependencies:
+    "find-up" "^4.0.0"
+
+"pkg-dir@< 6 >= 5":
+  "integrity" "sha512-NPE8TDbzl/3YQYY7CSS228s3g2ollTFnc+Qi3tqmqJp9Vg2ovUpixcJEo2HJScN2Ez+kEaal6y70c0ehqJBJeA=="
+  "resolved" "https://registry.npmjs.org/pkg-dir/-/pkg-dir-5.0.0.tgz"
+  "version" "5.0.0"
+  dependencies:
+    "find-up" "^5.0.0"
+
+"prelude-ls@^1.2.1":
+  "integrity" "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="
+  "resolved" "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz"
+  "version" "1.2.1"
+
+"process-on-spawn@^1.0.0":
+  "integrity" "sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg=="
+  "resolved" "https://registry.npmjs.org/process-on-spawn/-/process-on-spawn-1.0.0.tgz"
+  "version" "1.0.0"
+  dependencies:
+    "fromentries" "^1.2.0"
+
+"punycode@^2.1.0":
+  "integrity" "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A=="
+  "resolved" "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz"
+  "version" "2.1.1"
+
+"pvtsutils@^1.3.2":
+  "integrity" "sha512-+Ipe2iNUyrZz+8K/2IOo+kKikdtfhRKzNpQbruF2URmqPtoqAs8g3xS7TJvFF2GcPXjh7DkqMnpVveRFq4PgEQ=="
+  "resolved" "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.2.tgz"
+  "version" "1.3.2"
+  dependencies:
+    "tslib" "^2.4.0"
+
+"pvutils@^1.1.3":
+  "integrity" "sha512-pMpnA0qRdFp32b1sJl1wOJNxZLQ2cbQx+k6tjNtZ8CpvVhNqEPRgivZ2WOUev2YMajecdH7ctUPDvEe87nariQ=="
+  "resolved" "https://registry.npmjs.org/pvutils/-/pvutils-1.1.3.tgz"
+  "version" "1.1.3"
+
+"queue-microtask@^1.2.2":
+  "integrity" "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="
+  "resolved" "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz"
+  "version" "1.2.3"
+
+"randombytes@^2.1.0":
+  "integrity" "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ=="
+  "resolved" "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz"
+  "version" "2.1.0"
+  dependencies:
+    "safe-buffer" "^5.1.0"
+
+"readdirp@~3.6.0":
+  "integrity" "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA=="
+  "resolved" "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
+  "version" "3.6.0"
+  dependencies:
+    "picomatch" "^2.2.1"
+
+"regexpp@^3.2.0":
+  "integrity" "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg=="
+  "resolved" "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz"
+  "version" "3.2.0"
+
+"release-zalgo@^1.0.0":
+  "integrity" "sha1-CXALflB0Mpc5Mw5TXFqQ+2eFFzA="
+  "resolved" "https://registry.npmjs.org/release-zalgo/-/release-zalgo-1.0.0.tgz"
+  "version" "1.0.0"
+  dependencies:
+    "es6-error" "^4.0.1"
+
+"require-directory@^2.1.1":
+  "integrity" "sha1-jGStX9MNqxyXbiNE/+f3kqam30I="
+  "resolved" "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz"
+  "version" "2.1.1"
+
+"require-main-filename@^2.0.0":
+  "integrity" "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg=="
+  "resolved" "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz"
+  "version" "2.0.0"
+
+"resolve-from@^4.0.0":
+  "integrity" "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="
+  "resolved" "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
+  "version" "4.0.0"
+
+"resolve-from@^5.0.0":
+  "integrity" "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw=="
+  "resolved" "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz"
+  "version" "5.0.0"
+
+"resolve@^1.11.1", "resolve@^1.20.0":
+  "integrity" "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw=="
+  "resolved" "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz"
+  "version" "1.22.0"
+  dependencies:
+    "is-core-module" "^2.8.1"
+    "path-parse" "^1.0.7"
+    "supports-preserve-symlinks-flag" "^1.0.0"
+
+"reusify@^1.0.4":
+  "integrity" "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw=="
+  "resolved" "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
+  "version" "1.0.4"
+
+"rimraf@^3.0.0", "rimraf@^3.0.2":
+  "integrity" "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA=="
+  "resolved" "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
+  "version" "3.0.2"
+  dependencies:
+    "glob" "^7.1.3"
+
+"rollup-plugin-dts@^4.2.1":
+  "integrity" "sha512-eaxQZNUJ5iQcxNGlpJ1CUgG4OSVqWjDZ3nNSWBIoGrpcote2aNphSe1RJOaSYkb8dwn3o+rYm1vvld/5z3EGSQ=="
+  "resolved" "https://registry.npmjs.org/rollup-plugin-dts/-/rollup-plugin-dts-4.2.1.tgz"
+  "version" "4.2.1"
+  dependencies:
+    "magic-string" "^0.26.1"
+  optionalDependencies:
+    "@babel/code-frame" "^7.16.7"
+
+"rollup-plugin-node-resolve@^5.2.0":
+  "integrity" "sha512-jUlyaDXts7TW2CqQ4GaO5VJ4PwwaV8VUGA7+km3n6k6xtOEacf61u0VXwN80phY/evMcaS+9eIeJ9MOyDxt5Zw=="
+  "resolved" "https://registry.npmjs.org/rollup-plugin-node-resolve/-/rollup-plugin-node-resolve-5.2.0.tgz"
+  "version" "5.2.0"
+  dependencies:
+    "@types/resolve" "0.0.8"
+    "builtin-modules" "^3.1.0"
+    "is-module" "^1.0.0"
+    "resolve" "^1.11.1"
+    "rollup-pluginutils" "^2.8.1"
+
+"rollup-plugin-typescript2@^0.31.2":
+  "integrity" "sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q=="
+  "resolved" "https://registry.npmjs.org/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.31.2.tgz"
+  "version" "0.31.2"
+  dependencies:
+    "@rollup/pluginutils" "^4.1.2"
+    "@yarn-tool/resolve-package" "^1.0.40"
+    "find-cache-dir" "^3.3.2"
+    "fs-extra" "^10.0.0"
+    "resolve" "^1.20.0"
+    "tslib" "^2.3.1"
+
+"rollup-pluginutils@^2.8.1":
+  "integrity" "sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ=="
+  "resolved" "https://registry.npmjs.org/rollup-pluginutils/-/rollup-pluginutils-2.8.2.tgz"
+  "version" "2.8.2"
+  dependencies:
+    "estree-walker" "^0.6.1"
+
+"rollup@^2.70", "rollup@^2.72.1", "rollup@>=1.11.0", "rollup@>=1.26.3":
+  "integrity" "sha512-NTc5UGy/NWFGpSqF1lFY8z9Adri6uhyMLI6LvPAXdBKoPRFhIIiBUpt+Qg2awixqO3xvzSijjhnb4+QEZwJmxA=="
+  "resolved" "https://registry.npmjs.org/rollup/-/rollup-2.72.1.tgz"
+  "version" "2.72.1"
+  optionalDependencies:
+    "fsevents" "~2.3.2"
+
+"run-parallel@^1.1.9":
+  "integrity" "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="
+  "resolved" "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
+  "version" "1.2.0"
+  dependencies:
+    "queue-microtask" "^1.2.2"
+
+"safe-buffer@^5.1.0":
+  "integrity" "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
+  "resolved" "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
+  "version" "5.2.1"
+
+"safe-buffer@~5.1.1":
+  "integrity" "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+  "resolved" "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
+  "version" "5.1.2"
+
+"semver@^6.0.0", "semver@^6.3.0":
+  "integrity" "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw=="
+  "resolved" "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz"
+  "version" "6.3.0"
+
+"semver@^7.3.5":
+  "integrity" "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g=="
+  "resolved" "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz"
+  "version" "7.3.7"
+  dependencies:
+    "lru-cache" "^6.0.0"
+
+"serialize-javascript@6.0.0":
+  "integrity" "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag=="
+  "resolved" "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz"
+  "version" "6.0.0"
+  dependencies:
+    "randombytes" "^2.1.0"
+
+"set-blocking@^2.0.0":
+  "integrity" "sha1-BF+XgtARrppoA93TgrJDkrPYkPc="
+  "resolved" "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz"
+  "version" "2.0.0"
+
+"shebang-command@^2.0.0":
+  "integrity" "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="
+  "resolved" "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
+  "version" "2.0.0"
+  dependencies:
+    "shebang-regex" "^3.0.0"
+
+"shebang-regex@^3.0.0":
+  "integrity" "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="
+  "resolved" "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
+  "version" "3.0.0"
+
+"signal-exit@^3.0.2":
+  "integrity" "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="
+  "resolved" "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz"
+  "version" "3.0.7"
+
+"slash@^3.0.0":
+  "integrity" "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="
+  "resolved" "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
+  "version" "3.0.0"
+
+"source-map@^0.5.0":
+  "integrity" "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w="
+  "resolved" "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz"
+  "version" "0.5.7"
+
+"source-map@^0.6.1":
+  "integrity" "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="
+  "resolved" "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
+  "version" "0.6.1"
+
+"sourcemap-codec@^1.4.8":
+  "integrity" "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA=="
+  "resolved" "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz"
+  "version" "1.4.8"
+
+"spawn-wrap@^2.0.0":
+  "integrity" "sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg=="
+  "resolved" "https://registry.npmjs.org/spawn-wrap/-/spawn-wrap-2.0.0.tgz"
+  "version" "2.0.0"
+  dependencies:
+    "foreground-child" "^2.0.0"
+    "is-windows" "^1.0.2"
+    "make-dir" "^3.0.0"
+    "rimraf" "^3.0.0"
+    "signal-exit" "^3.0.2"
+    "which" "^2.0.1"
+
+"sprintf-js@~1.0.2":
+  "integrity" "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw="
+  "resolved" "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz"
+  "version" "1.0.3"
+
+"string-width@^4.1.0", "string-width@^4.2.0":
+  "integrity" "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="
+  "resolved" "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  "version" "4.2.3"
+  dependencies:
+    "emoji-regex" "^8.0.0"
+    "is-fullwidth-code-point" "^3.0.0"
+    "strip-ansi" "^6.0.1"
+
+"strip-ansi@^6.0.0", "strip-ansi@^6.0.1":
+  "integrity" "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="
+  "resolved" "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  "version" "6.0.1"
+  dependencies:
+    "ansi-regex" "^5.0.1"
+
+"strip-bom@^4.0.0":
+  "integrity" "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w=="
+  "resolved" "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz"
+  "version" "4.0.0"
+
+"strip-json-comments@^3.1.0", "strip-json-comments@^3.1.1", "strip-json-comments@3.1.1":
+  "integrity" "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="
+  "resolved" "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
+  "version" "3.1.1"
+
+"supports-color@^5.3.0":
+  "integrity" "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow=="
+  "resolved" "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz"
+  "version" "5.5.0"
+  dependencies:
+    "has-flag" "^3.0.0"
+
+"supports-color@^7.1.0":
+  "integrity" "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="
+  "resolved" "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
+  "version" "7.2.0"
+  dependencies:
+    "has-flag" "^4.0.0"
+
+"supports-color@8.1.1":
+  "integrity" "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="
+  "resolved" "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz"
+  "version" "8.1.1"
+  dependencies:
+    "has-flag" "^4.0.0"
+
+"supports-preserve-symlinks-flag@^1.0.0":
+  "integrity" "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="
+  "resolved" "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
+  "version" "1.0.0"
+
+"test-exclude@^6.0.0":
+  "integrity" "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w=="
+  "resolved" "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz"
+  "version" "6.0.0"
+  dependencies:
+    "@istanbuljs/schema" "^0.1.2"
+    "glob" "^7.1.4"
+    "minimatch" "^3.0.4"
+
+"text-table@^0.2.0":
+  "integrity" "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ="
+  "resolved" "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz"
+  "version" "0.2.0"
+
+"to-fast-properties@^2.0.0":
+  "integrity" "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4="
+  "resolved" "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz"
+  "version" "2.0.0"
+
+"to-regex-range@^5.0.1":
+  "integrity" "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="
+  "resolved" "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
+  "version" "5.0.1"
+  dependencies:
+    "is-number" "^7.0.0"
+
+"ts-node@^10.7.0":
+  "integrity" "sha512-TbIGS4xgJoX2i3do417KSaep1uRAW/Lu+WAL2doDHC0D6ummjirVOXU5/7aiZotbQ5p1Zp9tP7U6cYhA0O7M8A=="
+  "resolved" "https://registry.npmjs.org/ts-node/-/ts-node-10.7.0.tgz"
+  "version" "10.7.0"
+  dependencies:
+    "@cspotcode/source-map-support" "0.7.0"
+    "@tsconfig/node10" "^1.0.7"
+    "@tsconfig/node12" "^1.0.7"
+    "@tsconfig/node14" "^1.0.0"
+    "@tsconfig/node16" "^1.0.2"
+    "acorn" "^8.4.1"
+    "acorn-walk" "^8.1.1"
+    "arg" "^4.1.0"
+    "create-require" "^1.1.0"
+    "diff" "^4.0.1"
+    "make-error" "^1.1.1"
+    "v8-compile-cache-lib" "^3.0.0"
+    "yn" "3.1.1"
+
+"tslib@^1.8.1":
+  "integrity" "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="
+  "resolved" "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz"
+  "version" "1.14.1"
+
+"tslib@^2.3.1", "tslib@^2.4.0":
+  "integrity" "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ=="
+  "resolved" "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz"
+  "version" "2.4.0"
+
+"tsutils@^3.21.0":
+  "integrity" "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA=="
+  "resolved" "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz"
+  "version" "3.21.0"
+  dependencies:
+    "tslib" "^1.8.1"
+
+"type-check@^0.4.0", "type-check@~0.4.0":
+  "integrity" "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="
+  "resolved" "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz"
+  "version" "0.4.0"
+  dependencies:
+    "prelude-ls" "^1.2.1"
+
+"type-fest@^0.20.2":
+  "integrity" "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ=="
+  "resolved" "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz"
+  "version" "0.20.2"
+
+"type-fest@^0.8.0":
+  "integrity" "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA=="
+  "resolved" "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz"
+  "version" "0.8.1"
+
+"typedarray-to-buffer@^3.1.5":
+  "integrity" "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q=="
+  "resolved" "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz"
+  "version" "3.1.5"
+  dependencies:
+    "is-typedarray" "^1.0.0"
+
+"typescript@^3.7.5 || ^4.0.0", "typescript@^4.6", "typescript@^4.6.4", "typescript@>=2.4.0", "typescript@>=2.7", "typescript@>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta":
+  "integrity" "sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg=="
+  "resolved" "https://registry.npmjs.org/typescript/-/typescript-4.6.4.tgz"
+  "version" "4.6.4"
+
+"universalify@^2.0.0":
+  "integrity" "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ=="
+  "resolved" "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz"
+  "version" "2.0.0"
+
+"upath2@^3.1.12":
+  "integrity" "sha512-yC3eZeCyCXFWjy7Nu4pgjLhXNYjuzuUmJiRgSSw6TJp8Emc+E4951HGPJf+bldFC5SL7oBLeNbtm1fGzXn2gxw=="
+  "resolved" "https://registry.npmjs.org/upath2/-/upath2-3.1.12.tgz"
+  "version" "3.1.12"
+  dependencies:
+    "path-is-network-drive" "^1.0.13"
+    "path-strip-sep" "^1.0.10"
+    "tslib" "^2.3.1"
+
+"uri-js@^4.2.2":
+  "integrity" "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="
+  "resolved" "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
+  "version" "4.4.1"
+  dependencies:
+    "punycode" "^2.1.0"
+
+"uuid@^3.3.3":
+  "integrity" "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A=="
+  "resolved" "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz"
+  "version" "3.4.0"
+
+"v8-compile-cache-lib@^3.0.0":
+  "integrity" "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg=="
+  "resolved" "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz"
+  "version" "3.0.1"
+
+"v8-compile-cache@^2.0.3":
+  "integrity" "sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA=="
+  "resolved" "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz"
+  "version" "2.3.0"
+
+"which-module@^2.0.0":
+  "integrity" "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho="
+  "resolved" "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz"
+  "version" "2.0.0"
+
+"which@^2.0.1":
+  "integrity" "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="
+  "resolved" "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
+  "version" "2.0.2"
+  dependencies:
+    "isexe" "^2.0.0"
+
+"word-wrap@^1.2.3":
+  "integrity" "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ=="
+  "resolved" "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz"
+  "version" "1.2.3"
+
+"workerpool@6.2.1":
+  "integrity" "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw=="
+  "resolved" "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz"
+  "version" "6.2.1"
+
+"wrap-ansi@^6.2.0":
+  "integrity" "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="
+  "resolved" "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz"
+  "version" "6.2.0"
+  dependencies:
+    "ansi-styles" "^4.0.0"
+    "string-width" "^4.1.0"
+    "strip-ansi" "^6.0.0"
+
+"wrap-ansi@^7.0.0":
+  "integrity" "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="
+  "resolved" "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
+  "version" "7.0.0"
+  dependencies:
+    "ansi-styles" "^4.0.0"
+    "string-width" "^4.1.0"
+    "strip-ansi" "^6.0.0"
+
+"wrappy@1":
+  "integrity" "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+  "resolved" "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
+  "version" "1.0.2"
+
+"write-file-atomic@^3.0.0":
+  "integrity" "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q=="
+  "resolved" "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz"
+  "version" "3.0.3"
+  dependencies:
+    "imurmurhash" "^0.1.4"
+    "is-typedarray" "^1.0.0"
+    "signal-exit" "^3.0.2"
+    "typedarray-to-buffer" "^3.1.5"
+
+"y18n@^4.0.0":
+  "integrity" "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="
+  "resolved" "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz"
+  "version" "4.0.3"
+
+"y18n@^5.0.5":
+  "integrity" "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="
+  "resolved" "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz"
+  "version" "5.0.8"
+
+"yallist@^4.0.0":
+  "integrity" "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+  "resolved" "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
+  "version" "4.0.0"
+
+"yargs-parser@^18.1.2":
+  "integrity" "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ=="
+  "resolved" "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz"
+  "version" "18.1.3"
+  dependencies:
+    "camelcase" "^5.0.0"
+    "decamelize" "^1.2.0"
+
+"yargs-parser@^20.2.2":
+  "integrity" "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w=="
+  "resolved" "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz"
+  "version" "20.2.9"
+
+"yargs-parser@20.2.4":
+  "integrity" "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA=="
+  "resolved" "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz"
+  "version" "20.2.4"
+
+"yargs-unparser@2.0.0":
+  "integrity" "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA=="
+  "resolved" "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz"
+  "version" "2.0.0"
+  dependencies:
+    "camelcase" "^6.0.0"
+    "decamelize" "^4.0.0"
+    "flat" "^5.0.2"
+    "is-plain-obj" "^2.1.0"
+
+"yargs@^15.0.2":
+  "integrity" "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A=="
+  "resolved" "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz"
+  "version" "15.4.1"
+  dependencies:
+    "cliui" "^6.0.0"
+    "decamelize" "^1.2.0"
+    "find-up" "^4.1.0"
+    "get-caller-file" "^2.0.1"
+    "require-directory" "^2.1.1"
+    "require-main-filename" "^2.0.0"
+    "set-blocking" "^2.0.0"
+    "string-width" "^4.2.0"
+    "which-module" "^2.0.0"
+    "y18n" "^4.0.0"
+    "yargs-parser" "^18.1.2"
+
+"yargs@16.2.0":
+  "integrity" "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw=="
+  "resolved" "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz"
+  "version" "16.2.0"
+  dependencies:
+    "cliui" "^7.0.2"
+    "escalade" "^3.1.1"
+    "get-caller-file" "^2.0.5"
+    "require-directory" "^2.1.1"
+    "string-width" "^4.2.0"
+    "y18n" "^5.0.5"
+    "yargs-parser" "^20.2.2"
+
+"yn@3.1.1":
+  "integrity" "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q=="
+  "resolved" "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz"
+  "version" "3.1.1"
+
+"yocto-queue@^0.1.0":
+  "integrity" "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="
+  "resolved" "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
+  "version" "0.1.0"