asn1-ts 6.0.0 → 7.0.3

package/dist/node/utils/decodeX690RealNumber.js

@@ -1,113 +1,113 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const errors = (0, tslib_1.__importStar)(require("../errors"));
-const values_1 = require("../values");
-const convertBytesToText_1 = (0, tslib_1.__importDefault)(require("./convertBytesToText"));
-const decodeSignedBigEndianInteger_1 = (0, tslib_1.__importDefault)(require("../utils/decodeSignedBigEndianInteger"));
-const decodeUnsignedBigEndianInteger_1 = (0, tslib_1.__importDefault)(require("../utils/decodeUnsignedBigEndianInteger"));
-function decodeX690RealNumber(bytes) {
-    if (bytes.length === 0)
-        return 0.0;
-    switch (bytes[0] & 0b11000000) {
-        case (0b01000000): {
-            if (bytes[0] === values_1.ASN1SpecialRealValue.notANumber)
-                return NaN;
-            if (bytes[0] === values_1.ASN1SpecialRealValue.minusZero)
-                return -0.0;
-            if (bytes[0] === values_1.ASN1SpecialRealValue.plusInfinity)
-                return Infinity;
-            if (bytes[0] === values_1.ASN1SpecialRealValue.minusInfinity)
-                return -Infinity;
-            throw new errors.ASN1UndefinedError("Unrecognized special REAL value!");
-        }
-        case (0b00000000): {
-            const realString = (0, convertBytesToText_1.default)(bytes.slice(1));
-            switch (bytes[0] & 0b00111111) {
-                case 1: {
-                    if (!values_1.nr1Regex.test(realString))
-                        throw new errors.ASN1Error("Malformed NR1 Base-10 REAL");
-                    return Number.parseFloat(realString);
-                }
-                case 2: {
-                    if (!values_1.nr2Regex.test(realString))
-                        throw new errors.ASN1Error("Malformed NR2 Base-10 REAL");
-                    return Number.parseFloat(realString.replace(",", "."));
-                }
-                case 3: {
-                    if (!values_1.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 (values_1.ASN1RealEncodingBase.base2): return 2;
-                    case (values_1.ASN1RealEncodingBase.base8): return 8;
-                    case (values_1.ASN1RealEncodingBase.base16): return 16;
-                    default:
-                        throw new errors.ASN1Error("Impossible REAL encoding base encountered.");
-                }
-            })(bytes[0] & 0b00110000);
-            const scale = ((flag) => {
-                switch (flag) {
-                    case (values_1.ASN1RealEncodingScale.scale0): return 0;
-                    case (values_1.ASN1RealEncodingScale.scale1): return 1;
-                    case (values_1.ASN1RealEncodingScale.scale2): return 2;
-                    case (values_1.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 = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(1, 2));
-                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(bytes.subarray(2));
-                    break;
-                }
-                case (0b00000001): {
-                    if (bytes.length < 4)
-                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
-                    exponent = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(1, 3));
-                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(bytes.subarray(3));
-                    break;
-                }
-                case (0b00000010): {
-                    if (bytes.length < 5)
-                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
-                    exponent = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(1, 4));
-                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(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 = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(2, (2 + exponentLength)));
-                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(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.");
-    }
-}
-exports.default = decodeX690RealNumber;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const errors = (0, tslib_1.__importStar)(require("../errors"));
+const values_1 = require("../values");
+const convertBytesToText_1 = (0, tslib_1.__importDefault)(require("./convertBytesToText"));
+const decodeSignedBigEndianInteger_1 = (0, tslib_1.__importDefault)(require("../utils/decodeSignedBigEndianInteger"));
+const decodeUnsignedBigEndianInteger_1 = (0, tslib_1.__importDefault)(require("../utils/decodeUnsignedBigEndianInteger"));
+function decodeX690RealNumber(bytes) {
+    if (bytes.length === 0)
+        return 0.0;
+    switch (bytes[0] & 0b11000000) {
+        case (0b01000000): {
+            if (bytes[0] === values_1.ASN1SpecialRealValue.notANumber)
+                return NaN;
+            if (bytes[0] === values_1.ASN1SpecialRealValue.minusZero)
+                return -0.0;
+            if (bytes[0] === values_1.ASN1SpecialRealValue.plusInfinity)
+                return Infinity;
+            if (bytes[0] === values_1.ASN1SpecialRealValue.minusInfinity)
+                return -Infinity;
+            throw new errors.ASN1UndefinedError("Unrecognized special REAL value!");
+        }
+        case (0b00000000): {
+            const realString = (0, convertBytesToText_1.default)(bytes.slice(1));
+            switch (bytes[0] & 0b00111111) {
+                case 1: {
+                    if (!values_1.nr1Regex.test(realString))
+                        throw new errors.ASN1Error("Malformed NR1 Base-10 REAL");
+                    return Number.parseFloat(realString);
+                }
+                case 2: {
+                    if (!values_1.nr2Regex.test(realString))
+                        throw new errors.ASN1Error("Malformed NR2 Base-10 REAL");
+                    return Number.parseFloat(realString.replace(",", "."));
+                }
+                case 3: {
+                    if (!values_1.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 (values_1.ASN1RealEncodingBase.base2): return 2;
+                    case (values_1.ASN1RealEncodingBase.base8): return 8;
+                    case (values_1.ASN1RealEncodingBase.base16): return 16;
+                    default:
+                        throw new errors.ASN1Error("Impossible REAL encoding base encountered.");
+                }
+            })(bytes[0] & 0b00110000);
+            const scale = ((flag) => {
+                switch (flag) {
+                    case (values_1.ASN1RealEncodingScale.scale0): return 0;
+                    case (values_1.ASN1RealEncodingScale.scale1): return 1;
+                    case (values_1.ASN1RealEncodingScale.scale2): return 2;
+                    case (values_1.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 = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(1, 2));
+                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(bytes.subarray(2));
+                    break;
+                }
+                case (0b00000001): {
+                    if (bytes.length < 4)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(1, 3));
+                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(bytes.subarray(3));
+                    break;
+                }
+                case (0b00000010): {
+                    if (bytes.length < 5)
+                        throw new errors.ASN1TruncationError("Binary-encoded REAL truncated.");
+                    exponent = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(1, 4));
+                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(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 = (0, decodeSignedBigEndianInteger_1.default)(bytes.subarray(2, (2 + exponentLength)));
+                    mantissa = (0, decodeUnsignedBigEndianInteger_1.default)(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.");
+    }
+}
+exports.default = decodeX690RealNumber;
 //# sourceMappingURL=decodeX690RealNumber.js.map

package/dist/node/utils/dissectFloat.d.ts

@@ -1,6 +1,6 @@
-export default function dissectFloat(value: number): {
-    negative: boolean;
-    exponent: number;
-    mantissa: number;
-};
+export default function dissectFloat(value: number): {
+    negative: boolean;
+    exponent: number;
+    mantissa: number;
+};
 //# sourceMappingURL=dissectFloat.d.ts.map

package/dist/node/utils/dissectFloat.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const EXPONENT_BITMASK = 2146435072;
-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 = 2147483648 + ((((uints[1] & 1048575) << 11)
-        | ((uints[0] & 4292870144) >>> 21)));
-    return {
-        negative: (value < 0),
-        exponent,
-        mantissa,
-    };
-}
-exports.default = dissectFloat;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const EXPONENT_BITMASK = 2146435072;
+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 = 2147483648 + ((((uints[1] & 1048575) << 11)
+        | ((uints[0] & 4292870144) >>> 21)));
+    return {
+        negative: (value < 0),
+        exponent,
+        mantissa,
+    };
+}
+exports.default = dissectFloat;
 //# sourceMappingURL=dissectFloat.js.map

package/dist/node/utils/encodeBase128.d.ts

@@ -1,2 +1,2 @@
-export default function encodeBase128(value: Uint8Array): Uint8Array;
+export default function encodeBase128(value: Uint8Array): Uint8Array;
 //# sourceMappingURL=encodeBase128.d.ts.map

package/dist/node/utils/encodeBase128.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const base128Length_1 = (0, tslib_1.__importDefault)(require("./base128Length"));
-const getBitFromBase256_1 = (0, tslib_1.__importDefault)(require("./getBitFromBase256"));
-const setBitInBase128_1 = (0, tslib_1.__importDefault)(require("./setBitInBase128"));
-function encodeBase128(value) {
-    if (value.length === 1 && value[0] < 128) {
-        return new Uint8Array([value[0]]);
-    }
-    const encodedBytes = new Uint8Array((0, base128Length_1.default)(value.length));
-    for (let byte = 0; byte < value.length; byte++) {
-        for (let bit = 0; bit < 8; bit++) {
-            const bitIndex = ((byte << 3) + bit);
-            const bitValue = (0, getBitFromBase256_1.default)(value, bitIndex);
-            if (bitValue) {
-                (0, setBitInBase128_1.default)(encodedBytes, bitIndex, true);
-            }
-        }
-    }
-    for (let byte = 0; byte < (encodedBytes.length - 1); byte++) {
-        encodedBytes[byte] |= 0x80;
-    }
-    return new Uint8Array(encodedBytes);
-}
-exports.default = encodeBase128;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base128Length_1 = (0, tslib_1.__importDefault)(require("./base128Length"));
+const getBitFromBase256_1 = (0, tslib_1.__importDefault)(require("./getBitFromBase256"));
+const setBitInBase128_1 = (0, tslib_1.__importDefault)(require("./setBitInBase128"));
+function encodeBase128(value) {
+    if (value.length === 1 && value[0] < 128) {
+        return new Uint8Array([value[0]]);
+    }
+    const encodedBytes = new Uint8Array((0, base128Length_1.default)(value.length));
+    for (let byte = 0; byte < value.length; byte++) {
+        for (let bit = 0; bit < 8; bit++) {
+            const bitIndex = ((byte << 3) + bit);
+            const bitValue = (0, getBitFromBase256_1.default)(value, bitIndex);
+            if (bitValue) {
+                (0, setBitInBase128_1.default)(encodedBytes, bitIndex, true);
+            }
+        }
+    }
+    for (let byte = 0; byte < (encodedBytes.length - 1); byte++) {
+        encodedBytes[byte] |= 0x80;
+    }
+    return new Uint8Array(encodedBytes);
+}
+exports.default = encodeBase128;
 //# sourceMappingURL=encodeBase128.js.map

package/dist/node/utils/encodeIEEE754DoublePrecisionFloat.d.ts

@@ -1,2 +1,2 @@
-export default function encodeIEEE754DoublePrecisionFloat(value: number): Uint8Array;
+export default function encodeIEEE754DoublePrecisionFloat(value: number): Uint8Array;
 //# sourceMappingURL=encodeIEEE754DoublePrecisionFloat.d.ts.map

package/dist/node/utils/encodeIEEE754DoublePrecisionFloat.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function encodeIEEE754DoublePrecisionFloat(value) {
-    return new Uint8Array(new Float64Array([value]).buffer).reverse();
-}
-exports.default = encodeIEEE754DoublePrecisionFloat;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function encodeIEEE754DoublePrecisionFloat(value) {
+    return new Uint8Array(new Float64Array([value]).buffer).reverse();
+}
+exports.default = encodeIEEE754DoublePrecisionFloat;
 //# sourceMappingURL=encodeIEEE754DoublePrecisionFloat.js.map

package/dist/node/utils/encodeIEEE754SinglePrecisionFloat.d.ts

@@ -1,2 +1,2 @@
-export default function encodeIEEE754SinglePrecisionFloat(value: number): Uint8Array;
+export default function encodeIEEE754SinglePrecisionFloat(value: number): Uint8Array;
 //# sourceMappingURL=encodeIEEE754SinglePrecisionFloat.d.ts.map

package/dist/node/utils/encodeIEEE754SinglePrecisionFloat.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function encodeIEEE754SinglePrecisionFloat(value) {
-    return new Uint8Array(new Float32Array([value]).buffer).reverse();
-}
-exports.default = encodeIEEE754SinglePrecisionFloat;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function encodeIEEE754SinglePrecisionFloat(value) {
+    return new Uint8Array(new Float32Array([value]).buffer).reverse();
+}
+exports.default = encodeIEEE754SinglePrecisionFloat;
 //# sourceMappingURL=encodeIEEE754SinglePrecisionFloat.js.map

package/dist/node/utils/encodeSignedBigEndianInteger.d.ts

@@ -1,2 +1,2 @@
-export default function encodeBigEndianSignedInteger(value: number): Uint8Array;
+export default function encodeBigEndianSignedInteger(value: number): Uint8Array;
 //# sourceMappingURL=encodeSignedBigEndianInteger.d.ts.map

package/dist/node/utils/encodeSignedBigEndianInteger.js

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const errors = (0, tslib_1.__importStar)(require("../errors"));
-const values_1 = require("../values");
-function encodeBigEndianSignedInteger(value) {
-    if (value < values_1.MIN_SINT_32) {
-        throw new errors.ASN1OverflowError(`Number ${value} too small to be encoded as a big-endian signed integer.`);
-    }
-    if (value > values_1.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),
-        ]);
-    }
-}
-exports.default = encodeBigEndianSignedInteger;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const errors = (0, tslib_1.__importStar)(require("../errors"));
+const values_1 = require("../values");
+function encodeBigEndianSignedInteger(value) {
+    if (value < values_1.MIN_SINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too small to be encoded as a big-endian signed integer.`);
+    }
+    if (value > values_1.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),
+        ]);
+    }
+}
+exports.default = encodeBigEndianSignedInteger;
 //# sourceMappingURL=encodeSignedBigEndianInteger.js.map

package/dist/node/utils/encodeUnsignedBigEndianInteger.d.ts

@@ -1,2 +1,2 @@
-export default function encodeUnsignedBigEndianInteger(value: number): Uint8Array;
+export default function encodeUnsignedBigEndianInteger(value: number): Uint8Array;
 //# sourceMappingURL=encodeUnsignedBigEndianInteger.d.ts.map

package/dist/node/utils/encodeUnsignedBigEndianInteger.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const errors = (0, tslib_1.__importStar)(require("../errors"));
-const values_1 = require("../values");
-function encodeUnsignedBigEndianInteger(value) {
-    if (value < values_1.MIN_UINT_32) {
-        throw new errors.ASN1OverflowError(`Number ${value} too small to be encoded as a big-endian unsigned integer.`);
-    }
-    if (value > values_1.MAX_UINT_32) {
-        throw new errors.ASN1OverflowError(`Number ${value} too big to be encoded as a big-endian unsigned integer.`);
-    }
-    const bytes = (new Uint8Array((new Uint32Array([value]).buffer))).reverse();
-    let startOfNonPadding = 0;
-    for (let i = 0; i < bytes.length - 1; i++) {
-        if (bytes[i] === 0x00) {
-            startOfNonPadding++;
-        }
-        else {
-            break;
-        }
-    }
-    return bytes.slice(startOfNonPadding);
-}
-exports.default = encodeUnsignedBigEndianInteger;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const errors = (0, tslib_1.__importStar)(require("../errors"));
+const values_1 = require("../values");
+function encodeUnsignedBigEndianInteger(value) {
+    if (value < values_1.MIN_UINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too small to be encoded as a big-endian unsigned integer.`);
+    }
+    if (value > values_1.MAX_UINT_32) {
+        throw new errors.ASN1OverflowError(`Number ${value} too big to be encoded as a big-endian unsigned integer.`);
+    }
+    const bytes = (new Uint8Array((new Uint32Array([value]).buffer))).reverse();
+    let startOfNonPadding = 0;
+    for (let i = 0; i < bytes.length - 1; i++) {
+        if (bytes[i] === 0x00) {
+            startOfNonPadding++;
+        }
+        else {
+            break;
+        }
+    }
+    return bytes.slice(startOfNonPadding);
+}
+exports.default = encodeUnsignedBigEndianInteger;
 //# sourceMappingURL=encodeUnsignedBigEndianInteger.js.map

package/dist/node/utils/encodeX690Base10RealNumber.d.ts

@@ -1,2 +1,2 @@
-export default function encodeX690Base10RealNumber(value: number): Uint8Array;
+export default function encodeX690Base10RealNumber(value: number): Uint8Array;
 //# sourceMappingURL=encodeX690Base10RealNumber.d.ts.map

package/dist/node/utils/encodeX690Base10RealNumber.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const values_1 = require("../values");
-const convertTextToBytes_1 = (0, tslib_1.__importDefault)(require("./convertTextToBytes"));
-function encodeX690Base10RealNumber(value) {
-    if (value === 0.0) {
-        return new Uint8Array(0);
-    }
-    else if (Number.isNaN(value)) {
-        return new Uint8Array([values_1.ASN1SpecialRealValue.notANumber]);
-    }
-    else if (value === -0.0) {
-        return new Uint8Array([values_1.ASN1SpecialRealValue.minusZero]);
-    }
-    else if (value === Infinity) {
-        return new Uint8Array([values_1.ASN1SpecialRealValue.plusInfinity]);
-    }
-    else if (value === -Infinity) {
-        return new Uint8Array([values_1.ASN1SpecialRealValue.minusInfinity]);
-    }
-    const valueString = (String.fromCharCode(0b00000011) + value.toFixed(7));
-    return (0, convertTextToBytes_1.default)(valueString);
-}
-exports.default = encodeX690Base10RealNumber;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const values_1 = require("../values");
+const convertTextToBytes_1 = (0, tslib_1.__importDefault)(require("./convertTextToBytes"));
+function encodeX690Base10RealNumber(value) {
+    if (value === 0.0) {
+        return new Uint8Array(0);
+    }
+    else if (Number.isNaN(value)) {
+        return new Uint8Array([values_1.ASN1SpecialRealValue.notANumber]);
+    }
+    else if (value === -0.0) {
+        return new Uint8Array([values_1.ASN1SpecialRealValue.minusZero]);
+    }
+    else if (value === Infinity) {
+        return new Uint8Array([values_1.ASN1SpecialRealValue.plusInfinity]);
+    }
+    else if (value === -Infinity) {
+        return new Uint8Array([values_1.ASN1SpecialRealValue.minusInfinity]);
+    }
+    const valueString = (String.fromCharCode(0b00000011) + value.toFixed(7));
+    return (0, convertTextToBytes_1.default)(valueString);
+}
+exports.default = encodeX690Base10RealNumber;
 //# sourceMappingURL=encodeX690Base10RealNumber.js.map

package/dist/node/utils/encodeX690BinaryRealNumber.d.ts

@@ -1,2 +1,2 @@
-export default function encodeX690BinaryRealNumber(value: number): Uint8Array;
+export default function encodeX690BinaryRealNumber(value: number): Uint8Array;
 //# sourceMappingURL=encodeX690BinaryRealNumber.d.ts.map