asn1-ts 8.0.5 → 9.0.1

package/dist/utils/index.mjs

@@ -0,0 +1,22 @@
+export { default as base128Length } from "./base128Length.mjs";
+export { default as decodeIEEE754DoublePrecisionFloat } from "./decodeIEEE754DoublePrecisionFloat.mjs";
+export { default as decodeIEEE754SinglePrecisionFloat } from "./decodeIEEE754SinglePrecisionFloat.mjs";
+export { default as decodeSignedBigEndianInteger } from "./decodeSignedBigEndianInteger.mjs";
+export { default as decodeUnsignedBigEndianInteger } from "./decodeUnsignedBigEndianInteger.mjs";
+export { default as decodeX690RealNumber } from "./decodeX690RealNumber.mjs";
+export { default as dissectFloat } from "./dissectFloat.mjs";
+export { default as encodeIEEE754DoublePrecisionFloat } from "./encodeIEEE754DoublePrecisionFloat.mjs";
+export { default as encodeIEEE754SinglePrecisionFloat } from "./encodeIEEE754SinglePrecisionFloat.mjs";
+export { default as encodeSignedBigEndianInteger } from "./encodeSignedBigEndianInteger.mjs";
+export { default as encodeUnsignedBigEndianInteger } from "./encodeUnsignedBigEndianInteger.mjs";
+export { default as encodeX690Base10RealNumber } from "./encodeX690Base10RealNumber.mjs";
+export { default as encodeX690BinaryRealNumber } from "./encodeX690BinaryRealNumber.mjs";
+export { default as getBitFromBase128 } from "./getBitFromBase128.mjs";
+export { default as getBitFromBase256 } from "./getBitFromBase256.mjs";
+export { default as isInCanonicalOrder } from "./isInCanonicalOrder.mjs";
+export { default as isUniquelyTagged } from "./isUniquelyTagged.mjs";
+export { default as packBits } from "./packBits.mjs";
+export { default as setBitInBase128 } from "./setBitInBase128.mjs";
+export { default as setBitInBase256 } from "./setBitInBase256.mjs";
+export { default as trimLeadingPaddingBytes } from "./trimLeadingPaddingBytes.mjs";
+export { default as unpackBits } from "./unpackBits.mjs";

package/dist/{node/utils/isInCanonicalOrder.d.ts → utils/isInCanonicalOrder.d.mts}

@@ -1,2 +1,2 @@
-import type ASN1Element from "../asn1";
+import type ASN1Element from "../asn1.mjs";
 export default function isInCanonicalOrder(elements: ASN1Element[]): boolean;

