web-dc-api 0.0.58 → 0.0.59

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/converters.js

@@ -0,0 +1,180 @@
+'use strict';
+
+var index_es = require('../../../../asn1js/build/index.es.js');
+var enums = require('./enums.js');
+require('../../../../../_virtual/index9.js');
+var octet_string = require('./types/octet_string.js');
+
+const AsnAnyConverter = {
+  fromASN: value => value instanceof index_es.Null ? null : value.valueBeforeDecodeView,
+  toASN: value => {
+    if (value === null) {
+      return new index_es.Null();
+    }
+    const schema = index_es.fromBER(value);
+    if (schema.result.error) {
+      throw new Error(schema.result.error);
+    }
+    return schema.result;
+  }
+};
+const AsnIntegerConverter = {
+  fromASN: value => value.valueBlock.valueHexView.byteLength >= 4 ? value.valueBlock.toString() : value.valueBlock.valueDec,
+  toASN: value => new index_es.Integer({
+    value: +value
+  })
+};
+const AsnEnumeratedConverter = {
+  fromASN: value => value.valueBlock.valueDec,
+  toASN: value => new index_es.Enumerated({
+    value
+  })
+};
+const AsnIntegerArrayBufferConverter = {
+  fromASN: value => value.valueBlock.valueHexView,
+  toASN: value => new index_es.Integer({
+    valueHex: value
+  })
+};
+const AsnBitStringConverter = {
+  fromASN: value => value.valueBlock.valueHexView,
+  toASN: value => new index_es.BitString({
+    valueHex: value
+  })
+};
+const AsnObjectIdentifierConverter = {
+  fromASN: value => value.valueBlock.toString(),
+  toASN: value => new index_es.ObjectIdentifier({
+    value
+  })
+};
+const AsnBooleanConverter = {
+  fromASN: value => value.valueBlock.value,
+  toASN: value => new index_es.Boolean({
+    value
+  })
+};
+const AsnOctetStringConverter = {
+  fromASN: value => value.valueBlock.valueHexView,
+  toASN: value => new index_es.OctetString({
+    valueHex: value
+  })
+};
+const AsnConstructedOctetStringConverter = {
+  fromASN: value => new octet_string.OctetString(value.getValue()),
+  toASN: value => value.toASN()
+};
+function createStringConverter(Asn1Type) {
+  return {
+    fromASN: value => value.valueBlock.value,
+    toASN: value => new Asn1Type({
+      value
+    })
+  };
+}
+const AsnUtf8StringConverter = createStringConverter(index_es.Utf8String);
+const AsnBmpStringConverter = createStringConverter(index_es.BmpString);
+const AsnUniversalStringConverter = createStringConverter(index_es.UniversalString);
+const AsnNumericStringConverter = createStringConverter(index_es.NumericString);
+const AsnPrintableStringConverter = createStringConverter(index_es.PrintableString);
+const AsnTeletexStringConverter = createStringConverter(index_es.TeletexString);
+const AsnVideotexStringConverter = createStringConverter(index_es.VideotexString);
+const AsnIA5StringConverter = createStringConverter(index_es.IA5String);
+const AsnGraphicStringConverter = createStringConverter(index_es.GraphicString);
+const AsnVisibleStringConverter = createStringConverter(index_es.VisibleString);
+const AsnGeneralStringConverter = createStringConverter(index_es.GeneralString);
+const AsnCharacterStringConverter = createStringConverter(index_es.CharacterString);
+const AsnUTCTimeConverter = {
+  fromASN: value => value.toDate(),
+  toASN: value => new index_es.UTCTime({
+    valueDate: value
+  })
+};
+const AsnGeneralizedTimeConverter = {
+  fromASN: value => value.toDate(),
+  toASN: value => new index_es.GeneralizedTime({
+    valueDate: value
+  })
+};
+const AsnNullConverter = {
+  fromASN: () => null,
+  toASN: () => {
+    return new index_es.Null();
+  }
+};
+function defaultConverter(type) {
+  switch (type) {
+    case enums.AsnPropTypes.Any:
+      return AsnAnyConverter;
+    case enums.AsnPropTypes.BitString:
+      return AsnBitStringConverter;
+    case enums.AsnPropTypes.BmpString:
+      return AsnBmpStringConverter;
+    case enums.AsnPropTypes.Boolean:
+      return AsnBooleanConverter;
+    case enums.AsnPropTypes.CharacterString:
+      return AsnCharacterStringConverter;
+    case enums.AsnPropTypes.Enumerated:
+      return AsnEnumeratedConverter;
+    case enums.AsnPropTypes.GeneralString:
+      return AsnGeneralStringConverter;
+    case enums.AsnPropTypes.GeneralizedTime:
+      return AsnGeneralizedTimeConverter;
+    case enums.AsnPropTypes.GraphicString:
+      return AsnGraphicStringConverter;
+    case enums.AsnPropTypes.IA5String:
+      return AsnIA5StringConverter;
+    case enums.AsnPropTypes.Integer:
+      return AsnIntegerConverter;
+    case enums.AsnPropTypes.Null:
+      return AsnNullConverter;
+    case enums.AsnPropTypes.NumericString:
+      return AsnNumericStringConverter;
+    case enums.AsnPropTypes.ObjectIdentifier:
+      return AsnObjectIdentifierConverter;
+    case enums.AsnPropTypes.OctetString:
+      return AsnOctetStringConverter;
+    case enums.AsnPropTypes.PrintableString:
+      return AsnPrintableStringConverter;
+    case enums.AsnPropTypes.TeletexString:
+      return AsnTeletexStringConverter;
+    case enums.AsnPropTypes.UTCTime:
+      return AsnUTCTimeConverter;
+    case enums.AsnPropTypes.UniversalString:
+      return AsnUniversalStringConverter;
+    case enums.AsnPropTypes.Utf8String:
+      return AsnUtf8StringConverter;
+    case enums.AsnPropTypes.VideotexString:
+      return AsnVideotexStringConverter;
+    case enums.AsnPropTypes.VisibleString:
+      return AsnVisibleStringConverter;
+    default:
+      return null;
+  }
+}
+
+exports.AsnAnyConverter = AsnAnyConverter;
+exports.AsnBitStringConverter = AsnBitStringConverter;
+exports.AsnBmpStringConverter = AsnBmpStringConverter;
+exports.AsnBooleanConverter = AsnBooleanConverter;
+exports.AsnCharacterStringConverter = AsnCharacterStringConverter;
+exports.AsnConstructedOctetStringConverter = AsnConstructedOctetStringConverter;
+exports.AsnEnumeratedConverter = AsnEnumeratedConverter;
+exports.AsnGeneralStringConverter = AsnGeneralStringConverter;
+exports.AsnGeneralizedTimeConverter = AsnGeneralizedTimeConverter;
+exports.AsnGraphicStringConverter = AsnGraphicStringConverter;
+exports.AsnIA5StringConverter = AsnIA5StringConverter;
+exports.AsnIntegerArrayBufferConverter = AsnIntegerArrayBufferConverter;
+exports.AsnIntegerConverter = AsnIntegerConverter;
+exports.AsnNullConverter = AsnNullConverter;
+exports.AsnNumericStringConverter = AsnNumericStringConverter;
+exports.AsnObjectIdentifierConverter = AsnObjectIdentifierConverter;
+exports.AsnOctetStringConverter = AsnOctetStringConverter;
+exports.AsnPrintableStringConverter = AsnPrintableStringConverter;
+exports.AsnTeletexStringConverter = AsnTeletexStringConverter;
+exports.AsnUTCTimeConverter = AsnUTCTimeConverter;
+exports.AsnUniversalStringConverter = AsnUniversalStringConverter;
+exports.AsnUtf8StringConverter = AsnUtf8StringConverter;
+exports.AsnVideotexStringConverter = AsnVideotexStringConverter;
+exports.AsnVisibleStringConverter = AsnVisibleStringConverter;
+exports.defaultConverter = defaultConverter;

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/decorators.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var converters = require('./converters.js');
+require('./enums.js');
+var storage = require('./storage.js');
+
+const AsnType = options => target => {
+  let schema;
+  if (!storage.schemaStorage.has(target)) {
+    schema = storage.schemaStorage.createDefault(target);
+    storage.schemaStorage.set(target, schema);
+  } else {
+    schema = storage.schemaStorage.get(target);
+  }
+  Object.assign(schema, options);
+};
+const AsnProp = options => (target, propertyKey) => {
+  let schema;
+  if (!storage.schemaStorage.has(target.constructor)) {
+    schema = storage.schemaStorage.createDefault(target.constructor);
+    storage.schemaStorage.set(target.constructor, schema);
+  } else {
+    schema = storage.schemaStorage.get(target.constructor);
+  }
+  const copyOptions = Object.assign({}, options);
+  if (typeof copyOptions.type === "number" && !copyOptions.converter) {
+    const defaultConverter = converters.defaultConverter(options.type);
+    if (!defaultConverter) {
+      throw new Error(`Cannot get default converter for property '${propertyKey}' of ${target.constructor.name}`);
+    }
+    copyOptions.converter = defaultConverter;
+  }
+  schema.items[propertyKey] = copyOptions;
+};
+
+exports.AsnProp = AsnProp;
+exports.AsnType = AsnType;

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/enums.js

