asn1-ts 8.0.5 → 9.0.0

package/dist/codecs/ber/decoders/decodeReal.mjs

@@ -0,0 +1,108 @@
+import * as errors from "../../../errors.mjs";
+import { ASN1SpecialRealValue, ASN1RealEncodingBase, ASN1RealEncodingScale, nr1Regex, nr2Regex, nr3Regex, } from "../../../values.mjs";
+import convertBytesToText from "../../../utils/convertBytesToText.mjs";
+import decodeUnsignedBigEndianInteger from "../../../utils/decodeUnsignedBigEndianInteger.mjs";
+import decodeSignedBigEndianInteger from "../../../utils/decodeSignedBigEndianInteger.mjs";
+export default function decodeReal(value) {
+    if (value.length === 0)
+        return 0.0;
+    switch (value[0] & 0b11000000) {
+        case (0b01000000): {
+            if (value[0] === ASN1SpecialRealValue.notANumber)
+                return NaN;
+            if (value[0] === ASN1SpecialRealValue.minusZero)
+                return -0.0;
+            if (value[0] === ASN1SpecialRealValue.plusInfinity)
+                return Infinity;
+            if (value[0] === ASN1SpecialRealValue.minusInfinity)
+                return -Infinity;
+            throw new errors.ASN1UndefinedError("Unrecognized special REAL value!");
+        }
+        case (0b00000000): {
+            const realString = convertBytesToText(value.subarray(1));
+            switch (value[0] & 0b00111111) {
+                case 1: {
+                    if (!nr1Regex.test(realString))
+                        throw new errors.ASN1Error("Malformed NR1 Base-10 REAL");
+                    return Number.parseFloat(realString);
+                }
+                case 2: {
+                    if (!nr2Regex.test(realString))
+                        throw new errors.ASN1Error("Malformed NR2 Base-10 REAL");
+                    return Number.parseFloat(realString.replace(",", "."));
+                }
+                case 3: {
+                    if (!nr3Regex.test(realString))
+                        throw new errors.ASN1Error("Malformed NR3 Base-10 REAL");
+                    return Number.parseFloat(realString.replace(",", "."));
+                }
+                default:
+                    throw new errors.ASN1UndefinedError("Undefined Base-10 REAL encoding.");
+            }
+        }
+        case (0b10000000):
+        case (0b11000000): {
+            const sign = ((value[0] & 0b01000000) ? -1 : 1);
+            const base = ((flag) => {
+                switch (flag) {
+                    case (ASN1RealEncodingBase.base2): return 2;
+                    case (ASN1RealEncodingBase.base8): return 8;
+                    case (ASN1RealEncodingBase.base16): return 16;
+                    default:
+                        throw new errors.ASN1Error("Impossible REAL encoding base encountered.");
+                }
+            })(value[0] & 0b00110000);
+            const scale = ((flag) => {
+                switch (flag) {
+                    case (ASN1RealEncodingScale.scale0): return 0;
+                    case (ASN1RealEncodingScale.scale1): return 1;
+                    case (ASN1RealEncodingScale.scale2): return 2;
+                    case (ASN1RealEncodingScale.scale3): return 3;
+                    default:
+                        throw new errors.ASN1Error("Impossible REAL encoding scale encountered.");
+                }
+            })(value[0] & 0b00001100);
+            let exponent;
+            let mantissa;
+            switch (value[0] & 0b00000011) {
+                case (0b00000000): {
+                    if (value.length < 3)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = decodeSignedBigEndianInteger(value.subarray(1, 2));
+                    mantissa = decodeUnsignedBigEndianInteger(value.subarray(2));
+                    break;
+                }
+                case (0b00000001): {
+                    if (value.length < 4)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = decodeSignedBigEndianInteger(value.subarray(1, 3));
+                    mantissa = decodeUnsignedBigEndianInteger(value.subarray(3));
+                    break;
+                }
+                case (0b00000010): {
+                    if (value.length < 5)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = decodeSignedBigEndianInteger(value.subarray(1, 4));
+                    mantissa = decodeUnsignedBigEndianInteger(value.subarray(4));
+                    break;
+                }
+                case (0b00000011): {
+                    if (value.length < 3)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    const exponentLength = value[1];
+                    if (value.length < (3 + exponentLength)) {
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    }
+                    exponent = decodeSignedBigEndianInteger(value.subarray(2, (2 + exponentLength)));
+                    mantissa = decodeUnsignedBigEndianInteger(value.subarray((2 + exponentLength)));
+                    break;
+                }
+                default:
+                    throw new errors.ASN1Error("Impossible binary REAL exponent encoding encountered.");
+            }
+            return (sign * mantissa * Math.pow(2, scale) * Math.pow(base, exponent));
+        }
+        default:
+            throw new errors.ASN1Error("Impossible REAL format encountered.");
+    }
+}

