asn1-ts 8.0.5 → 9.0.1

package/dist/{node/codecs/der.js → codecs/der.mjs}

@@ -1,89 +1,53 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const asn1_1 = __importDefault(require("../asn1"));
-const errors = __importStar(require("../errors"));
-const values_1 = require("../values");
-const convertBytesToText_1 = __importDefault(require("../utils/convertBytesToText"));
-const convertTextToBytes_1 = __importDefault(require("../utils/convertTextToBytes"));
-const sortCanonically_1 = __importDefault(require("../utils/sortCanonically"));
-const ObjectIdentifier_1 = __importDefault(require("../types/ObjectIdentifier"));
-const encodeBoolean_1 = __importDefault(require("./x690/encoders/encodeBoolean"));
-const decodeBoolean_1 = __importDefault(require("./der/decoders/decodeBoolean"));
-const encodeBitString_1 = __importDefault(require("./x690/encoders/encodeBitString"));
-const decodeBitString_1 = __importDefault(require("./der/decoders/decodeBitString"));
-const encodeReal_1 = __importDefault(require("./x690/encoders/encodeReal"));
-const decodeReal_1 = __importDefault(require("./der/decoders/decodeReal"));
-const encodeSequence_1 = __importDefault(require("./x690/encoders/encodeSequence"));
-const decodeSequence_1 = __importDefault(require("./der/decoders/decodeSequence"));
-const encodeUTCTime_1 = __importDefault(require("./x690/encoders/encodeUTCTime"));
-const decodeUTCTime_1 = __importDefault(require("./der/decoders/decodeUTCTime"));
-const encodeGeneralizedTime_1 = __importDefault(require("./x690/encoders/encodeGeneralizedTime"));
-const decodeGeneralizedTime_1 = __importDefault(require("./der/decoders/decodeGeneralizedTime"));
-const encodeExternal_1 = __importDefault(require("../codecs/x690/encoders/encodeExternal"));
-const encodeEmbeddedPDV_1 = __importDefault(require("../codecs/x690/encoders/encodeEmbeddedPDV"));
-const encodeCharacterString_1 = __importDefault(require("../codecs/x690/encoders/encodeCharacterString"));
-const decodeExternal_1 = __importDefault(require("../codecs/x690/decoders/decodeExternal"));
-const decodeEmbeddedPDV_1 = __importDefault(require("../codecs/x690/decoders/decodeEmbeddedPDV"));
-const decodeCharacterString_1 = __importDefault(require("../codecs/x690/decoders/decodeCharacterString"));
-const encodeGraphicString_1 = __importDefault(require("../codecs/ber/encoders/encodeGraphicString"));
-const encodeNumericString_1 = __importDefault(require("../codecs/ber/encoders/encodeNumericString"));
-const encodeObjectDescriptor_1 = __importDefault(require("../codecs/ber/encoders/encodeObjectDescriptor"));
-const encodePrintableString_1 = __importDefault(require("../codecs/ber/encoders/encodePrintableString"));
-const encodeVisibleString_1 = __importDefault(require("../codecs/ber/encoders/encodeVisibleString"));
-const encodeGeneralString_1 = __importDefault(require("../codecs/ber/encoders/encodeGeneralString"));
-const decodeGraphicString_1 = __importDefault(require("../codecs/x690/decoders/decodeGraphicString"));
-const decodeNumericString_1 = __importDefault(require("../codecs/x690/decoders/decodeNumericString"));
-const decodeObjectDescriptor_1 = __importDefault(require("../codecs/x690/decoders/decodeObjectDescriptor"));
-const decodePrintableString_1 = __importDefault(require("../codecs/x690/decoders/decodePrintableString"));
-const decodeVisibleString_1 = __importDefault(require("../codecs/x690/decoders/decodeVisibleString"));
-const decodeGeneralString_1 = __importDefault(require("../codecs/x690/decoders/decodeGeneralString"));
-const encodeDuration_1 = __importDefault(require("../codecs/x690/encoders/encodeDuration"));
-const decodeDuration_1 = __importDefault(require("../codecs/der/decoders/decodeDuration"));
-const x690_1 = __importDefault(require("../x690"));
-const utils_1 = require("../utils");
-const node_buffer_1 = require("node:buffer");
-class DERElement extends x690_1.default {
+import ASN1Element from "../asn1.mjs";
+import * as errors from "../errors.mjs";
+import { ASN1Construction, ASN1TagClass, ASN1UniversalType, } from "../values.mjs";
+import convertBytesToText from "../utils/convertBytesToText.mjs";
+import convertTextToBytes from "../utils/convertTextToBytes.mjs";
+import sortCanonically from "../utils/sortCanonically.mjs";
+import ObjectIdentifier from "../types/ObjectIdentifier.mjs";
+import encodeBoolean from "./x690/encoders/encodeBoolean.mjs";
+import decodeBoolean from "./der/decoders/decodeBoolean.mjs";
+import encodeBitString from "./x690/encoders/encodeBitString.mjs";
+import decodeBitString from "./der/decoders/decodeBitString.mjs";
+import encodeReal from "./x690/encoders/encodeReal.mjs";
+import decodeReal from "./der/decoders/decodeReal.mjs";
+import encodeSequence from "./x690/encoders/encodeSequence.mjs";
+import decodeSequence from "./der/decoders/decodeSequence.mjs";
+import encodeUTCTime from "./x690/encoders/encodeUTCTime.mjs";
+import decodeUTCTime from "./der/decoders/decodeUTCTime.mjs";
+import encodeGeneralizedTime from "./x690/encoders/encodeGeneralizedTime.mjs";
+import decodeGeneralizedTime from "./der/decoders/decodeGeneralizedTime.mjs";
+import encodeExternal from "../codecs/x690/encoders/encodeExternal.mjs";
+import encodeEmbeddedPDV from "../codecs/x690/encoders/encodeEmbeddedPDV.mjs";
+import encodeCharacterString from "../codecs/x690/encoders/encodeCharacterString.mjs";
+import decodeExternal from "../codecs/x690/decoders/decodeExternal.mjs";
+import decodeEmbeddedPDV from "../codecs/x690/decoders/decodeEmbeddedPDV.mjs";
+import decodeCharacterString from "../codecs/x690/decoders/decodeCharacterString.mjs";
+import encodeGraphicString from "../codecs/ber/encoders/encodeGraphicString.mjs";
+import encodeNumericString from "../codecs/ber/encoders/encodeNumericString.mjs";
+import encodeObjectDescriptor from "../codecs/ber/encoders/encodeObjectDescriptor.mjs";
+import encodePrintableString from "../codecs/ber/encoders/encodePrintableString.mjs";
+import encodeVisibleString from "../codecs/ber/encoders/encodeVisibleString.mjs";
+import encodeGeneralString from "../codecs/ber/encoders/encodeGeneralString.mjs";
+import decodeGraphicString from "../codecs/x690/decoders/decodeGraphicString.mjs";
+import decodeNumericString from "../codecs/x690/decoders/decodeNumericString.mjs";
+import decodeObjectDescriptor from "../codecs/x690/decoders/decodeObjectDescriptor.mjs";
+import decodePrintableString from "../codecs/x690/decoders/decodePrintableString.mjs";
+import decodeVisibleString from "../codecs/x690/decoders/decodeVisibleString.mjs";
+import decodeGeneralString from "../codecs/x690/decoders/decodeGeneralString.mjs";
+import encodeDuration from "../codecs/x690/encoders/encodeDuration.mjs";
+import decodeDuration from "../codecs/der/decoders/decodeDuration.mjs";
+import X690Element from "../x690.mjs";
+import { isUniquelyTagged } from "../utils/index.mjs";
+import { Buffer } from "node:buffer";
+export default class DERElement extends X690Element {
+    _value = new Uint8Array(0);
+    _currentValueLength;
     get value() {
         if (this._value instanceof Uint8Array) {
             return this._value;
         }
-        const bytes = (0, encodeSequence_1.default)(this._value);
+        const bytes = encodeSequence(this._value);
         this._value = bytes;
         return bytes;
     }
@@ -96,112 +60,112 @@ class DERElement extends x690_1.default {
         this._value = els;
     }
     set boolean(value) {
-        this.value = (0, encodeBoolean_1.default)(value);
+        this.value = encodeBoolean(value);
     }
     get boolean() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("BOOLEAN cannot be constructed.", this);
         }
-        return (0, decodeBoolean_1.default)(this.value);
+        return decodeBoolean(this.value);
     }
     set bitString(value) {
-        this.value = (0, encodeBitString_1.default)(value);
+        this.value = encodeBitString(value);
     }
     get bitString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("BIT STRING cannot be constructed.", this);
         }