@@ -0,0 +1,38 @@
+'use strict';
+
+exports.AsnTypeTypes = void 0;
+(function (AsnTypeTypes) {
+  AsnTypeTypes[AsnTypeTypes["Sequence"] = 0] = "Sequence";
+  AsnTypeTypes[AsnTypeTypes["Set"] = 1] = "Set";
+  AsnTypeTypes[AsnTypeTypes["Choice"] = 2] = "Choice";
+})(exports.AsnTypeTypes || (exports.AsnTypeTypes = {}));
+exports.AsnPropTypes = void 0;
+(function (AsnPropTypes) {
+  AsnPropTypes[AsnPropTypes["Any"] = 1] = "Any";
+  AsnPropTypes[AsnPropTypes["Boolean"] = 2] = "Boolean";
+  AsnPropTypes[AsnPropTypes["OctetString"] = 3] = "OctetString";
+  AsnPropTypes[AsnPropTypes["BitString"] = 4] = "BitString";
+  AsnPropTypes[AsnPropTypes["Integer"] = 5] = "Integer";
+  AsnPropTypes[AsnPropTypes["Enumerated"] = 6] = "Enumerated";
+  AsnPropTypes[AsnPropTypes["ObjectIdentifier"] = 7] = "ObjectIdentifier";
+  AsnPropTypes[AsnPropTypes["Utf8String"] = 8] = "Utf8String";
+  AsnPropTypes[AsnPropTypes["BmpString"] = 9] = "BmpString";
+  AsnPropTypes[AsnPropTypes["UniversalString"] = 10] = "UniversalString";
+  AsnPropTypes[AsnPropTypes["NumericString"] = 11] = "NumericString";
+  AsnPropTypes[AsnPropTypes["PrintableString"] = 12] = "PrintableString";
+  AsnPropTypes[AsnPropTypes["TeletexString"] = 13] = "TeletexString";
+  AsnPropTypes[AsnPropTypes["VideotexString"] = 14] = "VideotexString";
+  AsnPropTypes[AsnPropTypes["IA5String"] = 15] = "IA5String";
+  AsnPropTypes[AsnPropTypes["GraphicString"] = 16] = "GraphicString";
+  AsnPropTypes[AsnPropTypes["VisibleString"] = 17] = "VisibleString";
+  AsnPropTypes[AsnPropTypes["GeneralString"] = 18] = "GeneralString";
+  AsnPropTypes[AsnPropTypes["CharacterString"] = 19] = "CharacterString";
+  AsnPropTypes[AsnPropTypes["UTCTime"] = 20] = "UTCTime";
+  AsnPropTypes[AsnPropTypes["GeneralizedTime"] = 21] = "GeneralizedTime";
+  AsnPropTypes[AsnPropTypes["DATE"] = 22] = "DATE";
+  AsnPropTypes[AsnPropTypes["TimeOfDay"] = 23] = "TimeOfDay";
+  AsnPropTypes[AsnPropTypes["DateTime"] = 24] = "DateTime";
+  AsnPropTypes[AsnPropTypes["Duration"] = 25] = "Duration";
+  AsnPropTypes[AsnPropTypes["TIME"] = 26] = "TIME";
+  AsnPropTypes[AsnPropTypes["Null"] = 27] = "Null";
+})(exports.AsnPropTypes || (exports.AsnPropTypes = {}));

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/errors/schema_validation.js