package/dist/codecs/ber/decoders/decodeSequence.d.mts

@@ -0,0 +1,3 @@
+import BERElement from "../../ber.mjs";
+import { SEQUENCE } from "../../../macros.mjs";
+export default function decodeSequence(value: Uint8Array): SEQUENCE<BERElement>;

package/dist/codecs/ber/decoders/decodeSequence.mjs

@@ -0,0 +1,11 @@
+import BERElement from "../../ber.mjs";
+export default function decodeSequence(value) {
+    const encodedElements = [];
+    let i = 0;
+    while (i < value.length) {
+        const next = new BERElement();
+        i += next.fromBytes(value.subarray(i));
+        encodedElements.push(next);
+    }
+    return encodedElements;
+}

package/dist/{node/codecs/ber/decoders/decodeUTCTime.d.ts → codecs/ber/decoders/decodeUTCTime.d.mts}

@@ -1,2 +1,2 @@
-import { UTCTime } from "../../../macros";
+import { UTCTime } from "../../../macros.mjs";
 export default function decodeUTCTime(value: Uint8Array): UTCTime;

package/dist/codecs/ber/decoders/decodeUTCTime.mjs

@@ -0,0 +1,45 @@
+import convertBytesToText from "../../../utils/convertBytesToText.mjs";
+import * as errors from "../../../errors.mjs";
+import validateDateTime from "../../../validators/validateDateTime.mjs";
+export default function decodeUTCTime(value) {
+    const dateString = convertBytesToText(value);
+    let year = Number(dateString.slice(0, 2));
+    year = (year <= 49)
+        ? (2000 + year)
+        : (1900 + year);
+    const month = (Number(dateString.slice(2, 4)) - 1);
+    const date = Number(dateString.slice(4, 6));
+    const hours = Number(dateString.slice(6, 8));
+    const minutes = Number(dateString.slice(8, 10));
+    const char10 = dateString.charCodeAt(10);
+    const secondsFieldPresent = (char10 >= 0x30 && char10 <= 0x39);
+    const seconds = secondsFieldPresent
+        ? Number(dateString.slice(10, 12))
+        : 0;
+    let i = secondsFieldPresent ? 12 : 10;
+    if (dateString[i] === 'Z') {
+        validateDateTime("UTCTime", year, month, date, hours, minutes, seconds);
+        return new Date(Date.UTC(year, month, date, hours, minutes, seconds));
+    }
+    if ((dateString[i] !== '+') && (dateString[i] !== '-')) {
+        throw new errors.ASN1Error(`Malformed BER UTCTime: non +/- offset: ${dateString[i]}`);
+    }
+    const isPositive = dateString[i] === '+';
+    i++;
+    let j = 0;
+    while (value[i + j] && value[i + j] >= 0x30 && value[i + j] <= 0x39)
+        j++;
+    if (j !== 4) {
+        throw new errors.ASN1Error("Malformed BER UTCTime: non four-digit offset");
+    }
+    i += j;
+    if (dateString[i] !== undefined) {
+        throw new errors.ASN1Error("Malformed BER UTCTime: trailing data");
+    }
+    const offsetHour = Number.parseInt(dateString.slice(i - 4, i - 2), 10);
+    const offsetMinute = Number.parseInt(dateString.slice(i - 2, i), 10);
+    let epochTimeInMS = Date.UTC(year, month, date, hours, minutes, seconds);
+    const sign = isPositive ? -1 : 1;
+    epochTimeInMS += sign * ((offsetHour * 60 * 60 * 1000) + (offsetMinute * 60 * 1000));
+    return new Date(epochTimeInMS);
+}