package/dist/{node/utils/isInCanonicalOrder.js → utils/isInCanonicalOrder.mjs}

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = isInCanonicalOrder;
-const values_1 = require("../values");
-function isInCanonicalOrder(elements) {
+import { CANONICAL_TAG_CLASS_ORDERING } from "../values.mjs";
+export default function isInCanonicalOrder(elements) {
     let previousTagClass = null;
     let previousTagNumber = null;
     return (elements.every((element) => {
         if (previousTagClass !== null
             && element.tagClass !== previousTagClass
-            && values_1.CANONICAL_TAG_CLASS_ORDERING.indexOf(element.tagClass)
-                <= values_1.CANONICAL_TAG_CLASS_ORDERING.indexOf(previousTagClass))
+            && CANONICAL_TAG_CLASS_ORDERING.indexOf(element.tagClass)
+                <= CANONICAL_TAG_CLASS_ORDERING.indexOf(previousTagClass))
             return false;
         if (element.tagClass !== previousTagClass)
             previousTagNumber = null;

package/dist/{node/utils/isUniquelyTagged.d.ts → utils/isUniquelyTagged.d.mts}

@@ -1,2 +1,2 @@
-import type ASN1Element from "../asn1";
+import type ASN1Element from "../asn1.mjs";
 export default function isUniquelyTagged(elements: ASN1Element[]): boolean;

package/dist/{node/utils/isUniquelyTagged.js → utils/isUniquelyTagged.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = isUniquelyTagged;
-function isUniquelyTagged(elements) {
+export default function isUniquelyTagged(elements) {
     const finds = new Set([]);
     for (let i = 0; i < elements.length; i++) {
         const key = ((elements[i].tagClass << 30)

package/dist/{node/utils/packBits.d.ts → utils/packBits.d.mts}

@@ -1,2 +1,2 @@
-import { BIT_STRING } from "../macros";
+import { BIT_STRING } from "../macros.mjs";
 export default function packBits(bits: BIT_STRING): Uint8Array;

package/dist/{node/utils/packBits.js → utils/packBits.mjs}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = packBits;
-const macros_1 = require("../macros");
-function packBits(bits) {
+import { FALSE_BIT } from "../macros.mjs";
+export default function packBits(bits) {
     const bytesNeeded = Math.ceil(bits.length / 8);
     const ret = new Uint8Array(bytesNeeded);
     let byte = -1;
@@ -11,7 +8,7 @@ function packBits(bits) {
         if (bitMod8 === 0) {
             byte++;
         }
-        if (bits[bit] !== macros_1.FALSE_BIT) {
+        if (bits[bit] !== FALSE_BIT) {
             ret[byte] |= (0x01 << (7 - bitMod8));
         }
     }

package/dist/{node/utils/setBitInBase128.js → utils/setBitInBase128.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = setBit;
-function setBit(to, bitIndex, value) {
+export default function setBit(to, bitIndex, value) {
     const byteIndex = to.length - (Math.floor(bitIndex / 7) + 1);
     if (value) {
         to[byteIndex] |= (0x01 << (bitIndex % 7));

package/dist/{node/utils/setBitInBase256.js → utils/setBitInBase256.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = setBitInBase256;
-function setBitInBase256(to, bitIndex, value) {
+export default function setBitInBase256(to, bitIndex, value) {
     const byteIndex = (to.length - (Math.floor(bitIndex / 8) + 1));
     if (value) {
         to[byteIndex] |= (0x01 << (bitIndex % 8));

package/dist/{node/utils/sortCanonically.d.ts → utils/sortCanonically.d.mts}

@@ -1,2 +1,2 @@
-import type ASN1Element from "../asn1";
+import type ASN1Element from "../asn1.mjs";
 export default function sortCanonically(elements: ASN1Element[]): ASN1Element[];

package/dist/utils/sortCanonically.mjs

@@ -0,0 +1,11 @@
+import { Buffer } from "node:buffer";
+export default function sortCanonically(elements) {
+    return elements.sort((a, b) => {
+        const aClassOrder = a.tagClass;
+        const bClassOrder = b.tagClass;
+        if (aClassOrder !== bClassOrder) {
+            return (aClassOrder - bClassOrder);
+        }
+        return Buffer.compare(a.toBytes(), b.toBytes());
+    });
+}

package/dist/utils/splitOctetsCanonically.mjs

@@ -0,0 +1,5 @@
+export default function* splitOctetsCanonically(value) {
+    for (let i = 0; i < value.length; i += 1000) {
+        yield value.subarray(i, i + 1000);
+    }
+}

package/dist/{node/utils/trimLeadingPaddingBytes.js → utils/trimLeadingPaddingBytes.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = trimLeadingPaddingBytes;
-function trimLeadingPaddingBytes(value) {
+export default function trimLeadingPaddingBytes(value) {
     if (value.length <= 1) {
         return value;
     }

package/dist/{node/utils/unpackBits.d.ts → utils/unpackBits.d.mts}

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

package/dist/{node/utils/unpackBits.js → utils/unpackBits.mjs}

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = unpackBits;
-const macros_1 = require("../macros");
-function unpackBits(bytes) {
+import { TRUE_BIT } from "../macros.mjs";
+export default function unpackBits(bytes) {
     const ret = new Uint8ClampedArray(bytes.length << 3);
     for (let byte = 0; byte < bytes.length; byte++) {
         for (let bit = 0; bit < 8; bit++) {
             if (bytes[byte] & (0x01 << (7 - bit))) {
-                ret[(byte << 3) + bit] = macros_1.TRUE_BIT;
+                ret[(byte << 3) + bit] = TRUE_BIT;
             }
         }
     }

package/dist/{node/validators/datetimeComponentValidator.d.ts → validators/datetimeComponentValidator.d.mts}

@@ -1,2 +1,2 @@
-import { INTEGER } from "../macros";
+import { INTEGER } from "../macros.mjs";
 export default function datetimeComponentValidator(unitName: string, min: INTEGER, max: INTEGER): (dataType: string, value: INTEGER) => void;

package/dist/validators/datetimeComponentValidator.mjs

@@ -0,0 +1,14 @@
+import * as errors from "../errors.mjs";
+export default function datetimeComponentValidator(unitName, min, max) {
+    return function (dataType, value) {
+        if (!Number.isInteger(value)) {
+            throw new errors.ASN1Error(`Non-integral ${unitName} supplied to ${dataType}.`);
+        }
+        if (value > max) {
+            throw new errors.ASN1Error(`Encountered ${unitName} greater than ${max} in ${dataType}.`);
+        }
+        if (value < min) {
+            throw new errors.ASN1Error(`Encountered ${unitName} less than ${min} in ${dataType}.`);
+        }
+    };
+}

package/dist/{node/validators/index.d.ts → validators/index.d.mts}

@@ -1,6 +1,6 @@
-export { default as isGeneralCharacter } from "./isGeneralCharacter";
-export { default as isGraphicCharacter } from "./isGraphicCharacter";
-export { default as isNumericCharacter } from "./isNumericCharacter";
-export { default as isObjectDescriptorCharacter } from "./isObjectDescriptorCharacter";
-export { default as isPrintableCharacter } from "./isPrintableCharacter";
-export { default as isVisibleCharacter } from "./isVisibleCharacter";
+export { default as isGeneralCharacter } from "./isGeneralCharacter.mjs";
+export { default as isGraphicCharacter } from "./isGraphicCharacter.mjs";
+export { default as isNumericCharacter } from "./isNumericCharacter.mjs";
+export { default as isObjectDescriptorCharacter } from "./isObjectDescriptorCharacter.mjs";
+export { default as isPrintableCharacter } from "./isPrintableCharacter.mjs";
+export { default as isVisibleCharacter } from "./isVisibleCharacter.mjs";

package/dist/validators/index.mjs

@@ -0,0 +1,6 @@
+export { default as isGeneralCharacter } from "./isGeneralCharacter.mjs";
+export { default as isGraphicCharacter } from "./isGraphicCharacter.mjs";
+export { default as isNumericCharacter } from "./isNumericCharacter.mjs";
+export { default as isObjectDescriptorCharacter } from "./isObjectDescriptorCharacter.mjs";
+export { default as isPrintableCharacter } from "./isPrintableCharacter.mjs";
+export { default as isVisibleCharacter } from "./isVisibleCharacter.mjs";

package/dist/validators/isGeneralCharacter.mjs

@@ -0,0 +1,3 @@
+export default function isGeneralCharacter(characterCode) {
+    return (characterCode <= 0x7F);
+}

package/dist/validators/isGraphicCharacter.mjs

@@ -0,0 +1,3 @@
+export default function isGraphicCharacter(characterCode) {
+    return (characterCode >= 0x20 && characterCode <= 0x7E);
+}

package/dist/validators/isNumericCharacter.mjs

@@ -0,0 +1,3 @@
+export default function isNumericString(characterCode) {
+    return ((characterCode >= 0x30 && characterCode <= 0x39) || characterCode === 0x20);
+}

package/dist/validators/isObjectDescriptorCharacter.mjs

@@ -0,0 +1,4 @@
+import isGraphicCharacter from "./isGraphicCharacter.mjs";
+export default function isObjectDescriptorCharacter(characterCode) {
+    return isGraphicCharacter(characterCode);
+}

package/dist/{node/validators/isPrintableCharacter.js → validators/isPrintableCharacter.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = isPrintableCharacter;
-function isPrintableCharacter(characterCode) {
+export default function isPrintableCharacter(characterCode) {
     return ((characterCode >= 0x27 && characterCode <= 0x39 && characterCode !== 0x2A)
         || (characterCode >= 0x41 && characterCode <= 0x5A)
         || (characterCode >= 0x61 && characterCode <= 0x7A)

package/dist/validators/isVisibleCharacter.mjs

@@ -0,0 +1,4 @@
+import isGraphicCharacter from "./isGraphicCharacter.mjs";
+export default function isVisibleCharacter(characterCode) {
+    return isGraphicCharacter(characterCode);
+}

package/dist/{node/validators/validateConstruction.d.ts → validators/validateConstruction.d.mts}

@@ -1,3 +1,3 @@
-import type ASN1Element from "../asn1";
-import type ConstructedElementSpecification from "../ConstructedElementSpecification";
+import type ASN1Element from "../asn1.mjs";
+import type ConstructedElementSpecification from "../ConstructedElementSpecification.mjs";
 export default function validateConstruction(elements: ASN1Element[], specification: ConstructedElementSpecification[]): void;

package/dist/validators/validateConstruction.mjs

@@ -0,0 +1,37 @@
+import * as errors from "../errors.mjs";
+export default function validateConstruction(elements, specification) {
+    let i = 0;
+    for (const spec of specification) {
+        if ((i >= elements.length)
+            || (spec.tagClass && spec.tagClass !== elements[i].tagClass)
+            || (spec.construction && spec.construction !== elements[i].construction)
+            || (spec.tagNumber && spec.tagNumber !== elements[i].tagNumber)) {
+            if (!spec.optional) {
+                throw new errors.ASN1ConstructionError(`Missing required element '${spec.name}'.`);
+            }
+            continue;
+        }
+        if (spec.choice && spec.choice.length > 0) {
+            let matchingChoiceFound = false;
+            for (let j = 0; j < spec.choice.length; j++) {
+                const choice = spec.choice[j];
+                if ((!(choice.tagClass) || (choice.tagClass === elements[i].tagClass))
+                    && (!(choice.construction) || (choice.construction === elements[i].construction))
+                    && (!(choice.tagNumber) || (choice.tagNumber === elements[i].tagNumber))) {
+                    if (choice.callback) {
+                        choice.callback(elements[i]);
+                    }
+                    matchingChoiceFound = true;
+                    break;
+                }
+            }
+            if (!matchingChoiceFound && !spec.optional) {
+                throw new errors.ASN1ConstructionError(`Missing required CHOICE '${spec.name}'.`);
+            }
+        }
+        if (spec.callback) {
+            spec.callback(elements[i]);
+        }
+        i++;
+    }
+}

package/dist/validators/validateDate.mjs

@@ -0,0 +1,49 @@
+import * as errors from "../errors.mjs";
+export default function validateDate(dataType, year, month, date) {
+    if (!Number.isSafeInteger(year)) {
+        throw new errors.ASN1Error(`Invalid year in ${dataType}`);
+    }
+    if (!Number.isSafeInteger(month)) {
+        throw new errors.ASN1Error(`Invalid month in ${dataType}`);
+    }
+    if (!Number.isSafeInteger(date) || (date < 1)) {
+        throw new errors.ASN1Error(`Invalid day in ${dataType}`);
+    }
+    switch (month) {
+        case 0:
+        case 2:
+        case 4:
+        case 6:
+        case 7:
+        case 9:
+        case 11: {
+            if (date > 31) {
+                throw new errors.ASN1Error(`Day > 31 encountered in ${dataType} with 31-day month.`);
+            }
+            break;
+        }
+        case 3:
+        case 5:
+        case 8:
+        case 10: {
+            if (date > 30) {
+                throw new errors.ASN1Error(`Day > 31 encountered in ${dataType} with 30-day month.`);
+            }
+            break;
+        }
+        case 1: {
+            const isLeapYear = ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0);
+            if (isLeapYear) {
+                if (date > 29) {
+                    throw new errors.ASN1Error(`Day > 29 encountered in ${dataType} with month of February in leap year.`);
+                }
+            }
+            else if (date > 28) {
+                throw new errors.ASN1Error(`Day > 28 encountered in ${dataType} with month of February and non leap year.`);
+            }
+            break;
+        }
+        default:
+            throw new errors.ASN1Error(`Invalid month in ${dataType}`);
+    }
+}

package/dist/validators/validateDateTime.mjs

@@ -0,0 +1,6 @@
+import validateDate from "./validateDate.mjs";
+import validateTime from "./validateTime.mjs";
+export default function validateDateTime(dataType, year, month, date, hours, minutes, seconds) {
+    validateDate(dataType, year, month, date);
+    validateTime(dataType, hours, minutes, seconds);
+}

package/dist/validators/validateTime.mjs

@@ -0,0 +1,21 @@
+import * as errors from "../errors.mjs";
+export default function validateTime(dataType, hours, minutes, seconds) {
+    if (!Number.isSafeInteger(hours)) {
+        throw new errors.ASN1Error(`Invalid hours in ${dataType}`);
+    }
+    if (!Number.isSafeInteger(minutes)) {
+        throw new errors.ASN1Error(`Invalid minutes in ${dataType}`);
+    }
+    if (!Number.isSafeInteger(seconds) || (seconds < 0)) {
+        throw new errors.ASN1Error(`Invalid seconds in ${dataType}`);
+    }
+    if (hours > 23) {
+        throw new errors.ASN1Error(`Hours > 23 encountered in ${dataType}.`);
+    }
+    if (minutes > 59) {
+        throw new errors.ASN1Error(`Minutes > 60 encountered in ${dataType}.`);
+    }
+    if (seconds > 59) {
+        throw new errors.ASN1Error(`Seconds > 60 encountered in ${dataType}.`);
+    }
+}

package/dist/{node/values.js → values.mjs}

@@ -1,48 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.datetimeRegex = exports.numberRegex = exports.CANONICAL_TAG_CLASS_ORDERING = exports.distinguishedNR3Regex = exports.canonicalNR3Regex = exports.nr3Regex = exports.nr2Regex = exports.nr1Regex = exports.distinguishedGeneralizedTimeRegex = exports.generalizedTimeRegex = exports.distinguishedUTCTimeRegex = exports.utcTimeRegex = exports.printableStringCharacters = exports.ASN1UniversalType = exports.ASN1RealEncodingScale = exports.ASN1RealEncodingBase = exports.ASN1SpecialRealValue = exports.LengthEncodingPreference = exports.ASN1Construction = exports.ASN1TagClass = exports.MIN_SINT_32 = exports.MAX_SINT_32 = exports.MIN_UINT_32 = exports.MAX_UINT_32 = void 0;
-exports.MAX_UINT_32 = 0x00FFFFFFFF;
-exports.MIN_UINT_32 = 0x0000000000;
-exports.MAX_SINT_32 = 0x7FFFFFFF;
-exports.MIN_SINT_32 = -0x80000000;
-var ASN1TagClass;
+export const MAX_UINT_32 = 0x00FFFFFFFF;
+export const MIN_UINT_32 = 0x0000000000;
+export const MAX_SINT_32 = 0x7FFFFFFF;
+export const MIN_SINT_32 = -0x80000000;
+export var ASN1TagClass;
 (function (ASN1TagClass) {
     ASN1TagClass[ASN1TagClass["universal"] = 0] = "universal";
     ASN1TagClass[ASN1TagClass["application"] = 1] = "application";
     ASN1TagClass[ASN1TagClass["context"] = 2] = "context";
     ASN1TagClass[ASN1TagClass["private"] = 3] = "private";
-})(ASN1TagClass || (exports.ASN1TagClass = ASN1TagClass = {}));
-var ASN1Construction;
+})(ASN1TagClass || (ASN1TagClass = {}));
+export var ASN1Construction;
 (function (ASN1Construction) {
     ASN1Construction[ASN1Construction["primitive"] = 0] = "primitive";
     ASN1Construction[ASN1Construction["constructed"] = 1] = "constructed";
-})(ASN1Construction || (exports.ASN1Construction = ASN1Construction = {}));
-var LengthEncodingPreference;
+})(ASN1Construction || (ASN1Construction = {}));
+export var LengthEncodingPreference;
 (function (LengthEncodingPreference) {
     LengthEncodingPreference[LengthEncodingPreference["definite"] = 0] = "definite";
     LengthEncodingPreference[LengthEncodingPreference["indefinite"] = 1] = "indefinite";
-})(LengthEncodingPreference || (exports.LengthEncodingPreference = LengthEncodingPreference = {}));
-var ASN1SpecialRealValue;
+})(LengthEncodingPreference || (LengthEncodingPreference = {}));
+export var ASN1SpecialRealValue;
 (function (ASN1SpecialRealValue) {
     ASN1SpecialRealValue[ASN1SpecialRealValue["plusInfinity"] = 64] = "plusInfinity";
     ASN1SpecialRealValue[ASN1SpecialRealValue["minusInfinity"] = 65] = "minusInfinity";
     ASN1SpecialRealValue[ASN1SpecialRealValue["notANumber"] = 66] = "notANumber";
     ASN1SpecialRealValue[ASN1SpecialRealValue["minusZero"] = 67] = "minusZero";
-})(ASN1SpecialRealValue || (exports.ASN1SpecialRealValue = ASN1SpecialRealValue = {}));
-var ASN1RealEncodingBase;
+})(ASN1SpecialRealValue || (ASN1SpecialRealValue = {}));
+export var ASN1RealEncodingBase;
 (function (ASN1RealEncodingBase) {
     ASN1RealEncodingBase[ASN1RealEncodingBase["base2"] = 0] = "base2";
     ASN1RealEncodingBase[ASN1RealEncodingBase["base8"] = 16] = "base8";
     ASN1RealEncodingBase[ASN1RealEncodingBase["base16"] = 32] = "base16";
-})(ASN1RealEncodingBase || (exports.ASN1RealEncodingBase = ASN1RealEncodingBase = {}));
-var ASN1RealEncodingScale;
+})(ASN1RealEncodingBase || (ASN1RealEncodingBase = {}));
+export var ASN1RealEncodingScale;
 (function (ASN1RealEncodingScale) {
     ASN1RealEncodingScale[ASN1RealEncodingScale["scale0"] = 0] = "scale0";
     ASN1RealEncodingScale[ASN1RealEncodingScale["scale1"] = 4] = "scale1";
     ASN1RealEncodingScale[ASN1RealEncodingScale["scale2"] = 8] = "scale2";
     ASN1RealEncodingScale[ASN1RealEncodingScale["scale3"] = 12] = "scale3";
-})(ASN1RealEncodingScale || (exports.ASN1RealEncodingScale = ASN1RealEncodingScale = {}));
-var ASN1UniversalType;
+})(ASN1RealEncodingScale || (ASN1RealEncodingScale = {}));
+export var ASN1UniversalType;
 (function (ASN1UniversalType) {
     ASN1UniversalType[ASN1UniversalType["endOfContent"] = 0] = "endOfContent";
     ASN1UniversalType[ASN1UniversalType["boolean"] = 1] = "boolean";
@@ -82,29 +79,29 @@ var ASN1UniversalType;
     ASN1UniversalType[ASN1UniversalType["duration"] = 34] = "duration";
     ASN1UniversalType[ASN1UniversalType["oidIRI"] = 35] = "oidIRI";
     ASN1UniversalType[ASN1UniversalType["roidIRI"] = 36] = "roidIRI";
-})(ASN1UniversalType || (exports.ASN1UniversalType = ASN1UniversalType = {}));
-exports.printableStringCharacters = "etaoinsrhdlucmfywgpbvkxqjzETAOINSRHDLUCMFYWGPBVKXQJZ0123456789 '()+,-./:=?";
-exports.utcTimeRegex = /^(\d{2})((?:1[0-2])|(?:0\d))((?:3[01])|(?:[0-2]\d))((?:2[0-3])|(?:[01]\d))([0-5]\d)([0-5]\d)?((?:(\+|-)((?:2[0-3])|(?:[01]\d))[0-5]\d)|Z)$/;
-exports.distinguishedUTCTimeRegex = /^(?<year>\d{2})(?<month>(?:1[0-2])|(?:0\d))(?<date>(?:3[01])|(?:[0-2]\d))(?<hour>(?:2[0-3])|(?:[01]\d))(?<minute>[0-5]\d)(?<second>[0-5]\d)?Z$/;
-exports.generalizedTimeRegex = /^(\d{4})((?:1[0-2])|(?:0\d))((?:3[01])|(?:[0-2]\d))((?:2[0-3])|(?:[01]\d))([0-5]\d)?([0-5]\d)?(?:(?:\.|,)(\d+))?((?:(?:\+|-)((?:2[0-3])|(?:[01]\d))[0-5]\d)|Z)?$/;
-exports.distinguishedGeneralizedTimeRegex = /^(?<year>\d{4})(?<month>(?:1[0-2])|(?:0\d))(?<date>(?:3[01])|(?:[0-2]\d))(?<hour>(?:2[0-3])|(?:[01]\d))(?<minute>[0-5]\d)(?<second>[0-5]\d)(?:(\.|,)(?<fraction>\d*[1-9]))?Z$/;
-exports.nr1Regex = /^ *(\+|-)?\d+$/u;
-exports.nr2Regex = /^ *(\+|-)?(?:\d+(\.|,)\d*)|(?:\d*(\.|,)\d+)$/u;
-exports.nr3Regex = /^ *(\+|-)?(?:\d+(\.|,)\d*)|(?:\d*(\.|,)\d+)(e|E)(\+|-)?\d+$/u;
-exports.canonicalNR3Regex = /^ *-?(?:[1-9]\d*)?[1-9]\.E(?:\+0)|(?:-?[1-9]\d*)$/u;
-exports.distinguishedNR3Regex = /^ *-?(?:[1-9]\d*)?[1-9]\.E(?:\+0)|(?:-?[1-9]\d*)$/u;
-exports.CANONICAL_TAG_CLASS_ORDERING = [
+})(ASN1UniversalType || (ASN1UniversalType = {}));
+export const printableStringCharacters = "etaoinsrhdlucmfywgpbvkxqjzETAOINSRHDLUCMFYWGPBVKXQJZ0123456789 '()+,-./:=?";
+export const utcTimeRegex = /^(\d{2})((?:1[0-2])|(?:0\d))((?:3[01])|(?:[0-2]\d))((?:2[0-3])|(?:[01]\d))([0-5]\d)([0-5]\d)?((?:(\+|-)((?:2[0-3])|(?:[01]\d))[0-5]\d)|Z)$/;
+export const distinguishedUTCTimeRegex = /^(?<year>\d{2})(?<month>(?:1[0-2])|(?:0\d))(?<date>(?:3[01])|(?:[0-2]\d))(?<hour>(?:2[0-3])|(?:[01]\d))(?<minute>[0-5]\d)(?<second>[0-5]\d)?Z$/;
+export const generalizedTimeRegex = /^(\d{4})((?:1[0-2])|(?:0\d))((?:3[01])|(?:[0-2]\d))((?:2[0-3])|(?:[01]\d))([0-5]\d)?([0-5]\d)?(?:(?:\.|,)(\d+))?((?:(?:\+|-)((?:2[0-3])|(?:[01]\d))[0-5]\d)|Z)?$/;
+export const distinguishedGeneralizedTimeRegex = /^(?<year>\d{4})(?<month>(?:1[0-2])|(?:0\d))(?<date>(?:3[01])|(?:[0-2]\d))(?<hour>(?:2[0-3])|(?:[01]\d))(?<minute>[0-5]\d)(?<second>[0-5]\d)(?:(\.|,)(?<fraction>\d*[1-9]))?Z$/;
+export const nr1Regex = /^ *(\+|-)?\d+$/u;
+export const nr2Regex = /^ *(\+|-)?(?:\d+(\.|,)\d*)|(?:\d*(\.|,)\d+)$/u;
+export const nr3Regex = /^ *(\+|-)?(?:\d+(\.|,)\d*)|(?:\d*(\.|,)\d+)(e|E)(\+|-)?\d+$/u;
+export const canonicalNR3Regex = /^ *-?(?:[1-9]\d*)?[1-9]\.E(?:\+0)|(?:-?[1-9]\d*)$/u;
+export const distinguishedNR3Regex = /^ *-?(?:[1-9]\d*)?[1-9]\.E(?:\+0)|(?:-?[1-9]\d*)$/u;
+export const CANONICAL_TAG_CLASS_ORDERING = [
     ASN1TagClass.universal,
     ASN1TagClass.application,
     ASN1TagClass.context,
     ASN1TagClass.private,
 ];
-exports.numberRegex = "(?:0|[1-9]\\d*)(?:\\.\\d+)?";
-exports.datetimeRegex = new RegExp("^(?:(" + exports.numberRegex + ")Y)?"
-    + "(?:(" + exports.numberRegex + ")M)?"
-    + "(?:(" + exports.numberRegex + ")D)?"
+export const numberRegex = "(?:0|[1-9]\\d*)(?:\\.\\d+)?";
+export const datetimeRegex = new RegExp("^(?:(" + numberRegex + ")Y)?"
+    + "(?:(" + numberRegex + ")M)?"
+    + "(?:(" + numberRegex + ")D)?"
     + "(?:T"
-    + "(?:(" + exports.numberRegex + ")H)?"
-    + "(?:(" + exports.numberRegex + ")M)?"
-    + "(?:(" + exports.numberRegex + ")S)?"
+    + "(?:(" + numberRegex + ")H)?"
+    + "(?:(" + numberRegex + ")M)?"
+    + "(?:(" + numberRegex + ")S)?"
     + ")?$");

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

@@ -1,5 +1,5 @@
-import ASN1Element from "./asn1";
-import type { INTEGER, OBJECT_IDENTIFIER, ENUMERATED, RELATIVE_OID, TIME, DATE, TIME_OF_DAY, DATE_TIME, OID_IRI, RELATIVE_OID_IRI } from "./macros";
+import ASN1Element from "./asn1.mjs";
+import type { INTEGER, OBJECT_IDENTIFIER, ENUMERATED, RELATIVE_OID, TIME, DATE, TIME_OF_DAY, DATE_TIME, OID_IRI, RELATIVE_OID_IRI } from "./macros.mjs";
 export default abstract class X690Element extends ASN1Element {
     set integer(value: INTEGER);
     get integer(): INTEGER;

package/dist/x690.mjs

@@ -0,0 +1,95 @@
+import ASN1Element from "./asn1.mjs";
+import * as errors from "./errors.mjs";
+import { ASN1Construction } from "./values.mjs";
+import encodeInteger from "./codecs/x690/encoders/encodeInteger.mjs";
+import decodeInteger from "./codecs/x690/decoders/decodeInteger.mjs";
+import encodeObjectIdentifier from "./codecs/x690/encoders/encodeObjectIdentifier.mjs";
+import decodeObjectIdentifier from "./codecs/x690/decoders/decodeObjectIdentifier.mjs";
+import encodeRelativeObjectIdentifier from "./codecs/x690/encoders/encodeRelativeObjectIdentifier.mjs";
+import decodeRelativeObjectIdentifier from "./codecs/x690/decoders/decodeRelativeObjectIdentifier.mjs";
+import encodeTime from "./codecs/x690/encoders/encodeTime.mjs";
+import decodeTime from "./codecs/x690/decoders/decodeTime.mjs";
+import encodeDate from "./codecs/x690/encoders/encodeDate.mjs";
+import decodeDate from "./codecs/x690/decoders/decodeDate.mjs";
+import encodeTimeOfDay from "./codecs/x690/encoders/encodeTimeOfDay.mjs";
+import decodeTimeOfDay from "./codecs/x690/decoders/decodeTimeOfDay.mjs";
+import encodeDateTime from "./codecs/x690/encoders/encodeDateTime.mjs";
+import decodeDateTime from "./codecs/x690/decoders/decodeDateTime.mjs";
+import encodeOIDIRI from "./codecs/x690/encoders/encodeOIDIRI.mjs";
+import decodeOIDIRI from "./codecs/x690/decoders/decodeOIDIRI.mjs";
+import encodeRelativeOIDIRI from "./codecs/x690/encoders/encodeRelativeOIDIRI.mjs";
+import decodeRelativeOIDIRI from "./codecs/x690/decoders/decodeRelativeOIDIRI.mjs";
+export default class X690Element extends ASN1Element {
+    set integer(value) {
+        this.value = encodeInteger(value);
+    }
+    get integer() {
+        if (this.construction !== ASN1Construction.primitive) {
+            throw new errors.ASN1ConstructionError("INTEGER cannot be constructed.", this);
+        }
+        return decodeInteger(this.value);
+    }
+    set objectIdentifier(value) {
+        this.value = encodeObjectIdentifier(value);
+    }
+    get objectIdentifier() {
+        if (this.construction !== ASN1Construction.primitive) {
+            throw new errors.ASN1ConstructionError("OBJECT IDENTIFIER cannot be constructed.", this);
+        }
+        if (this.value.length === 0) {
+            throw new errors.ASN1TruncationError("Encoded value was too short to be an OBJECT IDENTIFIER!", this);
+        }
+        return decodeObjectIdentifier(this.value);
+    }
+    set enumerated(value) {
+        this.integer = value;
+    }
+    get enumerated() {
+        return Number(this.integer);
+    }
+    set relativeObjectIdentifier(value) {
+        this.value = encodeRelativeObjectIdentifier(value);
+    }
+    get relativeObjectIdentifier() {
+        if (this.construction !== ASN1Construction.primitive) {
+            throw new errors.ASN1ConstructionError("Relative OID cannot be constructed.", this);
+        }
+        return decodeRelativeObjectIdentifier(this.value);
+    }
+    set time(value) {
+        this.value = encodeTime(value);
+    }
+    get time() {
+        return decodeTime(this.value);
+    }
+    set date(value) {
+        this.value = encodeDate(value);
+    }
+    get date() {
+        return decodeDate(this.value);
+    }
+    set timeOfDay(value) {
+        this.value = encodeTimeOfDay(value);
+    }
+    get timeOfDay() {
+        return decodeTimeOfDay(this.value);
+    }
+    set dateTime(value) {
+        this.value = encodeDateTime(value);
+    }
+    get dateTime() {
+        return decodeDateTime(this.value);
+    }
+    set oidIRI(value) {
+        this.value = encodeOIDIRI(value);
+    }
+    get oidIRI() {
+        return decodeOIDIRI(this.value);
+    }
+    set relativeOIDIRI(value) {
+        this.value = encodeRelativeOIDIRI(value);
+    }
+    get relativeOIDIRI() {
+        return decodeRelativeOIDIRI(this.value);
+    }
+}