@@ -0,0 +1,10 @@
+'use strict';
+
+class AsnSchemaValidationError extends Error {
+  constructor() {
+    super(...arguments);
+    this.schemas = [];
+  }
+}
+
+exports.AsnSchemaValidationError = AsnSchemaValidationError;

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/helper.js

@@ -0,0 +1,44 @@
+'use strict';
+
+function isConvertible(target) {
+  if (typeof target === "function" && target.prototype) {
+    if (target.prototype.toASN && target.prototype.fromASN) {
+      return true;
+    } else {
+      return isConvertible(target.prototype);
+    }
+  } else {
+    return !!(target && typeof target === "object" && "toASN" in target && "fromASN" in target);
+  }
+}
+function isTypeOfArray(target) {
+  var _a;
+  if (target) {
+    const proto = Object.getPrototypeOf(target);
+    if (((_a = proto === null || proto === void 0 ? void 0 : proto.prototype) === null || _a === void 0 ? void 0 : _a.constructor) === Array) {
+      return true;
+    }
+    return isTypeOfArray(proto);
+  }
+  return false;
+}
+function isArrayEqual(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.isArrayEqual = isArrayEqual;
+exports.isConvertible = isConvertible;
+exports.isTypeOfArray = isTypeOfArray;

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/objects.js

@@ -0,0 +1,17 @@
+'use strict';
+
+class AsnArray extends Array {
+  constructor() {
+    let items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    if (typeof items === "number") {
+      super(items);
+    } else {
+      super();
+      for (const item of items) {
+        this.push(item);
+      }
+    }
+  }
+}
+
+exports.AsnArray = AsnArray;

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/parser.js

@@ -0,0 +1,130 @@
+'use strict';
+
+var index_es = require('../../../../asn1js/build/index.es.js');
+var enums = require('./enums.js');
+var converters = require('./converters.js');
+var schema_validation = require('./errors/schema_validation.js');
+var helper = require('./helper.js');
+var storage = require('./storage.js');
+
+class AsnParser {
+  static parse(data, target) {
+    const asn1Parsed = index_es.fromBER(data);
+    if (asn1Parsed.result.error) {
+      throw new Error(asn1Parsed.result.error);
+    }
+    const res = this.fromASN(asn1Parsed.result, target);
+    return res;
+  }
+  static fromASN(asn1Schema, target) {
+    var _a;
+    try {
+      if (helper.isConvertible(target)) {
+        const value = new target();
+        return value.fromASN(asn1Schema);
+      }
+      const schema = storage.schemaStorage.get(target);
+      storage.schemaStorage.cache(target);
+      let targetSchema = schema.schema;
+      if (asn1Schema.constructor === index_es.Constructed && schema.type !== enums.AsnTypeTypes.Choice) {
+        targetSchema = new index_es.Constructed({
+          idBlock: {
+            tagClass: 3,
+            tagNumber: asn1Schema.idBlock.tagNumber
+          },
+          value: schema.schema.valueBlock.value
+        });
+        for (const key in schema.items) {
+          delete asn1Schema[key];
+        }
+      }
+      const asn1ComparedSchema = index_es.compareSchema({}, asn1Schema, targetSchema);
+      if (!asn1ComparedSchema.verified) {
+        throw new schema_validation.AsnSchemaValidationError(`Data does not match to ${target.name} ASN1 schema. ${asn1ComparedSchema.result.error}`);
+      }
+      const res = new target();
+      if (helper.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 = converters.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));
+        }
+      }
+      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" || helper.isConvertible(schemaItemType)) {
+          const converter = (_a = schemaItem.converter) !== null && _a !== void 0 ? _a : helper.isConvertible(schemaItemType) ? new schemaItemType() : null;
+          if (!converter) {
+            throw new Error("Converter is empty");
+          }
+          if (schemaItem.repeated) {
+            if (schemaItem.implicit) {
+              const Container = schemaItem.repeated === "sequence" ? index_es.Sequence : index_es.Set;
+              const newItem = new Container();
+              newItem.valueBlock = asn1SchemaValue.valueBlock;
+              const newItemAsn = index_es.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 (helper.isConvertible(schemaItemType)) {
+                newItem = new schemaItemType().toSchema("");
+              } else {
+                const Asn1TypeName = enums.AsnPropTypes[schemaItemType];
+                const Asn1Type = index_es[Asn1TypeName];
+                if (!Asn1Type) {
+                  throw new Error(`Cannot get '${Asn1TypeName}' class from asn1js module`);
+                }
+                newItem = new Asn1Type();
+              }
+              newItem.valueBlock = value.valueBlock;
+              value = index_es.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);
+          }
+        }
+      }
+      return res;
+    } catch (error) {
+      if (error instanceof schema_validation.AsnSchemaValidationError) {
+        error.schemas.push(target.name);
+      }
+      throw error;
+    }
+  }
+}
+
+exports.AsnParser = AsnParser;