-        return (0, decodeBitString_1.default)(this.value);
+        return decodeBitString(this.value);
     }
     set octetString(value) {
         this.value = new Uint8Array(value);
     }
     get octetString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("OCTET STRING cannot be constructed.", this);
         }
         return new Uint8Array(this.value);
     }
     set objectDescriptor(value) {
-        this.value = (0, encodeObjectDescriptor_1.default)(value);
+        this.value = encodeObjectDescriptor(value);
     }
     get objectDescriptor() {
-        return (0, decodeObjectDescriptor_1.default)(this.value);
+        return decodeObjectDescriptor(this.value);
     }
     set external(value) {
-        this.value = (0, encodeExternal_1.default)(value);
-        this.construction = values_1.ASN1Construction.constructed;
+        this.value = encodeExternal(value);
+        this.construction = ASN1Construction.constructed;
     }
     get external() {
-        if (this.construction !== values_1.ASN1Construction.constructed) {
+        if (this.construction !== ASN1Construction.constructed) {
             throw new errors.ASN1ConstructionError("EXTERNAL cannot be primitively-constructed.", this);
         }
-        return (0, decodeExternal_1.default)(this.value);
+        return decodeExternal(this.value);
     }
     set real(value) {
-        this.value = (0, encodeReal_1.default)(value);
+        this.value = encodeReal(value);
     }
     get real() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("REAL cannot be constructed.", this);
         }
