node-opcua-crypto 4.16.0 → 4.16.1

package/dist/index.js

@@ -2209,7 +2209,7 @@ var BufferSourceConverter = class _BufferSourceConverter {
   }
 };
 var STRING_TYPE = "string";
-var HEX_REGEX = /^[0-9a-f]+$/i;
+var HEX_REGEX = /^[0-9a-f\s]+$/i;
 var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 var BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
 var Utf8Converter = class {
@@ -2657,19 +2657,19 @@ var BIT_STRING_NAME = "BIT STRING";
 function HexBlock(BaseClass) {
   var _a2;
   return _a2 = class Some extends BaseClass {
-    constructor(...args) {
-      var _a3;
-      super(...args);
-      const params = args[0] || {};
-      this.isHexOnly = (_a3 = params.isHexOnly) !== null && _a3 !== void 0 ? _a3 : false;
-      this.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
-    }
     get valueHex() {
       return this.valueHexView.slice().buffer;
     }
     set valueHex(value) {
       this.valueHexView = new Uint8Array(value);
     }
+    constructor(...args) {
+      var _b;
+      super(...args);
+      const params = args[0] || {};
+      this.isHexOnly = (_b = params.isHexOnly) !== null && _b !== void 0 ? _b : false;
+      this.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
+    }
     fromBER(inputBuffer, inputOffset, inputLength) {
       const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
       if (!checkBufferParams(this, view, inputOffset, inputLength)) {
@@ -2704,12 +2704,6 @@ function HexBlock(BaseClass) {
   }, _a2.NAME = "hexBlock", _a2;
 }
 var LocalBaseBlock = class {
-  constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW } = {}) {
-    this.blockLength = blockLength;
-    this.error = error;
-    this.warnings = warnings;
-    this.valueBeforeDecodeView = BufferSourceConverter.toUint8Array(valueBeforeDecode);
-  }
   static blockName() {
     return this.NAME;
   }
@@ -2719,6 +2713,12 @@ var LocalBaseBlock = class {
   set valueBeforeDecode(value) {
     this.valueBeforeDecodeView = new Uint8Array(value);
   }
+  constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW } = {}) {
+    this.blockLength = blockLength;
+    this.error = error;
+    this.warnings = warnings;
+    this.valueBeforeDecodeView = BufferSourceConverter.toUint8Array(valueBeforeDecode);
+  }
   toJSON() {
     return {
       blockName: this.constructor.NAME,
@@ -2731,10 +2731,10 @@ var LocalBaseBlock = class {
 };
 LocalBaseBlock.NAME = "baseBlock";
 var ValueBlock = class extends LocalBaseBlock {
-  fromBER(inputBuffer, inputOffset, inputLength) {
+  fromBER(_inputBuffer, _inputOffset, _inputLength) {
     throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
   }
-  toBER(sizeOnly, writer) {
+  toBER(_sizeOnly, _writer) {
     throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
   }
 };
@@ -3075,7 +3075,9 @@ var BaseBlock = class extends LocalBaseBlock {
     return Convert.ToHex(this.toBER());
   }
   onAsciiEncoding() {
-    return `${this.constructor.NAME} : ${Convert.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
+    const name = this.constructor.NAME;
+    const value = Convert.ToHex(this.valueBlock.valueBeforeDecodeView);
+    return `${name} : ${value}`;
   }
   isEqual(other) {
     if (this === other) {
@@ -3091,6 +3093,7 @@ var BaseBlock = class extends LocalBaseBlock {
 };
 BaseBlock.NAME = "BaseBlock";
 function prepareIndefiniteForm(baseBlock) {
+  var _a2;
   if (baseBlock instanceof typeStore.Constructed) {
     for (const value of baseBlock.valueBlock.value) {
       if (prepareIndefiniteForm(value)) {
@@ -3098,21 +3101,21 @@ function prepareIndefiniteForm(baseBlock) {
       }
     }
   }
-  return !!baseBlock.lenBlock.isIndefiniteForm;
+  return !!((_a2 = baseBlock.lenBlock) === null || _a2 === void 0 ? void 0 : _a2.isIndefiniteForm);
 }
 var BaseStringBlock = class extends BaseBlock {
-  constructor({ value = EMPTY_STRING, ...parameters } = {}, stringValueBlockType) {
-    super(parameters, stringValueBlockType);
-    if (value) {
-      this.fromString(value);
-    }
-  }
   getValue() {
     return this.valueBlock.value;
   }
   setValue(value) {
     this.valueBlock.value = value;
   }
+  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) {
@@ -3471,10 +3474,10 @@ _a$v = Constructed;
 })();
 Constructed.NAME = "CONSTRUCTED";
 var LocalEndOfContentValueBlock = class extends ValueBlock {
-  fromBER(inputBuffer, inputOffset, inputLength) {
+  fromBER(inputBuffer, inputOffset, _inputLength) {
     return inputOffset;
   }
-  toBER(sizeOnly) {
+  toBER(_sizeOnly) {
     return EMPTY_BUFFER;
   }
 };
@@ -3535,17 +3538,6 @@ _a$t = Null;
 })();
 Null.NAME = "NULL";
 var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
-  constructor({ value, ...parameters } = {}) {
-    super(parameters);
-    if (parameters.valueHex) {
-      this.valueHexView = BufferSourceConverter.toUint8Array(parameters.valueHex);
-    } else {
-      this.valueHexView = new Uint8Array(1);
-    }
-    if (value) {
-      this.value = value;
-    }
-  }
   get value() {
     for (const octet of this.valueHexView) {
       if (octet > 0) {
@@ -3557,6 +3549,17 @@ var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
   set value(value) {
     this.valueHexView[0] = value ? 255 : 0;
   }
+  constructor({ value, ...parameters } = {}) {
+    super(parameters);
+    if (parameters.valueHex) {
+      this.valueHexView = BufferSourceConverter.toUint8Array(parameters.valueHex);
+    } else {
+      this.valueHexView = new Uint8Array(1);
+    }
+    if (value) {
+      this.value = value;
+    }
+  }
   fromBER(inputBuffer, inputOffset, inputLength) {
     const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
     if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
@@ -3583,17 +3586,17 @@ var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
 LocalBooleanValueBlock.NAME = "BooleanValueBlock";
 var _a$s;
 var Boolean = class extends BaseBlock {
-  constructor(parameters = {}) {
-    super(parameters, LocalBooleanValueBlock);
-    this.idBlock.tagClass = 1;
-    this.idBlock.tagNumber = 1;
-  }
   getValue() {
     return this.valueBlock.value;
   }
   setValue(value) {
     this.valueBlock.value = value;
   }
+  constructor(parameters = {}) {
+    super(parameters, LocalBooleanValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 1;
+  }
   onAsciiEncoding() {
     return `${this.constructor.NAME} : ${this.getValue}`;
   }
@@ -3651,7 +3654,7 @@ var LocalOctetStringValueBlock = class extends HexBlock(LocalConstructedValueBlo
 };
 LocalOctetStringValueBlock.NAME = "OctetStringValueBlock";
 var _a$r;
-var OctetString = class _OctetString extends BaseBlock {
+var OctetString = class extends BaseBlock {
   constructor({ idBlock = {}, lenBlock = {}, ...parameters } = {}) {
     var _b, _c;
     (_b = parameters.isConstructed) !== null && _b !== void 0 ? _b : parameters.isConstructed = !!((_c = parameters.value) === null || _c === void 0 ? void 0 : _c.length);
@@ -3689,7 +3692,7 @@ var OctetString = class _OctetString extends BaseBlock {
             this.valueBlock.value = [asn.result];
           }
         }
-      } catch (e) {
+      } catch {
       }
     }
     return super.fromBER(inputBuffer, inputOffset, inputLength);
@@ -3698,7 +3701,9 @@ var OctetString = class _OctetString extends BaseBlock {
     if (this.valueBlock.isConstructed || this.valueBlock.value && this.valueBlock.value.length) {
       return Constructed.prototype.onAsciiEncoding.call(this);
     }
-    return `${this.constructor.NAME} : ${Convert.ToHex(this.valueBlock.valueHexView)}`;
+    const name = this.constructor.NAME;
+    const value = Convert.ToHex(this.valueBlock.valueHexView);
+    return `${name} : ${value}`;
   }
   getValue() {
     if (!this.idBlock.isConstructed) {
@@ -3706,7 +3711,7 @@ var OctetString = class _OctetString extends BaseBlock {
     }
     const array = [];
     for (const content of this.valueBlock.value) {
-      if (content instanceof _OctetString) {
+      if (content instanceof _a$r) {
         array.push(content.valueBlock.valueHexView);
       }
     }
@@ -3776,7 +3781,7 @@ var LocalBitStringValueBlock = class extends HexBlock(LocalConstructedValueBlock
             this.value = [asn.result];
           }
         }
-      } catch (e) {
+      } catch {
       }
     }
     this.valueHexView = intBuffer.subarray(1);
@@ -3791,7 +3796,9 @@ var LocalBitStringValueBlock = class extends HexBlock(LocalConstructedValueBlock
       return new ArrayBuffer(this.valueHexView.byteLength + 1);
     }
     if (!this.valueHexView.byteLength) {
-      return EMPTY_BUFFER;
+      const empty = new Uint8Array(1);
+      empty[0] = 0;
+      return empty.buffer;
     }
     const retView = new Uint8Array(this.valueHexView.length + 1);
     retView[0] = this.unusedBits;
@@ -3841,7 +3848,9 @@ var BitString = class extends BaseBlock {
         bits.push(byte.toString(2).padStart(8, "0"));
       }
       const bitsStr = bits.join("");
-      return `${this.constructor.NAME} : ${bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits)}`;
+      const name = this.constructor.NAME;
+      const value = bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits);
+      return `${name} : ${value}`;
     }
   }
 };
@@ -3938,16 +3947,6 @@ function viewSub(first, second) {
   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");
@@ -3960,6 +3959,16 @@ 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;
+    }
+  }
   set valueDec(v) {
     this._valueDec = v;
     this.isHexOnly = false;
@@ -4072,7 +4081,7 @@ LocalIntegerValueBlock.NAME = "IntegerValueBlock";
   });
 })();
 var _a$o;
-var Integer = class _Integer extends BaseBlock {
+var Integer = class extends BaseBlock {
   constructor(parameters = {}) {
     super(parameters, LocalIntegerValueBlock);
     this.idBlock.tagClass = 1;
@@ -4102,18 +4111,16 @@ var Integer = class _Integer extends BaseBlock {
       }
       writer.write(view);
     }
-    const res = new _Integer({
-      valueHex: writer.final()
-    });
+    const res = new _a$o({ valueHex: writer.final() });
     return res;
   }
   convertToDER() {
-    const integer = new _Integer({ valueHex: this.valueBlock.valueHexView });
+    const integer = new _a$o({ valueHex: this.valueBlock.valueHexView });
     integer.valueBlock.toDER();
     return integer;
   }
   convertFromDER() {
-    return new _Integer({
+    return new _a$o({
       valueHex: this.valueBlock.valueHexView[0] === 0 ? this.valueBlock.valueHexView.subarray(1) : this.valueBlock.valueHexView
     });
   }
@@ -4376,17 +4383,17 @@ var LocalObjectIdentifierValueBlock = class extends ValueBlock {
 LocalObjectIdentifierValueBlock.NAME = "ObjectIdentifierValueBlock";
 var _a$m;
 var ObjectIdentifier = class extends BaseBlock {
-  constructor(parameters = {}) {
-    super(parameters, LocalObjectIdentifierValueBlock);
-    this.idBlock.tagClass = 1;
-    this.idBlock.tagNumber = 6;
-  }
   getValue() {
     return this.valueBlock.toString();
   }
   setValue(value) {
     this.valueBlock.fromString(value);
   }
+  constructor(parameters = {}) {
+    super(parameters, LocalObjectIdentifierValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 6;
+  }
   onAsciiEncoding() {
     return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
   }
@@ -4506,7 +4513,7 @@ var LocalRelativeObjectIdentifierValueBlock = class extends ValueBlock {
     }
     return resultOffset;
   }
-  toBER(sizeOnly, writer) {
+  toBER(sizeOnly, _writer) {
     const retBuffers = [];
     for (let i = 0; i < this.value.length; i++) {
       const valueBuf = this.value[i].toBER(sizeOnly);
@@ -4568,17 +4575,17 @@ var LocalRelativeObjectIdentifierValueBlock = class extends ValueBlock {
 LocalRelativeObjectIdentifierValueBlock.NAME = "RelativeObjectIdentifierValueBlock";
 var _a$l;
 var RelativeObjectIdentifier = class extends BaseBlock {
-  constructor(parameters = {}) {
-    super(parameters, LocalRelativeObjectIdentifierValueBlock);
-    this.idBlock.tagClass = 1;
-    this.idBlock.tagNumber = 13;
-  }
   getValue() {
     return this.valueBlock.toString();
   }
   setValue(value) {
     this.valueBlock.fromString(value);
   }
+  constructor(parameters = {}) {
+    super(parameters, LocalRelativeObjectIdentifierValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 13;
+  }
   onAsciiEncoding() {
     return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
   }
@@ -4975,7 +4982,8 @@ var GeneralizedTime = class extends UTCTime {
     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));
+    const utcDate = Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond);
+    return new Date(utcDate);
   }
   fromString(inputString) {
     let isUTC = false;
@@ -5224,28 +5232,28 @@ var Repeated = class extends Any {
   }
 };
 var RawData = class {
-  constructor({ data = EMPTY_VIEW } = {}) {
-    this.dataView = BufferSourceConverter.toUint8Array(data);
-  }
   get data() {
     return this.dataView.slice().buffer;
   }
   set data(value) {
     this.dataView = BufferSourceConverter.toUint8Array(value);
   }
+  constructor({ data = EMPTY_VIEW } = {}) {
+    this.dataView = BufferSourceConverter.toUint8Array(data);
+  }
   fromBER(inputBuffer, inputOffset, inputLength) {
     const endLength = inputOffset + inputLength;
     this.dataView = BufferSourceConverter.toUint8Array(inputBuffer).subarray(inputOffset, endLength);
     return endLength;
   }
-  toBER(sizeOnly) {
+  toBER(_sizeOnly) {
     return this.dataView.slice().buffer;
   }
 };
 function compareSchema(root, inputData, inputSchema) {
   if (inputSchema instanceof Choice) {
-    for (let j = 0; j < inputSchema.value.length; j++) {
-      const result = compareSchema(root, inputData, inputSchema.value[j]);
+    for (const element of inputSchema.value) {
+      const result = compareSchema(root, inputData, element);
       if (result.verified) {
         return {
           verified: true,
@@ -5256,9 +5264,7 @@ function compareSchema(root, inputData, inputSchema) {
     {
       const _result = {
         verified: false,
-        result: {
-          error: "Wrong values for Choice type"
-        }
+        result: { error: "Wrong values for Choice type" }
       };
       if (inputSchema.hasOwnProperty(NAME))
         _result.name = inputSchema.name;
@@ -5404,9 +5410,7 @@ function compareSchema(root, inputData, inputSchema) {
     let admission = 0;
     let result = {
       verified: false,
-      result: {
-        error: "Unknown error"
-      }
+      result: { error: "Unknown error" }
     };
     let maxLength = inputSchema.valueBlock.value.length;
     if (maxLength > 0) {
@@ -5783,10 +5787,7 @@ var AsnSchemaStorage = class {
     }
   }
   createDefault(target) {
-    const schema = {
-      type: AsnTypeTypes.Sequence,
-      items: {}
-    };
+    const schema = { type: AsnTypeTypes.Sequence, items: {} };
     const parentSchema = this.findParentSchema(target);
     if (parentSchema) {
       Object.assign(schema, parentSchema);
@@ -5828,26 +5829,14 @@ var AsnSchemaStorage = class {
         const Container = item.repeated === "set" ? Set : Sequence;
         asn1Item = new Container({
           name: "",
-          value: [
-            new Repeated({
-              name,
-              value: asn1Item
-            })
-          ]
+          value: [new Repeated({ name, value: asn1Item })]
         });
       }
       if (item.context !== null && item.context !== void 0) {
         if (item.implicit) {
           if (typeof item.type === "number" || isConvertible(item.type)) {
             const Container = item.repeated ? Constructed : Primitive;
-            asn1Value.push(new Container({
-              name,
-              optional,
-              idBlock: {
-                tagClass: 3,
-                tagNumber: item.context
-              }
-            }));
+            asn1Value.push(new Container({ name, optional, idBlock: { tagClass: 3, tagNumber: item.context } }));
           } else {
             this.cache(item.type);
             const isRepeated = !!item.repeated;
@@ -5856,20 +5845,14 @@ var AsnSchemaStorage = class {
             asn1Value.push(new Constructed({
               name: !isRepeated ? name : "",
               optional,
-              idBlock: {
-                tagClass: 3,
-                tagNumber: item.context
-              },
+              idBlock: { tagClass: 3, tagNumber: item.context },
               value
             }));
           }
         } else {
           asn1Value.push(new Constructed({
             optional,
-            idBlock: {
-              tagClass: 3,
-              tagNumber: item.context
-            },
+            idBlock: { tagClass: 3, tagNumber: item.context },
             value: [asn1Item]
           }));
         }
@@ -5925,7 +5908,6 @@ var AsnParser = class {
     return res;
   }
   static fromASN(asn1Schema, target) {
-    var _a2;
     try {
       if (isConvertible(target)) {
         const value = new target();
@@ -5934,104 +5916,259 @@ var AsnParser = class {
       const schema = schemaStorage.get(target);
       schemaStorage.cache(target);
       let targetSchema = schema.schema;
-      if (asn1Schema.constructor === Constructed && schema.type !== AsnTypeTypes.Choice) {
-        targetSchema = new Constructed({
-          idBlock: {
-            tagClass: 3,
-            tagNumber: asn1Schema.idBlock.tagNumber
-          },
-          value: schema.schema.valueBlock.value
-        });
-        for (const key in schema.items) {
-          delete asn1Schema[key];
-        }
+      const choiceResult = this.handleChoiceTypes(asn1Schema, schema, target, targetSchema);
+      if (choiceResult === null || choiceResult === void 0 ? void 0 : choiceResult.result) {
+        return choiceResult.result;
       }
-      const asn1ComparedSchema = compareSchema({}, asn1Schema, targetSchema);
-      if (!asn1ComparedSchema.verified) {
-        throw new AsnSchemaValidationError(`Data does not match to ${target.name} ASN1 schema. ${asn1ComparedSchema.result.error}`);
+      if (choiceResult === null || choiceResult === void 0 ? void 0 : choiceResult.targetSchema) {
+        targetSchema = choiceResult.targetSchema;
       }
+      const sequenceResult = this.handleSequenceTypes(asn1Schema, schema, target, targetSchema);
       const res = new target();
       if (isTypeOfArray(target)) {
-        if (!("value" in asn1Schema.valueBlock && Array.isArray(asn1Schema.valueBlock.value))) {
-          throw new Error(`Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.`);
-        }
-        const itemType = schema.itemType;
-        if (typeof itemType === "number") {
-          const converter = defaultConverter(itemType);
-          if (!converter) {
-            throw new Error(`Cannot get default converter for array item of ${target.name} ASN1 schema`);
-          }
-          return target.from(asn1Schema.valueBlock.value, (element) => converter.fromASN(element));
-        } else {
-          return target.from(asn1Schema.valueBlock.value, (element) => this.fromASN(element, itemType));
-        }
+        return this.handleArrayTypes(asn1Schema, schema, target);
       }
+      this.processSchemaItems(schema, sequenceResult, res);
+      return res;
+    } catch (error) {
+      if (error instanceof AsnSchemaValidationError) {
+        error.schemas.push(target.name);
+      }
+      throw error;
+    }
+  }
+  static handleChoiceTypes(asn1Schema, schema, target, targetSchema) {
+    if (asn1Schema.constructor === Constructed && schema.type === AsnTypeTypes.Choice && asn1Schema.idBlock.tagClass === 3) {
       for (const key in schema.items) {
-        const asn1SchemaValue = asn1ComparedSchema.result[key];
-        if (!asn1SchemaValue) {
-          continue;
-        }
         const schemaItem = schema.items[key];
-        const schemaItemType = schemaItem.type;
-        if (typeof schemaItemType === "number" || isConvertible(schemaItemType)) {
-          const converter = (_a2 = schemaItem.converter) !== null && _a2 !== void 0 ? _a2 : isConvertible(schemaItemType) ? new schemaItemType() : null;
-          if (!converter) {
-            throw new Error("Converter is empty");
-          }
-          if (schemaItem.repeated) {
-            if (schemaItem.implicit) {
-              const Container = schemaItem.repeated === "sequence" ? Sequence : Set;
-              const newItem = new Container();
-              newItem.valueBlock = asn1SchemaValue.valueBlock;
-              const newItemAsn = fromBER(newItem.toBER(false));
-              if (newItemAsn.offset === -1) {
-                throw new Error(`Cannot parse the child item. ${newItemAsn.result.error}`);
-              }
-              if (!("value" in newItemAsn.result.valueBlock && Array.isArray(newItemAsn.result.valueBlock.value))) {
-                throw new Error("Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.");
-              }
-              const value = newItemAsn.result.valueBlock.value;
-              res[key] = Array.from(value, (element) => converter.fromASN(element));
-            } else {
-              res[key] = Array.from(asn1SchemaValue, (element) => converter.fromASN(element));
-            }
-          } else {
-            let value = asn1SchemaValue;
-            if (schemaItem.implicit) {
-              let newItem;
-              if (isConvertible(schemaItemType)) {
-                newItem = new schemaItemType().toSchema("");
-              } else {
-                const Asn1TypeName = AsnPropTypes[schemaItemType];
-                const Asn1Type = index_es_exports[Asn1TypeName];
-                if (!Asn1Type) {
-                  throw new Error(`Cannot get '${Asn1TypeName}' class from asn1js module`);
-                }
-                newItem = new Asn1Type();
+        if (schemaItem.context === asn1Schema.idBlock.tagNumber && schemaItem.implicit) {
+          if (typeof schemaItem.type === "function" && schemaStorage.has(schemaItem.type)) {
+            const fieldSchema = schemaStorage.get(schemaItem.type);
+            if (fieldSchema && fieldSchema.type === AsnTypeTypes.Sequence) {
+              const newSeq = new Sequence();
+              if ("value" in asn1Schema.valueBlock && Array.isArray(asn1Schema.valueBlock.value) && "value" in newSeq.valueBlock) {
+                newSeq.valueBlock.value = asn1Schema.valueBlock.value;
+                const fieldValue = this.fromASN(newSeq, schemaItem.type);
+                const res = new target();
+                res[key] = fieldValue;
+                return { result: res };
               }
-              newItem.valueBlock = value.valueBlock;
-              value = fromBER(newItem.toBER(false)).result;
             }
-            res[key] = converter.fromASN(value);
           }
-        } else {
-          if (schemaItem.repeated) {
-            if (!Array.isArray(asn1SchemaValue)) {
-              throw new Error("Cannot get list of items from the ASN.1 parsed value. ASN.1 value should be iterable.");
-            }
-            res[key] = Array.from(asn1SchemaValue, (element) => this.fromASN(element, schemaItemType));
-          } else {
-            res[key] = this.fromASN(asn1SchemaValue, schemaItemType);
+        }
+      }
+    } else if (asn1Schema.constructor === Constructed && schema.type !== AsnTypeTypes.Choice) {
+      const newTargetSchema = new Constructed({
+        idBlock: {
+          tagClass: 3,
+          tagNumber: asn1Schema.idBlock.tagNumber
+        },
+        value: schema.schema.valueBlock.value
+      });
+      for (const key in schema.items) {
+        delete asn1Schema[key];
+      }
+      return { targetSchema: newTargetSchema };
+    }
+    return null;
+  }
+  static handleSequenceTypes(asn1Schema, schema, target, targetSchema) {
+    if (schema.type === AsnTypeTypes.Sequence) {
+      const asn1ComparedSchema = compareSchema({}, asn1Schema, targetSchema);
+      if (!asn1ComparedSchema.verified) {
+        throw new AsnSchemaValidationError(`Data does not match to ${target.name} ASN1 schema.${asn1ComparedSchema.result.error ? ` ${asn1ComparedSchema.result.error}` : ""}`);
+      }
+      return asn1ComparedSchema;
+    } else {
+      const asn1ComparedSchema = compareSchema({}, asn1Schema, targetSchema);
+      if (!asn1ComparedSchema.verified) {
+        throw new AsnSchemaValidationError(`Data does not match to ${target.name} ASN1 schema.${asn1ComparedSchema.result.error ? ` ${asn1ComparedSchema.result.error}` : ""}`);
+      }
+      return asn1ComparedSchema;
+    }
+  }
+  static processRepeatedField(asn1Elements, asn1Index, schemaItem) {
+    let elementsToProcess = asn1Elements.slice(asn1Index);
+    if (elementsToProcess.length === 1 && elementsToProcess[0].constructor.name === "Sequence") {
+      const seq = elementsToProcess[0];
+      if (seq.valueBlock && seq.valueBlock.value && Array.isArray(seq.valueBlock.value)) {
+        elementsToProcess = seq.valueBlock.value;
+      }
+    }
+    if (typeof schemaItem.type === "number") {
+      const converter = defaultConverter(schemaItem.type);
+      if (!converter)
+        throw new Error(`No converter for ASN.1 type ${schemaItem.type}`);
+      return elementsToProcess.filter((el) => el && el.valueBlock).map((el) => {
+        try {
+          return converter.fromASN(el);
+        } catch {
+          return void 0;
+        }
+      }).filter((v) => v !== void 0);
+    } else {
+      return elementsToProcess.filter((el) => el && el.valueBlock).map((el) => {
+        try {
+          return this.fromASN(el, schemaItem.type);
+        } catch {
+          return void 0;
+        }
+      }).filter((v) => v !== void 0);
+    }
+  }
+  static processPrimitiveField(asn1Element, schemaItem) {
+    const converter = defaultConverter(schemaItem.type);
+    if (!converter)
+      throw new Error(`No converter for ASN.1 type ${schemaItem.type}`);
+    return converter.fromASN(asn1Element);
+  }
+  static isOptionalChoiceField(schemaItem) {
+    return schemaItem.optional && typeof schemaItem.type === "function" && schemaStorage.has(schemaItem.type) && schemaStorage.get(schemaItem.type).type === AsnTypeTypes.Choice;
+  }
+  static processOptionalChoiceField(asn1Element, schemaItem) {
+    try {
+      const value = this.fromASN(asn1Element, schemaItem.type);
+      return { processed: true, value };
+    } catch (err) {
+      if (err instanceof AsnSchemaValidationError && /Wrong values for Choice type/.test(err.message)) {
+        return { processed: false };
+      }
+      throw err;
+    }
+  }
+  static handleArrayTypes(asn1Schema, schema, target) {
+    if (!("value" in asn1Schema.valueBlock && Array.isArray(asn1Schema.valueBlock.value))) {
+      throw new Error(`Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.`);
+    }
+    const itemType = schema.itemType;
+    if (typeof itemType === "number") {
+      const converter = defaultConverter(itemType);
+      if (!converter) {
+        throw new Error(`Cannot get default converter for array item of ${target.name} ASN1 schema`);
+      }
+      return target.from(asn1Schema.valueBlock.value, (element) => converter.fromASN(element));
+    } else {
+      return target.from(asn1Schema.valueBlock.value, (element) => this.fromASN(element, itemType));
+    }
+  }
+  static processSchemaItems(schema, asn1ComparedSchema, res) {
+    for (const key in schema.items) {
+      const asn1SchemaValue = asn1ComparedSchema.result[key];
+      if (!asn1SchemaValue) {
+        continue;
+      }
+      const schemaItem = schema.items[key];
+      const schemaItemType = schemaItem.type;
+      let parsedValue;
+      if (typeof schemaItemType === "number" || isConvertible(schemaItemType)) {
+        parsedValue = this.processPrimitiveSchemaItem(asn1SchemaValue, schemaItem, schemaItemType);
+      } else {
+        parsedValue = this.processComplexSchemaItem(asn1SchemaValue, schemaItem, schemaItemType);
+      }
+      if (parsedValue && typeof parsedValue === "object" && "value" in parsedValue && "raw" in parsedValue) {
+        res[key] = parsedValue.value;
+        res[`${key}Raw`] = parsedValue.raw;
+      } else {
+        res[key] = parsedValue;
+      }
+    }
+  }
+  static processPrimitiveSchemaItem(asn1SchemaValue, schemaItem, schemaItemType) {
+    var _a2;
+    const converter = (_a2 = schemaItem.converter) !== null && _a2 !== void 0 ? _a2 : isConvertible(schemaItemType) ? new schemaItemType() : null;
+    if (!converter) {
+      throw new Error("Converter is empty");
+    }
+    if (schemaItem.repeated) {
+      return this.processRepeatedPrimitiveItem(asn1SchemaValue, schemaItem, converter);
+    } else {
+      return this.processSinglePrimitiveItem(asn1SchemaValue, schemaItem, schemaItemType, converter);
+    }
+  }
+  static processRepeatedPrimitiveItem(asn1SchemaValue, schemaItem, converter) {
+    if (schemaItem.implicit) {
+      const Container = schemaItem.repeated === "sequence" ? Sequence : Set;
+      const newItem = new Container();
+      newItem.valueBlock = asn1SchemaValue.valueBlock;
+      const newItemAsn = fromBER(newItem.toBER(false));
+      if (newItemAsn.offset === -1) {
+        throw new Error(`Cannot parse the child item. ${newItemAsn.result.error}`);
+      }
+      if (!("value" in newItemAsn.result.valueBlock && Array.isArray(newItemAsn.result.valueBlock.value))) {
+        throw new Error("Cannot get items from the ASN.1 parsed value. ASN.1 object is not constructed.");
+      }
+      const value = newItemAsn.result.valueBlock.value;
+      return Array.from(value, (element) => converter.fromASN(element));
+    } else {
+      return Array.from(asn1SchemaValue, (element) => converter.fromASN(element));
+    }
+  }
+  static processSinglePrimitiveItem(asn1SchemaValue, schemaItem, schemaItemType, converter) {
+    let value = asn1SchemaValue;
+    if (schemaItem.implicit) {
+      let newItem;
+      if (isConvertible(schemaItemType)) {
+        newItem = new schemaItemType().toSchema("");
+      } else {
+        const Asn1TypeName = AsnPropTypes[schemaItemType];
+        const Asn1Type = index_es_exports[Asn1TypeName];
+        if (!Asn1Type) {
+          throw new Error(`Cannot get '${Asn1TypeName}' class from asn1js module`);
+        }
+        newItem = new Asn1Type();
+      }
+      newItem.valueBlock = value.valueBlock;
+      value = fromBER(newItem.toBER(false)).result;
+    }
+    return converter.fromASN(value);
+  }
+  static processComplexSchemaItem(asn1SchemaValue, schemaItem, schemaItemType) {
+    if (schemaItem.repeated) {
+      if (!Array.isArray(asn1SchemaValue)) {
+        throw new Error("Cannot get list of items from the ASN.1 parsed value. ASN.1 value should be iterable.");
+      }
+      return Array.from(asn1SchemaValue, (element) => this.fromASN(element, schemaItemType));
+    } else {
+      const valueToProcess = this.handleImplicitTagging(asn1SchemaValue, schemaItem, schemaItemType);
+      if (this.isOptionalChoiceField(schemaItem)) {
+        try {
+          return this.fromASN(valueToProcess, schemaItemType);
+        } catch (err) {
+          if (err instanceof AsnSchemaValidationError && /Wrong values for Choice type/.test(err.message)) {
+            return void 0;
           }
+          throw err;
         }
+      } else {
+        const parsedValue = this.fromASN(valueToProcess, schemaItemType);
+        if (schemaItem.raw) {
+          return {
+            value: parsedValue,
+            raw: asn1SchemaValue.valueBeforeDecodeView
+          };
+        }
+        return parsedValue;
       }
-      return res;
-    } catch (error) {
-      if (error instanceof AsnSchemaValidationError) {
-        error.schemas.push(target.name);
+    }
+  }
+  static handleImplicitTagging(asn1SchemaValue, schemaItem, schemaItemType) {
+    if (schemaItem.implicit && typeof schemaItem.context === "number") {
+      const schema = schemaStorage.get(schemaItemType);
+      if (schema.type === AsnTypeTypes.Sequence) {
+        const newSeq = new Sequence();
+        if ("value" in asn1SchemaValue.valueBlock && Array.isArray(asn1SchemaValue.valueBlock.value) && "value" in newSeq.valueBlock) {
+          newSeq.valueBlock.value = asn1SchemaValue.valueBlock.value;
+          return newSeq;
+        }
+      } else if (schema.type === AsnTypeTypes.Set) {
+        const newSet = new Set();
+        if ("value" in asn1SchemaValue.valueBlock && Array.isArray(asn1SchemaValue.valueBlock.value) && "value" in newSet.valueBlock) {
+          newSet.valueBlock.value = asn1SchemaValue.valueBlock.value;
+          return newSet;
+        }
       }
-      throw error;
     }
+    return asn1SchemaValue;
   }
 };
 
@@ -6481,7 +6618,7 @@ pvtsutils/build/index.es.js:
   (*!
    * MIT License
    * 
-   * Copyright (c) 2017-2022 Peculiar Ventures, LLC
+   * Copyright (c) 2017-2024 Peculiar Ventures, LLC
    * 
    * Permission is hereby granted, free of charge, to any person obtaining a copy
    * of this software and associated documentation files (the "Software"), to deal