package/dist/{node/codecs/ber/encoders/encodeGeneralString.d.ts → codecs/ber/encoders/encodeGeneralString.d.mts}

@@ -1,2 +1,2 @@
-import { GeneralString } from "../../../macros";
+import { GeneralString } from "../../../macros.mjs";
 export default function encodeGeneralString(value: GeneralString): Uint8Array;

package/dist/codecs/ber/encoders/encodeGeneralString.mjs

@@ -0,0 +1,13 @@
+import isGeneralCharacter from "../../../validators/isGeneralCharacter.mjs";
+import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
+import { ASN1CharactersError } from "../../../errors.mjs";
+export default function encodeGeneralString(value) {
+    const bytes = convertTextToBytes(value);
+    for (const char of bytes) {
+        if (!isGeneralCharacter(char)) {
+            throw new ASN1CharactersError("GeneralString can only contain ASCII characters."
+                + `Encountered character code ${char}.`);
+        }
+    }
+    return bytes;
+}

package/dist/{node/codecs/ber/encoders/encodeGraphicString.d.ts → codecs/ber/encoders/encodeGraphicString.d.mts}

@@ -1,2 +1,2 @@
-import { GraphicString } from "../../../macros";
+import { GraphicString } from "../../../macros.mjs";
 export default function encodeGraphicString(value: GraphicString): Uint8Array;

package/dist/codecs/ber/encoders/encodeGraphicString.mjs

@@ -0,0 +1,13 @@
+import isGraphicCharacter from "../../../validators/isGraphicCharacter.mjs";
+import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
+import { ASN1CharactersError } from "../../../errors.mjs";
+export default function encodeGraphicString(value) {
+    const bytes = convertTextToBytes(value);
+    for (const char of bytes) {
+        if (!isGraphicCharacter(char)) {
+            throw new ASN1CharactersError("GraphicString can only contain characters between 0x20 and 0x7E. "
+                + `Encountered character code ${char}.`);
+        }
+    }
+    return bytes;
+}

package/dist/{node/codecs/ber/encoders/encodeNumericString.d.ts → codecs/ber/encoders/encodeNumericString.d.mts}

@@ -1,2 +1,2 @@
-import { NumericString } from "../../../macros";
+import { NumericString } from "../../../macros.mjs";
 export default function encodeNumericString(value: NumericString): Uint8Array;

package/dist/codecs/ber/encoders/encodeNumericString.mjs

@@ -0,0 +1,13 @@
+import isNumericCharacter from "../../../validators/isNumericCharacter.mjs";
+import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
+import { ASN1CharactersError } from "../../../errors.mjs";
+export default function encodeNumericString(value) {
+    const bytes = convertTextToBytes(value);
+    for (const char of bytes) {
+        if (!isNumericCharacter(char)) {
+            throw new ASN1CharactersError("NumericString can only contain characters 0 - 9 and space. "
+                + `Encountered character code ${char}.`);
+        }
+    }
+    return bytes;
+}

package/dist/{node/codecs/ber/encoders/encodeObjectDescriptor.d.ts → codecs/ber/encoders/encodeObjectDescriptor.d.mts}

@@ -1,2 +1,2 @@
-import { ObjectDescriptor } from "../../../macros";
+import { ObjectDescriptor } from "../../../macros.mjs";
 export default function encodeObjectDescriptor(value: ObjectDescriptor): Uint8Array;

package/dist/codecs/ber/encoders/encodeObjectDescriptor.mjs