-        return (0, decodeReal_1.default)(this.value);
+        return decodeReal(this.value);
     }
     set embeddedPDV(value) {
-        this.value = (0, encodeEmbeddedPDV_1.default)(value);
-        this.construction = values_1.ASN1Construction.constructed;
+        this.value = encodeEmbeddedPDV(value);
+        this.construction = ASN1Construction.constructed;
     }
     get embeddedPDV() {
-        if (this.construction !== values_1.ASN1Construction.constructed) {
+        if (this.construction !== ASN1Construction.constructed) {
             throw new errors.ASN1ConstructionError("EMBEDDED PDV cannot be primitively-constructed.", this);
         }
-        return (0, decodeEmbeddedPDV_1.default)(this.value);
+        return decodeEmbeddedPDV(this.value);
     }
     set utf8String(value) {
-        this.value = (0, convertTextToBytes_1.default)(value);
+        this.value = convertTextToBytes(value);
     }
     get utf8String() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("UTF8String cannot be constructed.", this);
         }
-        return (0, convertBytesToText_1.default)(this.value);
+        return convertBytesToText(this.value);
     }
     set sequence(value) {
         this.construct(value);
-        this.construction = values_1.ASN1Construction.constructed;
+        this.construction = ASN1Construction.constructed;
     }
     get sequence() {
-        if (this.construction !== values_1.ASN1Construction.constructed) {
+        if (this.construction !== ASN1Construction.constructed) {
             throw new errors.ASN1ConstructionError("SET or SEQUENCE cannot be primitively constructed.", this);
         }
         if (Array.isArray(this._value)) {
             return this._value;
         }
-        return (0, decodeSequence_1.default)(this.value);
+        return decodeSequence(this.value);
     }
     set set(value) {
-        (0, sortCanonically_1.default)(value);
+        sortCanonically(value);
         this.sequence = value;
     }
     get set() {
         const ret = this.sequence;
-        if (!(0, utils_1.isUniquelyTagged)(ret)) {
+        if (!isUniquelyTagged(ret)) {
             throw new errors.ASN1ConstructionError("Duplicate tag in SET.", this);
         }
         return ret;
     }
     set sequenceOf(value) {
         this.construct(value);
-        this.construction = values_1.ASN1Construction.constructed;
+        this.construction = ASN1Construction.constructed;
     }
     get sequenceOf() {
-        if (this.construction !== values_1.ASN1Construction.constructed) {
+        if (this.construction !== ASN1Construction.constructed) {
             throw new errors.ASN1ConstructionError("SET or SEQUENCE cannot be primitively constructed.", this);
         }
         if (Array.isArray(this._value)) {
             return this._value;
         }
-        return (0, decodeSequence_1.default)(this.value);
+        return decodeSequence(this.value);
     }
     set setOf(value) {
         this.sequence = value;
@@ -210,22 +174,22 @@ class DERElement extends x690_1.default {
         return this.sequence;
     }
     set numericString(value) {
-        this.value = (0, encodeNumericString_1.default)(value);
+        this.value = encodeNumericString(value);
     }
     get numericString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("NumericString cannot be constructed.", this);
         }
-        return (0, decodeNumericString_1.default)(this.value);
+        return decodeNumericString(this.value);
     }
     set printableString(value) {
-        this.value = (0, encodePrintableString_1.default)(value);
+        this.value = encodePrintableString(value);
     }
     get printableString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("PrintableString cannot be constructed.", this);
         }
-        return (0, decodePrintableString_1.default)(this.value);
+        return decodePrintableString(this.value);
     }
     set teletexString(value) {
         this.value = new Uint8Array(value);
@@ -240,65 +204,65 @@ class DERElement extends x690_1.default {
         return this.octetString;
     }
     set ia5String(value) {
-        this.value = (0, convertTextToBytes_1.default)(value);
+        this.value = convertTextToBytes(value);
     }
     get ia5String() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("IA5String cannot be constructed.", this);
         }
