asn1-ts 8.0.5 → 9.0.1

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

@@ -1,91 +1,55 @@
-"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 x690_1 = __importDefault(require("../x690"));
-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("./cer/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 splitOctetsCanonically_1 = __importDefault(require("../utils/splitOctetsCanonically"));
-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 macros_1 = require("../macros");
-const utils_1 = require("../utils");
-const node_buffer_1 = require("node:buffer");
-class CERElement extends x690_1.default {
+import ASN1Element from "../asn1.mjs";
+import * as errors from "../errors.mjs";
+import { ASN1Construction, ASN1TagClass, ASN1UniversalType, } from "../values.mjs";
+import X690Element from "../x690.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 "./cer/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 splitOctetsCanonically from "../utils/splitOctetsCanonically.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 { FALSE_BIT, } from "../macros.mjs";
+import { isUniquelyTagged } from "../utils/index.mjs";
+import { Buffer } from "node:buffer";
+export default class CERElement 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;
     }
@@ -102,31 +66,31 @@ class CERElement extends x690_1.default {
     }
     set unfragmentedValue(value) {
         if (value.length <= 1000) {
-            this.construction = values_1.ASN1Construction.primitive;
+            this.construction = ASN1Construction.primitive;
             this.value = value;
         }
         else {
-            this.construction = values_1.ASN1Construction.constructed;
-            this.value = (0, encodeSequence_1.default)(Array
-                .from((0, splitOctetsCanonically_1.default)(value))
-                .map((fragment) => new CERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.primitive, values_1.ASN1UniversalType.octetString, new Uint8Array(fragment))));
+            this.construction = ASN1Construction.constructed;
+            this.value = encodeSequence(Array
+                .from(splitOctetsCanonically(value))
+                .map((fragment) => new CERElement(ASN1TagClass.universal, ASN1Construction.primitive, ASN1UniversalType.octetString, new Uint8Array(fragment))));
         }
     }
     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.unfragmentedValue = (0, encodeBitString_1.default)(value);