@@ -0,0 +1,13 @@
+import isObjectDescriptorCharacter from "../../../validators/isObjectDescriptorCharacter.mjs";
+import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
+import { ASN1CharactersError } from "../../../errors.mjs";
+export default function encodeObjectDescriptor(value) {
+    const bytes = convertTextToBytes(value);
+    for (const char of bytes) {
+        if (!isObjectDescriptorCharacter(char)) {
+            throw new ASN1CharactersError("ObjectDescriptor can only contain characters between 0x20 and 0x7E. "
+                + `Encountered character code ${char}.`);
+        }
+    }
+    return bytes;
+}

package/dist/{node/codecs/ber/encoders/encodePrintableString.d.ts → codecs/ber/encoders/encodePrintableString.d.mts}

@@ -1,2 +1,2 @@
-import { PrintableString } from "../../../macros";
+import { PrintableString } from "../../../macros.mjs";
 export default function encodeNumericString(value: PrintableString): Uint8Array;

package/dist/codecs/ber/encoders/encodePrintableString.mjs

@@ -0,0 +1,14 @@
+import isPrintableCharacter from "../../../validators/isPrintableCharacter.mjs";
+import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
+import { ASN1CharactersError } from "../../../errors.mjs";
+import { printableStringCharacters } from "../../../values.mjs";
+export default function encodeNumericString(value) {
+    const bytes = convertTextToBytes(value);
+    for (const char of bytes) {
+        if (!isPrintableCharacter(char)) {
+            throw new ASN1CharactersError(`PrintableString can only contain these characters: ${printableStringCharacters}. `
+                + `Encountered character code ${char}.`);
+        }
+    }
+    return bytes;
+}

package/dist/{node/codecs/ber/encoders/encodeVisibleString.d.ts → codecs/ber/encoders/encodeVisibleString.d.mts}

@@ -1,2 +1,2 @@
-import { VisibleString } from "../../../macros";
+import { VisibleString } from "../../../macros.mjs";
 export default function encodeVisibleString(value: VisibleString): Uint8Array;

package/dist/codecs/ber/encoders/encodeVisibleString.mjs

@@ -0,0 +1,13 @@
+import isGraphicCharacter from "../../../validators/isGraphicCharacter.mjs";
+import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
+import { ASN1CharactersError } from "../../../errors.mjs";
+export default function encodeVisibleString(value) {
+    const bytes = convertTextToBytes(value);
+    for (const char of bytes) {
+        if (!isGraphicCharacter(char)) {
+            throw new ASN1CharactersError("VisibleString can only contain characters between 0x20 and 0x7E. "
+                + `Encountered character code ${char}.`);
+        }
+    }
+    return bytes;
+}

package/dist/{node/codecs/ber.d.ts → codecs/ber.d.mts}

@@ -1,8 +1,8 @@
-import ASN1Element from "../asn1";
-import { ASN1Construction, ASN1TagClass, LengthEncodingPreference } from "../values";
-import X690Element from "../x690";
-import CharacterString from "../types/CharacterString";
-import { BOOLEAN, BIT_STRING, OCTET_STRING, ObjectDescriptor, EXTERNAL, REAL, EMBEDDED_PDV, UTF8String, SEQUENCE, SET, GraphicString, NumericString, VisibleString, PrintableString, TeletexString, GeneralString, UniversalString, VideotexString, BMPString, IA5String, UTCTime, GeneralizedTime, DURATION } from "../macros";
+import ASN1Element from "../asn1.mjs";
+import { ASN1Construction, ASN1TagClass, LengthEncodingPreference } from "../values.mjs";
+import X690Element from "../x690.mjs";
+import CharacterString from "../types/CharacterString.mjs";
+import { BOOLEAN, BIT_STRING, OCTET_STRING, ObjectDescriptor, EXTERNAL, REAL, EMBEDDED_PDV, UTF8String, SEQUENCE, SET, GraphicString, NumericString, VisibleString, PrintableString, TeletexString, GeneralString, UniversalString, VideotexString, BMPString, IA5String, UTCTime, GeneralizedTime, DURATION } from "../macros.mjs";
 export default class BERElement extends X690Element {
     static lengthEncodingPreference: LengthEncodingPreference;
     private _value;