-        return (0, convertBytesToText_1.default)(this.value);
+        return convertBytesToText(this.value);
     }
     set utcTime(value) {
-        this.value = (0, encodeUTCTime_1.default)(value);
+        this.value = encodeUTCTime(value);
     }
     get utcTime() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("UTCTime cannot be constructed.", this);
         }
-        return (0, decodeUTCTime_1.default)(this.value);
+        return decodeUTCTime(this.value);
     }
     set generalizedTime(value) {
-        this.value = (0, encodeGeneralizedTime_1.default)(value);
+        this.value = encodeGeneralizedTime(value);
     }
     get generalizedTime() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("GeneralizedTime cannot be constructed.", this);
         }
-        return (0, decodeGeneralizedTime_1.default)(this.value);
+        return decodeGeneralizedTime(this.value);
     }
     set graphicString(value) {
-        this.value = (0, encodeGraphicString_1.default)(value);
+        this.value = encodeGraphicString(value);
     }
     get graphicString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("GraphicString cannot be constructed.", this);
         }
-        return (0, decodeGraphicString_1.default)(this.value);
+        return decodeGraphicString(this.value);
     }
     set visibleString(value) {
-        this.value = (0, encodeVisibleString_1.default)(value);
+        this.value = encodeVisibleString(value);
     }
     get visibleString() {
-        return (0, decodeVisibleString_1.default)(this.value);
+        return decodeVisibleString(this.value);
     }
     set generalString(value) {
-        this.value = (0, encodeGeneralString_1.default)(value);
+        this.value = encodeGeneralString(value);
     }
     get generalString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("GeneralString cannot be constructed.", this);
         }