+        this.unfragmentedValue = encodeBitString(value);
     }
     get bitString() {
-        if (this.construction === values_1.ASN1Construction.primitive) {
-            return (0, decodeBitString_1.default)(this.value);
+        if (this.construction === ASN1Construction.primitive) {
+            return decodeBitString(this.value);
         }
         if ((this.recursionCount + 1) > CERElement.nestingRecursionLimit) {
             throw new errors.ASN1RecursionError();
@@ -134,7 +98,7 @@ class CERElement extends x690_1.default {
         const appendy = [];
         const substrings = this.sequence;
         for (const substring of substrings.slice(0, (substrings.length - 1))) {
-            if (substring.construction === values_1.ASN1Construction.primitive
+            if (substring.construction === ASN1Construction.primitive
                 && substring.value.length > 0
                 && substring.value[0] !== 0x00) {
                 throw new errors.ASN1Error("Only the last subelement of a constructed BIT STRING may have a non-zero first value byte.", this);
@@ -148,7 +112,7 @@ class CERElement extends x690_1.default {
                 throw new errors.ASN1ConstructionError("Invalid tag class in recursively-encoded BIT STRING.", this);
             }
             substring.recursionCount = (this.recursionCount + 1);
-            appendy.push(...Array.from(substring.bitString).map((b) => b !== macros_1.FALSE_BIT));
+            appendy.push(...Array.from(substring.bitString).map((b) => b !== FALSE_BIT));
         }
         return new Uint8ClampedArray(appendy.map((b) => (b ? 1 : 0)));
     }
@@ -159,76 +123,76 @@ class CERElement extends x690_1.default {
         return this.deconstruct("OCTET STRING");
     }
     set objectDescriptor(value) {
-        this.unfragmentedValue = (0, encodeObjectDescriptor_1.default)(value);
+        this.unfragmentedValue = encodeObjectDescriptor(value);
     }
     get objectDescriptor() {
-        return (0, decodeObjectDescriptor_1.default)(this.deconstruct("ObjectDescriptor"));
+        return decodeObjectDescriptor(this.deconstruct("ObjectDescriptor"));
     }
     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() {
-        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.");
         }
-        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() {
-        return (0, decodeEmbeddedPDV_1.default)(this.value);
+        return decodeEmbeddedPDV(this.value);
     }
     set utf8String(value) {
-        this.unfragmentedValue = (0, convertTextToBytes_1.default)(value);
+        this.unfragmentedValue = convertTextToBytes(value);
     }
     get utf8String() {
-        return (0, convertBytesToText_1.default)(this.deconstruct("UTF8String"));
+        return convertBytesToText(this.deconstruct("UTF8String"));
     }
     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;
@@ -237,16 +201,16 @@ class CERElement extends x690_1.default {
         return this.sequence;
     }
     set numericString(value) {
-        this.unfragmentedValue = (0, encodeNumericString_1.default)(value);
+        this.unfragmentedValue = encodeNumericString(value);
     }
     get numericString() {
-        return (0, decodeNumericString_1.default)(this.deconstruct("NumericString"));
+        return decodeNumericString(this.deconstruct("NumericString"));
     }
     set printableString(value) {
-        this.unfragmentedValue = (0, encodePrintableString_1.default)(value);
+        this.unfragmentedValue = encodePrintableString(value);
     }
     get printableString() {
-        return (0, decodePrintableString_1.default)(this.deconstruct("PrintableString"));
+        return decodePrintableString(this.deconstruct("PrintableString"));
     }
     set teletexString(value) {
         this.unfragmentedValue = new Uint8Array(value);
@@ -261,47 +225,47 @@ class CERElement extends x690_1.default {
         return this.deconstruct("VideotexString");
     }
     set ia5String(value) {
-        this.unfragmentedValue = (0, convertTextToBytes_1.default)(value);
+        this.unfragmentedValue = convertTextToBytes(value);
     }
     get ia5String() {
-        return (0, convertBytesToText_1.default)(this.deconstruct("IA5String"));
+        return convertBytesToText(this.deconstruct("IA5String"));
     }
     set utcTime(value) {
-        this.value = (0, encodeUTCTime_1.default)(value);
+        this.value = encodeUTCTime(value);
     }
     get utcTime() {
-        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() {
-        return (0, decodeGeneralizedTime_1.default)(this.value);
+        return decodeGeneralizedTime(this.value);
     }
     set graphicString(value) {
-        this.unfragmentedValue = (0, encodeGraphicString_1.default)(value);
+        this.unfragmentedValue = encodeGraphicString(value);
     }
     get graphicString() {
-        return (0, decodeGraphicString_1.default)(this.deconstruct("GraphicString"));
+        return decodeGraphicString(this.deconstruct("GraphicString"));
     }
     set visibleString(value) {
-        this.unfragmentedValue = (0, encodeVisibleString_1.default)(value);
+        this.unfragmentedValue = encodeVisibleString(value);
     }
     get visibleString() {
-        return (0, decodeVisibleString_1.default)(this.deconstruct("VisibleString"));
+        return decodeVisibleString(this.deconstruct("VisibleString"));
     }
     set generalString(value) {
-        this.unfragmentedValue = (0, encodeGeneralString_1.default)(value);
+        this.unfragmentedValue = encodeGeneralString(value);
     }
     get generalString() {
-        return (0, decodeGeneralString_1.default)(this.deconstruct("GeneralString"));
+        return decodeGeneralString(this.deconstruct("GeneralString"));
     }
     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() {
-        return (0, decodeCharacterString_1.default)(this.value);
+        return decodeCharacterString(this.value);
     }
     set universalString(value) {
         const buf = new Uint8Array(value.length << 2);
@@ -339,8 +303,8 @@ class CERElement extends x690_1.default {
         const valueBytes = this.deconstruct("BMPString");
         if (valueBytes.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(valueBytes.length);
+        if (typeof Buffer !== "undefined") {
+            const swappedEndianness = Buffer.allocUnsafe(valueBytes.length);
             for (let i = 0; i < valueBytes.length; i += 2) {
                 swappedEndianness[i] = valueBytes[i + 1];
                 swappedEndianness[i + 1] = valueBytes[i];
@@ -348,17 +312,17 @@ class CERElement extends x690_1.default {
             return swappedEndianness.toString("utf16le");
         }
         else if (typeof TextEncoder !== "undefined") {
-            return (new TextDecoder("utf-16be")).decode(valueBytes.buffer);
+            return (new TextDecoder("utf-16be")).decode(valueBytes);
         }
         else {
             throw new errors.ASN1Error("Neither TextDecoder nor Buffer are defined to decode bytes into text.", this);
         }
     }
     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) {
@@ -367,52 +331,52 @@ class CERElement 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 {
@@ -422,13 +386,13 @@ class CERElement 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 CERElement();
                         ret.encode(sub);
@@ -449,22 +413,22 @@ class CERElement extends x690_1.default {
         }
     }
     static fromSequence(sequence) {
-        const ret = new CERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.constructed, values_1.ASN1UniversalType.sequence);
+        const ret = new CERElement(ASN1TagClass.universal, ASN1Construction.constructed, ASN1UniversalType.sequence);
         ret.sequence = sequence.filter((element) => Boolean(element));
         return ret;
     }
     static fromSet(set) {
-        const ret = new CERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.constructed, values_1.ASN1UniversalType.set);
+        const ret = new CERElement(ASN1TagClass.universal, ASN1Construction.constructed, ASN1UniversalType.set);
         ret.set = set.filter((element) => Boolean(element));
         return ret;
     }
     static fromSetOf(set) {
-        const ret = new CERElement(values_1.ASN1TagClass.universal, values_1.ASN1Construction.constructed, values_1.ASN1UniversalType.set);
+        const ret = new CERElement(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);
         }
@@ -485,12 +449,11 @@ class CERElement 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;
@@ -506,21 +469,21 @@ class CERElement 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) {
@@ -582,7 +545,7 @@ class CERElement extends x690_1.default {
                 return (cursor + length);
             }
             else {
-                if (this.construction !== values_1.ASN1Construction.constructed) {
+                if (this.construction !== ASN1Construction.constructed) {
                     throw new errors.ASN1ConstructionError("Indefinite length ASN.1 element was not of constructed construction.", this);
                 }
                 const startOfValue = ++cursor;
@@ -590,9 +553,9 @@ class CERElement extends x690_1.default {
                 while (sentinel < bytes.length) {
                     const child = new CERElement();
                     sentinel += child.fromBytes(bytes.subarray(sentinel));
-                    if (child.tagClass === values_1.ASN1TagClass.universal
-                        && child.construction === values_1.ASN1Construction.primitive
-                        && child.tagNumber === values_1.ASN1UniversalType.endOfContent
+                    if (child.tagClass === ASN1TagClass.universal
+                        && child.construction === ASN1Construction.primitive
+                        && child.tagNumber === ASN1UniversalType.endOfContent
                         && child.value.length === 0)
                         break;
                 }
@@ -633,7 +596,7 @@ class CERElement extends x690_1.default {
         }
         let lengthOctets = [0x00];
         switch (this.construction) {
-            case (values_1.ASN1Construction.primitive): {
+            case (ASN1Construction.primitive): {
                 if (this.value.length < 127) {
                     lengthOctets[0] = this.value.length;
                 }
@@ -653,7 +616,7 @@ class CERElement extends x690_1.default {
                 }
                 break;
             }
-            case (values_1.ASN1Construction.constructed): {
+            case (ASN1Construction.constructed): {
                 lengthOctets = [0b10000000];
                 break;
             }
@@ -671,13 +634,13 @@ class CERElement extends x690_1.default {
             ...(Array.isArray(this._value)
                 ? this._value.flatMap((el) => el.toBuffers())
                 : [this._value]),
-            ...(this.construction === values_1.ASN1Construction.constructed
+            ...(this.construction === ASN1Construction.constructed
                 ? [new Uint8Array(2)]
                 : []),
         ];
     }
     deconstruct(dataType) {
-        if (this.construction === values_1.ASN1Construction.primitive) {
+        if (this.construction === ASN1Construction.primitive) {
             return new Uint8Array(this.value);
         }
         else {
@@ -686,17 +649,17 @@ class CERElement extends x690_1.default {
             const appendy = [];
             const substrings = this.sequence;
             for (const substring of substrings) {
-                if (substring.tagClass !== values_1.ASN1TagClass.universal) {
+                if (substring.tagClass !== ASN1TagClass.universal) {
                     throw new errors.ASN1ConstructionError(`Invalid tag class in constructed ${dataType}. Must be UNIVERSAL`, this);
                 }
-                if (substring.tagNumber !== values_1.ASN1UniversalType.octetString) {
+                if (substring.tagNumber !== ASN1UniversalType.octetString) {
                     throw new errors.ASN1ConstructionError(`Invalid tag number in constructed ${dataType}. Must be 4 (OCTET STRING).`, this);
                 }
                 substring.recursionCount = (this.recursionCount + 1);
                 const deconstructed = substring.deconstruct(dataType);
                 appendy.push(deconstructed);
             }
-            return node_buffer_1.Buffer.concat(appendy);
+            return Buffer.concat(appendy);
         }
     }
     get components() {
@@ -743,7 +706,7 @@ class CERElement extends x690_1.default {
         return len;
     }
     tlvLength() {
-        const eoc_bytes = (this.construction === values_1.ASN1Construction.constructed)
+        const eoc_bytes = (this.construction === ASN1Construction.constructed)
             ? 2
             : 0;
         const value_len = this.valueLength();
@@ -753,4 +716,3 @@ class CERElement extends x690_1.default {
             + eoc_bytes);
     }
 }
-exports.default = CERElement;