asn1-ts 8.0.5 → 9.0.0

package/dist/types/time/TIME-OF-DAY-DIFF-ENCODING.mjs

@@ -0,0 +1,17 @@
+import datetimeComponentValidator from "../../validators/datetimeComponentValidator.mjs";
+export default class TIME_OF_DAY_DIFF_ENCODING {
+    hours;
+    minutes;
+    seconds;
+    minutes_diff;
+    constructor(hours, minutes, seconds, minutes_diff) {
+        this.hours = hours;
+        this.minutes = minutes;
+        this.seconds = seconds;
+        this.minutes_diff = minutes_diff;
+        datetimeComponentValidator("hour", 0, 24)("TIME-OF-DAY-DIFF-ENCODING", hours);
+        datetimeComponentValidator("minute", 0, 59)("TIME-OF-DAY-DIFF-ENCODING", minutes);
+        datetimeComponentValidator("seconds", 0, 60)("TIME-OF-DAY-DIFF-ENCODING", seconds);
+        datetimeComponentValidator("minute-diff", -900, 900)("TIME-OF-DAY-DIFF-ENCODING", minutes_diff);
+    }
+}

package/dist/{node/types/time/TIME-OF-DAY-ENCODING.d.ts → types/time/TIME-OF-DAY-ENCODING.d.mts}