-        return (0, decodeGeneralString_1.default)(this.value);
+        return decodeGeneralString(this.value);
     }
     set characterString(value) {
-        this.value = (0, encodeCharacterString_1.default)(value);
-        this.construction = values_1.ASN1Construction.constructed;
+        this.value = encodeCharacterString(value);
+        this.construction = ASN1Construction.constructed;
     }
     get characterString() {
-        if (this.construction !== values_1.ASN1Construction.constructed) {
+        if (this.construction !== ASN1Construction.constructed) {
             throw new errors.ASN1ConstructionError("CHARACTER STRING cannot be primitively-constructed.", this);
         }
-        return (0, decodeCharacterString_1.default)(this.value);
+        return decodeCharacterString(this.value);
     }
     set universalString(value) {
         const buf = new Uint8Array(value.length << 2);
@@ -311,7 +275,7 @@ class DERElement extends x690_1.default {
         this.value = buf;
     }
     get universalString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("UniversalString cannot be constructed.", this);
         }
         if (this.value.length % 4) {
@@ -335,13 +299,13 @@ class DERElement extends x690_1.default {
         this.value = buf;
     }
     get bmpString() {
-        if (this.construction !== values_1.ASN1Construction.primitive) {
+        if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("BMPString cannot be constructed.", this);
         }
         if (this.value.length % 2)
             throw new errors.ASN1Error("BMPString encoded on non-mulitple of two bytes.", this);
-        if (typeof node_buffer_1.Buffer !== "undefined") {
-            const swappedEndianness = node_buffer_1.Buffer.allocUnsafe(this.value.length);
+        if (typeof Buffer !== "undefined") {
+            const swappedEndianness = Buffer.allocUnsafe(this.value.length);
             for (let i = 0; i < this.value.length; i += 2) {
                 swappedEndianness[i] = this.value[i + 1];
                 swappedEndianness[i + 1] = this.value[i];
@@ -356,10 +320,10 @@ class DERElement extends x690_1.default {
         }
     }
     set duration(value) {
-        this.value = (0, encodeDuration_1.default)(value);
+        this.value = encodeDuration(value);
     }
     get duration() {
-        return (0, decodeDuration_1.default)(this.value);
+        return decodeDuration(this.value);
     }
     encode(value) {
         switch (typeof value) {
@@ -368,52 +332,52 @@ class DERElement extends x690_1.default {
                 break;
             }
             case ("boolean"): {
-                this.tagNumber = values_1.ASN1UniversalType.boolean;
+                this.tagNumber = ASN1UniversalType.boolean;
                 this.boolean = value;
                 break;
             }
             case ("number"): {
                 if (Number.isInteger(value)) {
-                    this.tagNumber = values_1.ASN1UniversalType.integer;
+                    this.tagNumber = ASN1UniversalType.integer;
                     this.integer = value;
                 }
                 else {
-                    this.tagNumber = values_1.ASN1UniversalType.realNumber;
+                    this.tagNumber = ASN1UniversalType.realNumber;
                     this.real = value;
                 }
                 break;
             }
             case ("bigint"): {
-                this.tagNumber = values_1.ASN1UniversalType.integer;
+                this.tagNumber = ASN1UniversalType.integer;
                 this.integer = value;
                 break;
             }
             case ("string"): {
-                this.tagNumber = values_1.ASN1UniversalType.utf8String;
+                this.tagNumber = ASN1UniversalType.utf8String;
                 this.utf8String = value;
                 break;
             }
             case ("object"): {
                 if (!value) {
-                    this.tagNumber = values_1.ASN1UniversalType.nill;
+                    this.tagNumber = ASN1UniversalType.nill;
                     this.value = new Uint8Array(0);
                 }
                 else if (value instanceof Uint8Array) {
-                    this.tagNumber = values_1.ASN1UniversalType.octetString;
+                    this.tagNumber = ASN1UniversalType.octetString;
                     this.octetString = value;
                 }
                 else if (value instanceof Uint8ClampedArray) {
-                    this.tagNumber = values_1.ASN1UniversalType.bitString;
+                    this.tagNumber = ASN1UniversalType.bitString;
                     this.bitString = value;
                 }
-                else if (value instanceof asn1_1.default) {
-                    this.construction = values_1.ASN1Construction.constructed;
+                else if (value instanceof ASN1Element) {
+                    this.construction = ASN1Construction.constructed;
                     this.sequence = [value];
                 }
                 else if (value instanceof Set) {
-                    this.construction = values_1.ASN1Construction.constructed;
+                    this.construction = ASN1Construction.constructed;
                     this.set = Array.from(value).map((v) => {
-                        if (typeof v === "object" && v instanceof asn1_1.default) {
+                        if (typeof v === "object" && v instanceof ASN1Element) {
                             return v;
                         }
                         else {
@@ -423,13 +387,13 @@ class DERElement extends x690_1.default {
                         }
                     });
                 }
-                else if ((value instanceof ObjectIdentifier_1.default) || (value.constructor?.name === "ObjectIdentifier")) {
-                    this.tagNumber = values_1.ASN1UniversalType.objectIdentifier;
+                else if ((value instanceof ObjectIdentifier) || (value.constructor?.name === "ObjectIdentifier")) {
+                    this.tagNumber = ASN1UniversalType.objectIdentifier;
                     this.objectIdentifier = value;
                 }
                 else if (Array.isArray(value)) {
-                    this.construction = values_1.ASN1Construction.constructed;
-                    this.tagNumber = values_1.ASN1UniversalType.sequence;
+                    this.construction = ASN1Construction.constructed;
+                    this.tagNumber = ASN1UniversalType.sequence;
                     this.sequence = value.map((sub) => {
                         const ret = new DERElement();
                         ret.encode(sub);
@@ -450,22 +414,22 @@ class DERElement extends x690_1.default {
         }
     }
     static fromSequence(sequence) {
-        const ret = new DERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.constructed, values_1.ASN1UniversalType.sequence);
+        const ret = new DERElement(ASN1TagClass.universal, ASN1Construction.constructed, ASN1UniversalType.sequence);
         ret.sequence = sequence.filter((element) => Boolean(element));
         return ret;
     }
     static fromSet(set) {
-        const ret = new DERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.constructed, values_1.ASN1UniversalType.set);
+        const ret = new DERElement(ASN1TagClass.universal, ASN1Construction.constructed, ASN1UniversalType.set);
         ret.set = set.filter((element) => Boolean(element));
         return ret;
     }
     static fromSetOf(set) {
-        const ret = new DERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.constructed, values_1.ASN1UniversalType.set);
+        const ret = new DERElement(ASN1TagClass.universal, ASN1Construction.constructed, ASN1UniversalType.set);
         ret.setOf = set.filter((element) => Boolean(element));
         return ret;
     }
     get inner() {
-        if (this.construction !== values_1.ASN1Construction.constructed) {
+        if (this.construction !== ASN1Construction.constructed) {
             throw new errors.ASN1ConstructionError("An explicitly-encoded element cannot be encoded using "
                 + "primitive construction.", this);
         }
@@ -486,12 +450,11 @@ class DERElement extends x690_1.default {
         return ret;
     }
     set inner(value) {
-        this.construction = values_1.ASN1Construction.constructed;
+        this.construction = ASN1Construction.constructed;
         this._value = [value];
     }
-    constructor(tagClass = values_1.ASN1TagClass.universal, construction = values_1.ASN1Construction.primitive, tagNumber = values_1.ASN1UniversalType.endOfContent, value = undefined) {
+    constructor(tagClass = ASN1TagClass.universal, construction = ASN1Construction.primitive, tagNumber = ASN1UniversalType.endOfContent, value = undefined) {
         super();
-        this._value = new Uint8Array(0);
         this.encode(value);
         this.tagClass = tagClass;
         this.construction = construction;
@@ -504,21 +467,21 @@ class DERElement extends x690_1.default {
         let cursor = 0;
         switch (bytes[cursor] & 0b11000000) {
             case (0b00000000):
-                this.tagClass = values_1.ASN1TagClass.universal;
+                this.tagClass = ASN1TagClass.universal;
                 break;
             case (0b01000000):
-                this.tagClass = values_1.ASN1TagClass.application;
+                this.tagClass = ASN1TagClass.application;
                 break;
             case (0b10000000):
-                this.tagClass = values_1.ASN1TagClass.context;
+                this.tagClass = ASN1TagClass.context;
                 break;
             case (0b11000000):
-                this.tagClass = values_1.ASN1TagClass.private;
+                this.tagClass = ASN1TagClass.private;
                 break;
-            default: this.tagClass = values_1.ASN1TagClass.universal;
+            default: this.tagClass = ASN1TagClass.universal;
         }
         this.construction = ((bytes[cursor] & 0b00100000)
-            ? values_1.ASN1Construction.constructed : values_1.ASN1Construction.primitive);
+            ? ASN1Construction.constructed : ASN1Construction.primitive);
         this.tagNumber = (bytes[cursor] & 0b00011111);
         cursor++;
         if (this.tagNumber >= 31) {
@@ -695,4 +658,3 @@ class DERElement extends x690_1.default {
             + value_len);
     }
 }
-exports.default = DERElement;

package/dist/{node/codecs/x690/decoders/decodeCharacterString.d.ts → codecs/x690/decoders/decodeCharacterString.d.mts}

@@ -1,2 +1,2 @@
-import CharacterString from "../../../types/CharacterString";
+import CharacterString from "../../../types/CharacterString.mjs";
 export default function decodeCharacterString(value: Uint8Array): CharacterString;

package/dist/codecs/x690/decoders/decodeCharacterString.mjs

@@ -0,0 +1,12 @@
+import CharacterString from "../../../types/CharacterString.mjs";
+import decodeSequence from "../../der/decoders/decodeSequence.mjs";
+import { ASN1ConstructionError } from "../../../errors.mjs";
+export default function decodeCharacterString(value) {
+    const components = decodeSequence(value);
+    if (components.length !== 2) {
+        throw new ASN1ConstructionError(`CharacterString must contain 2 components, not ${components.length}.`);
+    }
+    const identification = components[0];
+    const stringValue = components[1].octetString;
+    return new CharacterString(identification, stringValue);
+}

package/dist/{node/codecs/x690/decoders/decodeDate.d.ts → codecs/x690/decoders/decodeDate.d.mts}

@@ -1,2 +1,2 @@
-import { DATE } from "../../../macros";
+import { DATE } from "../../../macros.mjs";
 export default function decodeDate(bytes: Uint8Array): DATE;

package/dist/codecs/x690/decoders/decodeDate.mjs

@@ -0,0 +1,10 @@
+import convertBytesToText from "../../../utils/convertBytesToText.mjs";
+import validateDate from "../../../validators/validateDate.mjs";
+export default function decodeDate(bytes) {
+    const str = convertBytesToText(bytes);
+    const year = parseInt(str.slice(0, 4), 10);
+    const month = parseInt(str.slice(4, 6), 10) - 1;
+    const day = parseInt(str.slice(6, 8), 10);
+    validateDate("DATE", year, month, day);
+    return new Date(year, month, day);
+}

package/dist/{node/codecs/x690/decoders/decodeDateTime.d.ts → codecs/x690/decoders/decodeDateTime.d.mts}

@@ -1,2 +1,2 @@
-import { DATE_TIME } from "../../../macros";
+import { DATE_TIME } from "../../../macros.mjs";
 export default function decodeDateTime(bytes: Uint8Array): DATE_TIME;