package/dist/cjs/node_modules/@peculiar/asn1-schema/build/es2015/schema.js

@@ -0,0 +1,165 @@
+'use strict';
+
+var index_es = require('../../../../asn1js/build/index.es.js');
+var enums = require('./enums.js');
+var helper = require('./helper.js');
+
+class AsnSchemaStorage {
+  constructor() {
+    this.items = new WeakMap();
+  }
+  has(target) {
+    return this.items.has(target);
+  }
+  get(target) {
+    let checkSchema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const schema = this.items.get(target);
+    if (!schema) {
+      throw new Error(`Cannot get schema for '${target.prototype.constructor.name}' target`);
+    }
+    if (checkSchema && !schema.schema) {
+      throw new Error(`Schema '${target.prototype.constructor.name}' doesn't contain ASN.1 schema. Call 'AsnSchemaStorage.cache'.`);
+    }
+    return schema;
+  }
+  cache(target) {
+    const schema = this.get(target);
+    if (!schema.schema) {
+      schema.schema = this.create(target, true);
+    }
+  }
+  createDefault(target) {
+    const schema = {
+      type: enums.AsnTypeTypes.Sequence,
+      items: {}
+    };
+    const parentSchema = this.findParentSchema(target);
+    if (parentSchema) {
+      Object.assign(schema, parentSchema);
+      schema.items = Object.assign({}, schema.items, parentSchema.items);
+    }
+    return schema;
+  }
+  create(target, useNames) {
+    const schema = this.items.get(target) || this.createDefault(target);
+    const asn1Value = [];
+    for (const key in schema.items) {
+      const item = schema.items[key];
+      const name = useNames ? key : "";
+      let asn1Item;
+      if (typeof item.type === "number") {
+        const Asn1TypeName = enums.AsnPropTypes[item.type];
+        const Asn1Type = index_es[Asn1TypeName];
+        if (!Asn1Type) {
+          throw new Error(`Cannot get ASN1 class by name '${Asn1TypeName}'`);
+        }
+        asn1Item = new Asn1Type({
+          name
+        });
+      } else if (helper.isConvertible(item.type)) {
+        const instance = new item.type();
+        asn1Item = instance.toSchema(name);
+      } else if (item.optional) {
+        const itemSchema = this.get(item.type);
+        if (itemSchema.type === enums.AsnTypeTypes.Choice) {
+          asn1Item = new index_es.Any({
+            name
+          });
+        } else {
+          asn1Item = this.create(item.type, false);
+          asn1Item.name = name;
+        }
+      } else {
+        asn1Item = new index_es.Any({
+          name
+        });
+      }
+      const optional = !!item.optional || item.defaultValue !== undefined;
+      if (item.repeated) {
+        asn1Item.name = "";
+        const Container = item.repeated === "set" ? index_es.Set : index_es.Sequence;
+        asn1Item = new Container({
+          name: "",
+          value: [new index_es.Repeated({
+            name,
+            value: asn1Item
+          })]
+        });
+      }
+      if (item.context !== null && item.context !== undefined) {
+        if (item.implicit) {
+          if (typeof item.type === "number" || helper.isConvertible(item.type)) {
+            const Container = item.repeated ? index_es.Constructed : index_es.Primitive;
+            asn1Value.push(new Container({
+              name,
+              optional,
+              idBlock: {
+                tagClass: 3,
+                tagNumber: item.context
+              }
+            }));
+          } else {
+            this.cache(item.type);
+            const isRepeated = !!item.repeated;
+            let value = !isRepeated ? this.get(item.type, true).schema : asn1Item;
+            value = "valueBlock" in value ? value.valueBlock.value : value.value;
+            asn1Value.push(new index_es.Constructed({
+              name: !isRepeated ? name : "",
+              optional,
+              idBlock: {
+                tagClass: 3,
+                tagNumber: item.context
+              },
+              value: value
+            }));
+          }
+        } else {
+          asn1Value.push(new index_es.Constructed({
+            optional,
+            idBlock: {
+              tagClass: 3,
+              tagNumber: item.context
+            },
+            value: [asn1Item]
+          }));
+        }
+      } else {
+        asn1Item.optional = optional;
+        asn1Value.push(asn1Item);
+      }
+    }
+    switch (schema.type) {
+      case enums.AsnTypeTypes.Sequence:
+        return new index_es.Sequence({
+          value: asn1Value,
+          name: ""
+        });
+      case enums.AsnTypeTypes.Set:
+        return new index_es.Set({
+          value: asn1Value,
+          name: ""
+        });
+      case enums.AsnTypeTypes.Choice:
+        return new index_es.Choice({
+          value: asn1Value,
+          name: ""
+        });
+      default:
+        throw new Error(`Unsupported ASN1 type in use`);
+    }
+  }
+  set(target, schema) {
+    this.items.set(target, schema);
+    return this;
+  }
+  findParentSchema(target) {
+    const parent = Object.getPrototypeOf(target);
+    if (parent) {
+      const schema = this.items.get(parent);
+      return schema || this.findParentSchema(parent);
+    }
+    return null;
+  }
+}
+
+exports.AsnSchemaStorage = AsnSchemaStorage;