@@ -1,4 +1,4 @@
-import { INTEGER } from "../../macros";
+import { INTEGER } from "../../macros.mjs";
 export default class TIME_OF_DAY_ENCODING {
     readonly hours: INTEGER;
     readonly minutes: INTEGER;

package/dist/types/time/TIME-OF-DAY-ENCODING.mjs

@@ -0,0 +1,14 @@
+import datetimeComponentValidator from "../../validators/datetimeComponentValidator.mjs";
+export default class TIME_OF_DAY_ENCODING {
+    hours;
+    minutes;
+    seconds;
+    constructor(hours, minutes, seconds) {
+        this.hours = hours;
+        this.minutes = minutes;
+        this.seconds = seconds;
+        datetimeComponentValidator("hour", 0, 24)("TIME-OF-DAY-ENCODING", hours);
+        datetimeComponentValidator("minute", 0, 59)("TIME-OF-DAY-ENCODING", minutes);
+        datetimeComponentValidator("seconds", 0, 60)("TIME-OF-DAY-ENCODING", seconds);
+    }
+}

package/dist/{node/types/time/TIME-OF-DAY-FRACTION-DIFF-ENCODING.d.ts → types/time/TIME-OF-DAY-FRACTION-DIFF-ENCODING.d.mts}

@@ -1,4 +1,4 @@
-import { INTEGER } from "../../macros";
+import { INTEGER } from "../../macros.mjs";
 export default class TIME_OF_DAY_FRACTION_DIFF_ENCODING {
     readonly hours: INTEGER;
     readonly minutes: INTEGER;

package/dist/types/time/TIME-OF-DAY-FRACTION-DIFF-ENCODING.mjs

@@ -0,0 +1,20 @@
+import datetimeComponentValidator from "../../validators/datetimeComponentValidator.mjs";
+export default class TIME_OF_DAY_FRACTION_DIFF_ENCODING {
+    hours;
+    minutes;
+    seconds;
+    fractional_part;
+    minutes_diff;
+    constructor(hours, minutes, seconds, fractional_part, minutes_diff) {
+        this.hours = hours;
+        this.minutes = minutes;
+        this.seconds = seconds;
+        this.fractional_part = fractional_part;
+        this.minutes_diff = minutes_diff;
+        datetimeComponentValidator("hour", 0, 24)("TIME-OF-DAY-FRACTION-DIFF-ENCODING", hours);
+        datetimeComponentValidator("minute", 0, 59)("TIME-OF-DAY-FRACTION-DIFF-ENCODING", minutes);
+        datetimeComponentValidator("seconds", 0, 60)("TIME-OF-DAY-FRACTION-DIFF-ENCODING", seconds);
+        datetimeComponentValidator("fractional-part", 0, Number.MAX_SAFE_INTEGER)("TIME-OF-DAY-FRACTION-DIFF-ENCODING", fractional_part);
+        datetimeComponentValidator("minute-diff", -900, 900)("TIME-OF-DAY-FRACTION-DIFF-ENCODING", minutes_diff);
+    }
+}

package/dist/{node/types/time/TIME-OF-DAY-FRACTION-ENCODING.d.ts → types/time/TIME-OF-DAY-FRACTION-ENCODING.d.mts}

@@ -1,4 +1,4 @@
-import { INTEGER } from "../../macros";
+import { INTEGER } from "../../macros.mjs";
 export default class TIME_OF_DAY_FRACTION_ENCODING {
     readonly hours: INTEGER;
     readonly minutes: INTEGER;

package/dist/types/time/TIME-OF-DAY-FRACTION-ENCODING.mjs

@@ -0,0 +1,17 @@
+import datetimeComponentValidator from "../../validators/datetimeComponentValidator.mjs";
+export default class TIME_OF_DAY_FRACTION_ENCODING {
+    hours;
+    minutes;
+    seconds;
+    fractional_part;
+    constructor(hours, minutes, seconds, fractional_part) {
+        this.hours = hours;
+        this.minutes = minutes;
+        this.seconds = seconds;
+        this.fractional_part = fractional_part;
+        datetimeComponentValidator("hour", 0, 24)("TIME-OF-DAY-FRACTION-ENCODING", hours);
+        datetimeComponentValidator("minute", 0, 59)("TIME-OF-DAY-FRACTION-ENCODING", minutes);
+        datetimeComponentValidator("seconds", 0, 60)("TIME-OF-DAY-FRACTION-ENCODING", seconds);
+        datetimeComponentValidator("fractional-part", 0, Number.MAX_SAFE_INTEGER)("TIME-OF-DAY-FRACTION-ENCODING", fractional_part);
+    }
+}

package/dist/{node/types/time/YEAR-ENCODING.d.ts → types/time/YEAR-ENCODING.d.mts}

@@ -1,4 +1,4 @@
-import { INTEGER } from "../../macros";
+import { INTEGER } from "../../macros.mjs";
 export default class YEAR_ENCODING {
     readonly year: INTEGER;
     constructor(year: INTEGER);

package/dist/types/time/YEAR-ENCODING.mjs

@@ -0,0 +1,6 @@
+export default class YEAR_ENCODING {
+    year;
+    constructor(year) {
+        this.year = year;
+    }
+}

package/dist/{node/types/time/YEAR-MONTH-ENCODING.d.ts → types/time/YEAR-MONTH-ENCODING.d.mts}

@@ -1,4 +1,4 @@
-import { INTEGER } from "../../macros";
+import { INTEGER } from "../../macros.mjs";
 export default class YEAR_MONTH_ENCODING {
     readonly year: INTEGER;
     readonly month: INTEGER;

package/dist/types/time/YEAR-MONTH-ENCODING.mjs

@@ -0,0 +1,10 @@
+import datetimeComponentValidator from "../../validators/datetimeComponentValidator.mjs";
+export default class YEAR_MONTH_ENCODING {
+    year;
+    month;
+    constructor(year, month) {
+        this.year = year;
+        this.month = month;
+        datetimeComponentValidator("month", 1, 12)("YEAR-MONTH-ENCODING", month);
+    }
+}

package/dist/utils/base128Length.mjs

@@ -0,0 +1,3 @@
+export default function base128Length(numberOfBytes) {
+    return Math.ceil(numberOfBytes * (8 / 7));
+}

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

@@ -1,4 +1,4 @@
-import type { INTEGER } from "../macros";
+import type { INTEGER } from "../macros.mjs";
 import { Buffer } from "node:buffer";
 export declare function bufferToInteger(input: Buffer | Uint8Array): INTEGER;
 export declare function integerToBuffer(int: INTEGER): Buffer;

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

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bufferToInteger = bufferToInteger;
-exports.integerToBuffer = integerToBuffer;
-const values_1 = require("../values");
-const node_buffer_1 = require("node:buffer");
-function bufferToInteger(input) {
-    const buf = (input instanceof node_buffer_1.Buffer)
+import { MIN_SINT_32, MAX_SINT_32 } from "../values.mjs";
+import { Buffer } from "node:buffer";
+export function bufferToInteger(input) {
+    const buf = (input instanceof Buffer)
         ? input
-        : node_buffer_1.Buffer.from(input.buffer);
+        : Buffer.from(input.buffer);
     switch (buf.length) {
         case (0): return 0;
         case (1): return buf.readInt8();
@@ -24,30 +20,30 @@ function bufferToInteger(input) {
         }
     }
 }
-function integerToBuffer(int) {
+export function integerToBuffer(int) {
     if (typeof int === "number") {
         if ((int <= 127) && (int >= -128)) {
-            const buf = node_buffer_1.Buffer.allocUnsafe(1);
+            const buf = Buffer.allocUnsafe(1);
             buf.writeInt8(int);
             return buf;
         }
         else if ((int <= 32767) && (int >= -32768)) {
-            const buf = node_buffer_1.Buffer.allocUnsafe(2);
+            const buf = Buffer.allocUnsafe(2);
             buf.writeInt16BE(int);
             return buf;
         }
         else if ((int <= 8388607) && (int >= -8388608)) {
-            const buf = node_buffer_1.Buffer.allocUnsafe(4);
+            const buf = Buffer.allocUnsafe(4);
             buf.writeInt32BE(int);
             return buf.subarray(1);
         }
-        else if ((int >= values_1.MIN_SINT_32) && (int <= values_1.MAX_SINT_32)) {
-            const buf = node_buffer_1.Buffer.allocUnsafe(4);
+        else if ((int >= MIN_SINT_32) && (int <= MAX_SINT_32)) {
+            const buf = Buffer.allocUnsafe(4);
             buf.writeInt32BE(int);
             return buf;
         }
         else {
-            const ret = node_buffer_1.Buffer.allocUnsafe(8);
+            const ret = Buffer.allocUnsafe(8);
             ret.writeBigInt64BE(BigInt(int));
             let startOfNonPadding = 0;
             if (int >= 0) {
@@ -75,27 +71,27 @@ function integerToBuffer(int) {
     }
     else {
         let startOfNonPadding = 0;
-        let ret = node_buffer_1.Buffer.allocUnsafe(8);
+        let ret = Buffer.allocUnsafe(8);
         if ((int >= Number.MIN_SAFE_INTEGER)
             && (int <= Number.MAX_SAFE_INTEGER)) {
             ret.writeBigInt64BE(int);
         }
         else if (int >= 0) {
             const hex = int.toString(16);
-            ret = node_buffer_1.Buffer.from(((hex.length % 2) ? `0${hex}` : hex), "hex");
-            if (ret[0] & 128) {
-                ret = node_buffer_1.Buffer.concat([
-                    node_buffer_1.Buffer.from([0x00]),
+            ret = Buffer.from(((hex.length % 2) ? `0${hex}` : hex), "hex");
+            if (ret[0] & 0b1000_0000) {
+                ret = Buffer.concat([
+                    Buffer.from([0x00]),
                     ret,
                 ]);
             }
         }
         else {
             const hex = BigInt.asUintN(100000000, int).toString(16);
-            ret = node_buffer_1.Buffer.from(((hex.length % 2) ? `0${hex}` : hex), "hex");
-            if (!(ret[0] & 128)) {
-                ret = node_buffer_1.Buffer.concat([
-                    node_buffer_1.Buffer.from([0xFF]),
+            ret = Buffer.from(((hex.length % 2) ? `0${hex}` : hex), "hex");
+            if (!(ret[0] & 0b1000_0000)) {
+                ret = Buffer.concat([
+                    Buffer.from([0xFF]),
                     ret,
                 ]);
             }

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

@@ -1,2 +1,2 @@
-import type ASN1Element from "../asn1";
+import type ASN1Element from "../asn1.mjs";
 export default function compareSetOfElementsCanonically(a: ASN1Element, b: ASN1Element): number;

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = compareSetOfElementsCanonically;
-function compareSetOfElementsCanonically(a, b) {
+export default function compareSetOfElementsCanonically(a, b) {
     const longestLength = (a.value.length > b.value.length)
         ? a.value.length
         : b.value.length;

package/dist/utils/convertBytesToText.mjs

@@ -0,0 +1,14 @@
+import { ASN1Error } from "../errors.mjs";
+import { Buffer } from "node:buffer";
+export default function convertBytesToText(bytes, codec = "utf-8") {
+    if (typeof Buffer !== "undefined") {
+        if (bytes instanceof Buffer) {
+            return bytes.toString(codec);
+        }
+        return (Buffer.from(bytes.buffer, bytes.byteOffset, bytes.length)).toString(codec);
+    }
+    else if (typeof TextEncoder !== "undefined") {
+        return (new TextDecoder(codec)).decode(bytes);
+    }
+    throw new ASN1Error("Neither TextDecoder nor Buffer are defined to decode bytes into text.");
+}

package/dist/utils/convertTextToBytes.mjs

@@ -0,0 +1,11 @@
+import { ASN1Error } from "../errors.mjs";
+import { Buffer } from "node:buffer";
+export default function convertTextToBytes(text, codec = "utf-8") {
+    if (typeof TextEncoder !== "undefined") {
+        return (new TextEncoder()).encode(text);
+    }
+    else if (typeof Buffer !== "undefined") {
+        return Buffer.from(text, codec);
+    }
+    throw new ASN1Error("Neither TextEncoder nor Buffer are defined to encode text into bytes.");
+}

package/dist/utils/decodeIEEE754DoublePrecisionFloat.mjs

@@ -0,0 +1,3 @@
+export default function decodeIEEE754DoublePrecisionFloat(bytes) {
+    return new Float64Array(bytes.reverse().buffer)[0];
+}

package/dist/utils/decodeIEEE754SinglePrecisionFloat.mjs

@@ -0,0 +1,3 @@
+export default function decodeIEEE754SinglePrecisionFloat(bytes) {
+    return new Float32Array(bytes.reverse().buffer)[0];
+}

package/dist/utils/decodeSignedBigEndianInteger.mjs

@@ -0,0 +1,13 @@
+import * as errors from "../errors.mjs";
+import { Buffer } from "node:buffer";
+export default function decodeSignedBigEndianInteger(value) {
+    if (value.length === 0) {
+        return 0;
+    }
+    if (value.length > 4) {
+        throw new errors.ASN1OverflowError("Number too long to decode.");
+    }
+    const ret = Buffer.alloc(4, (value[0] >= 0b10000000) ? 0xFF : 0x00);
+    ret.set(value, (4 - value.length));
+    return ret.readInt32BE();
+}

package/dist/utils/decodeUnsignedBigEndianInteger.mjs

@@ -0,0 +1,13 @@
+import * as errors from "../errors.mjs";
+import { Buffer } from "node:buffer";
+export default function decodeUnsignedBigEndianInteger(value) {
+    if (value.length === 0) {
+        return 0;
+    }
+    if (value.length > 4) {
+        throw new errors.ASN1OverflowError(`Number on ${value.length} bytes is too long to decode.`);
+    }
+    const ret = Buffer.alloc(4);
+    ret.set(value, (4 - value.length));
+    return ret.readUInt32BE();
+}

package/dist/utils/decodeX690RealNumber.mjs

@@ -0,0 +1,108 @@
+import * as errors from "../errors.mjs";
+import { ASN1SpecialRealValue, ASN1RealEncodingBase, ASN1RealEncodingScale, nr1Regex, nr2Regex, nr3Regex, } from "../values.mjs";
+import convertBytesToText from "./convertBytesToText.mjs";
+import decodeSignedBigEndianInteger from "../utils/decodeSignedBigEndianInteger.mjs";
+import decodeUnsignedBigEndianInteger from "../utils/decodeUnsignedBigEndianInteger.mjs";
+export default function decodeX690RealNumber(bytes) {
+    if (bytes.length === 0)
+        return 0.0;
+    switch (bytes[0] & 0b11000000) {
+        case (0b01000000): {
+            if (bytes[0] === ASN1SpecialRealValue.notANumber)
+                return NaN;
+            if (bytes[0] === ASN1SpecialRealValue.minusZero)
+                return -0.0;
+            if (bytes[0] === ASN1SpecialRealValue.plusInfinity)
+                return Infinity;
+            if (bytes[0] === ASN1SpecialRealValue.minusInfinity)
+                return -Infinity;
+            throw new errors.ASN1UndefinedError("Unrecognized special REAL value!");
+        }
+        case (0b00000000): {
+            const realString = convertBytesToText(bytes.subarray(1));
+            switch (bytes[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 = ((bytes[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.");
+                }
+            })(bytes[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.");
+                }
+            })(bytes[0] & 0b00001100);
+            let exponent;
+            let mantissa;
+            switch (bytes[0] & 0b00000011) {
+                case (0b00000000): {
+                    if (bytes.length < 3)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = decodeSignedBigEndianInteger(bytes.subarray(1, 2));
+                    mantissa = decodeUnsignedBigEndianInteger(bytes.subarray(2));
+                    break;
+                }
+                case (0b00000001): {
+                    if (bytes.length < 4)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = decodeSignedBigEndianInteger(bytes.subarray(1, 3));
+                    mantissa = decodeUnsignedBigEndianInteger(bytes.subarray(3));
+                    break;
+                }
+                case (0b00000010): {
+                    if (bytes.length < 5)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = decodeSignedBigEndianInteger(bytes.subarray(1, 4));
+                    mantissa = decodeUnsignedBigEndianInteger(bytes.subarray(4));
+                    break;
+                }
+                case (0b00000011): {
+                    if (bytes.length < 3)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    const exponentLength = bytes[1];
+                    if (bytes.length < (3 + exponentLength)) {
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    }
+                    exponent = decodeSignedBigEndianInteger(bytes.subarray(2, (2 + exponentLength)));
+                    mantissa = decodeUnsignedBigEndianInteger(bytes.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/utils/dissectFloat.mjs

@@ -0,0 +1,13 @@
+const EXPONENT_BITMASK = 0b0111_1111_1111_0000_0000_0000_0000_0000;
+export default function dissectFloat(value) {
+    const float = new Float64Array([value]);
+    const uints = new Uint32Array(float.buffer);
+    const exponent = (((uints[1] & EXPONENT_BITMASK) >>> 20) - 1023 - 31);
+    const mantissa = 0x8000_0000 + ((((uints[1] & 0x000F_FFFF) << 11)
+        | ((uints[0] & 0xFFE0_0000) >>> 21)));
+    return {
+        negative: (value < 0),
+        exponent,
+        mantissa,
+    };
+}

package/dist/utils/encodeIEEE754DoublePrecisionFloat.mjs

@@ -0,0 +1,3 @@
+export default function encodeIEEE754DoublePrecisionFloat(value) {
+    return new Uint8Array(new Float64Array([value]).buffer).reverse();
+}

package/dist/utils/encodeIEEE754SinglePrecisionFloat.mjs

@@ -0,0 +1,3 @@
+export default function encodeIEEE754SinglePrecisionFloat(value) {
+    return new Uint8Array(new Float32Array([value]).buffer).reverse();
+}

package/dist/utils/encodeSignedBigEndianInteger.mjs

@@ -0,0 +1,36 @@
+import * as errors from "../errors.mjs";
+import { MIN_SINT_32, MAX_SINT_32 } from "../values.mjs";
+export default function encodeBigEndianSignedInteger(value) {
+    if (value < MIN_SINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too small to be encoded as a big-endian signed integer.`);
+    }
+    if (value > MAX_SINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too big to be encoded as a big-endian signed integer.`);
+    }
+    if (value <= 127 && value >= -128) {
+        return new Uint8Array([
+            (value & 255),
+        ]);
+    }
+    else if (value <= 32767 && value >= -32768) {
+        return new Uint8Array([
+            ((value >> 8) & 255),
+            (value & 255),
+        ]);
+    }
+    else if (value <= 8388607 && value >= -8388608) {
+        return new Uint8Array([
+            ((value >> 16) & 255),
+            ((value >> 8) & 255),
+            (value & 255),
+        ]);
+    }
+    else {
+        return new Uint8Array([
+            ((value >> 24) & 255),
+            ((value >> 16) & 255),
+            ((value >> 8) & 255),
+            (value & 255),
+        ]);
+    }
+}

package/dist/utils/encodeUnsignedBigEndianInteger.mjs

@@ -0,0 +1,23 @@
+import * as errors from "../errors.mjs";
+import { MIN_UINT_32, MAX_UINT_32 } from "../values.mjs";
+import { Buffer } from "node:buffer";
+export default function encodeUnsignedBigEndianInteger(value) {
+    if (value < MIN_UINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too small to be encoded as a big-endian unsigned integer.`);
+    }
+    if (value > MAX_UINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too big to be encoded as a big-endian unsigned integer.`);
+    }
+    const bytes = Buffer.alloc(4);
+    bytes.writeUInt32BE(value);
+    let startOfNonPadding = 0;
+    for (let i = 0; i < bytes.length - 1; i++) {
+        if (bytes[i] === 0x00) {
+            startOfNonPadding++;
+        }
+        else {
+            break;
+        }
+    }
+    return bytes.subarray(startOfNonPadding);
+}

package/dist/utils/encodeX690Base10RealNumber.mjs

@@ -0,0 +1,21 @@
+import { ASN1SpecialRealValue } from "../values.mjs";
+import convertTextToBytes from "./convertTextToBytes.mjs";
+export default function encodeX690Base10RealNumber(value) {
+    if (value === 0.0) {
+        return new Uint8Array(0);
+    }
+    else if (Number.isNaN(value)) {
+        return new Uint8Array([ASN1SpecialRealValue.notANumber]);
+    }
+    else if (value === -0.0) {
+        return new Uint8Array([ASN1SpecialRealValue.minusZero]);
+    }
+    else if (value === Infinity) {
+        return new Uint8Array([ASN1SpecialRealValue.plusInfinity]);
+    }
+    else if (value === -Infinity) {
+        return new Uint8Array([ASN1SpecialRealValue.minusInfinity]);
+    }
+    const valueString = (String.fromCharCode(0b00000011) + value.toFixed(7));
+    return convertTextToBytes(valueString);
+}

package/dist/utils/encodeX690BinaryRealNumber.mjs

@@ -0,0 +1,43 @@
+import dissectFloat from "./dissectFloat.mjs";
+import encodeUnsignedBigEndianInteger from "./encodeUnsignedBigEndianInteger.mjs";
+import encodeSignedBigEndianInteger from "./encodeSignedBigEndianInteger.mjs";
+import { ASN1SpecialRealValue } from "../values.mjs";
+import * as errors from "../errors.mjs";
+export default function encodeX690BinaryRealNumber(value) {
+    if (value === 0.0) {
+        return new Uint8Array(0);
+    }
+    else if (Number.isNaN(value)) {
+        return new Uint8Array([ASN1SpecialRealValue.notANumber]);
+    }
+    else if (value === -0.0) {
+        return new Uint8Array([ASN1SpecialRealValue.minusZero]);
+    }
+    else if (value === Infinity) {
+        return new Uint8Array([ASN1SpecialRealValue.plusInfinity]);
+    }
+    else if (value === -Infinity) {
+        return new Uint8Array([ASN1SpecialRealValue.minusInfinity]);
+    }
+    const floatComponents = dissectFloat(value);
+    while (floatComponents.mantissa !== 0 && (floatComponents.mantissa % 2) === 0) {
+        floatComponents.mantissa = floatComponents.mantissa >>> 1;
+        floatComponents.exponent++;
+    }
+    if (floatComponents.exponent <= -1020) {
+        throw new errors.ASN1OverflowError(`REAL number ${value} (having exponent ${floatComponents.exponent}) `
+            + "is too precise to encode.");
+    }
+    const singleByteExponent = ((floatComponents.exponent <= 127)
+        && (floatComponents.exponent >= -128));
+    const firstByte = (0b1000_0000
+        | (value >= 0 ? 0b0000_0000 : 0b0100_0000)
+        | (singleByteExponent ? 0b0000_0000 : 0b0000_0001));
+    const exponentBytes = encodeSignedBigEndianInteger(floatComponents.exponent);
+    const mantissaBytes = encodeUnsignedBigEndianInteger(floatComponents.mantissa);
+    const ret = new Uint8Array(1 + exponentBytes.length + mantissaBytes.length);
+    ret[0] = firstByte;
+    ret.set(exponentBytes, 1);
+    ret.set(mantissaBytes, (1 + exponentBytes.length));
+    return ret;
+}

package/dist/utils/getBitFromBase128.mjs

@@ -0,0 +1,4 @@
+export default function getBitFromBase128(from, bitIndex) {
+    const byteIndex = (from.length - (Math.floor(bitIndex / 7) + 1));
+    return ((from[byteIndex] & (0x01 << (bitIndex % 7))) > 0);
+}

package/dist/utils/getBitFromBase256.mjs

@@ -0,0 +1,3 @@
+export default function getBit(from, bitIndex) {
+    return ((from[from.length - (Math.floor(bitIndex / 8) + 1)] & (0x01 << (bitIndex % 8))) > 0);
+}

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

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