token-types - npm Package Compare versions

Comparing version 1.1.0 to 1.2.0

lib/index.d.ts

@@ -98,2 +98,34 @@ /// <reference types="node" />
 /**
+ * IEEE 754 16-bit (half precision) float, big endian
+ */
+export declare const Float16_BE: IToken<number>;
+/**
+ * IEEE 754 16-bit (half precision) float, little endian
+ */
+export declare const Float16_LE: IToken<number>;
+/**
+ * IEEE 754 32-bit (single precision) float, big endian
+ */
+export declare const Float32_BE: IToken<number>;
+/**
+ * IEEE 754 32-bit (single precision) float, little endian
+ */
+export declare const Float32_LE: IToken<number>;
+/**
+ * IEEE 754 64-bit (double precision) float, big endian
+ */
+export declare const Float64_BE: IToken<number>;
+/**
+ * IEEE 754 64-bit (double precision) float, little endian
+ */
+export declare const Float64_LE: IToken<number>;
+/**
+ * IEEE 754 80-bit (extended precision) float, big endian
+ */
+export declare const Float80_BE: IToken<number>;
+/**
+ * IEEE 754 80-bit (extended precision) float, little endian
+ */
+export declare const Float80_LE: IToken<number>;
+/**
  * Ignore a given number of bytes
@@ -100,0 +132,0 @@ */

lib/index.js

@@ -5,7 +5,8 @@ "use strict";
 const assert = require("assert");
+const ieee754 = require("ieee754");
 // Possibly call flush()
 const maybeFlush = (b, o, len, flush) => {
     if (o + len > b.length) {
-        if (typeof (flush) !== "function") {
-            throw new Error("Buffer out of space and no valid flush() function found");
+        if (typeof (flush) !== 'function') {
+            throw new Error('Buffer out of space and no valid flush() function found');
         }
@@ -27,4 +28,4 @@ flush(b, o);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xff);
@@ -47,4 +48,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xffff);
@@ -67,4 +68,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xffff);
@@ -87,4 +88,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xffffff);
@@ -107,4 +108,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xffffff);
@@ -127,4 +128,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xffffffff);
@@ -147,4 +148,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= 0 && v <= 0xffffffff);
@@ -167,4 +168,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -128 && v <= 127);
@@ -187,4 +188,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -32768 && v <= 32767);
@@ -207,4 +208,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -32768 && v <= 32767);
@@ -227,4 +228,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -0x800000 && v <= 0x7fffff);
@@ -247,4 +248,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -0x800000 && v <= 0x7fffff);
@@ -267,4 +268,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -2147483648 && v <= 2147483647);
@@ -287,4 +288,4 @@ assert.ok(o >= 0);
     put(b, o, v, flush) {
-        assert.equal(typeof o, "number");
-        assert.equal(typeof v, "number");
+        assert.equal(typeof o, 'number');
+        assert.equal(typeof v, 'number');
         assert.ok(v >= -2147483648 && v <= 2147483647);
@@ -327,4 +328,4 @@ assert.ok(o >= 0);
     len: 8,
-    get(buf, off) {
-        return readUIntBE(buf, off, this.len);
+    get(b, off) {
+        return readUIntBE(b, off, this.len);
     },
@@ -340,4 +341,4 @@ put(b, o, v) {
     len: 8,
-    get(buf, off) {
-        return readIntBE(buf, off, this.len);
+    get(b, off) {
+        return readIntBE(b, off, this.len);
     },
@@ -349,2 +350,98 @@ put(b, off, v) {
 /**
+ * IEEE 754 16-bit (half precision) float, big endian
+ */
+exports.Float16_BE = {
+    len: 2,
+    get(b, off) {
+        return ieee754.read(b, off, false, 10, this.len);
+    },
+    put(b, off, v) {
+        return ieee754.write(b, v, off, false, 10, this.len);
+    }
+};
+/**
+ * IEEE 754 16-bit (half precision) float, little endian
+ */
+exports.Float16_LE = {
+    len: 2,
+    get(b, off) {
+        return ieee754.read(b, off, true, 10, this.len);
+    },
+    put(b, off, v) {
+        return ieee754.write(b, v, off, true, 10, this.len);
+    }
+};
+/**
+ * IEEE 754 32-bit (single precision) float, big endian
+ */
+exports.Float32_BE = {
+    len: 4,
+    get(b, off) {
+        return b.readFloatBE(off);
+    },
+    put(b, off, v) {
+        return b.writeFloatBE(v, off);
+    }
+};
+/**
+ * IEEE 754 32-bit (single precision) float, little endian
+ */
+exports.Float32_LE = {
+    len: 4,
+    get(b, off) {
+        return b.readFloatLE(off);
+    },
+    put(b, off, v) {
+        return b.writeFloatLE(v, off);
+    }
+};
+/**
+ * IEEE 754 64-bit (double precision) float, big endian
+ */
+exports.Float64_BE = {
+    len: 8,
+    get(b, off) {
+        return b.readDoubleBE(off);
+    },
+    put(b, off, v) {
+        return b.writeDoubleBE(v, off);
+    }
+};
+/**
+ * IEEE 754 64-bit (double precision) float, little endian
+ */
+exports.Float64_LE = {
+    len: 8,
+    get(b, off) {
+        return b.readDoubleLE(off);
+    },
+    put(b, off, v) {
+        return b.writeDoubleLE(v, off);
+    }
+};
+/**
+ * IEEE 754 80-bit (extended precision) float, big endian
+ */
+exports.Float80_BE = {
+    len: 10,
+    get(b, off) {
+        return ieee754.read(b, off, false, 63, this.len);
+    },
+    put(b, off, v) {
+        return ieee754.write(b, v, off, false, 63, this.len);
+    }
+};
+/**
+ * IEEE 754 80-bit (extended precision) float, little endian
+ */
+exports.Float80_LE = {
+    len: 10,
+    get(b, off) {
+        return ieee754.read(b, off, true, 63, this.len);
+    },
+    put(b, off, v) {
+        return ieee754.write(b, v, off, true, 63, this.len);
+    }
+};
+/**
  * Ignore a given number of bytes
@@ -395,3 +492,3 @@ */
     static decode(buffer, off, until) {
-        let str = "";
+        let str = '';
         for (let i = off; i < until; ++i) {
@@ -420,3 +517,3 @@ str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));
         if (codePoint === null) {
-            throw Error("invaliding encoding");
+            throw Error('invaliding encoding');
         }
@@ -423,0 +520,0 @@ return codePoint;

package.json

 {
   "name": "token-types",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Common token types for decoding and encoding binairy values",
@@ -40,5 +40,5 @@ "author": {
   "devDependencies": {
-    "@types/chai": "^4.2.4",
+    "@types/chai": "^4.2.5",
     "@types/mocha": "^5.2.5",
-    "@types/node": "^12.12.3",
+    "@types/node": "^12.12.5",
     "chai": "^4.2.0",
@@ -49,10 +49,12 @@ "coveralls": "^3.0.7",
     "nyc": "^14.1.1",
-    "remark-cli": "^7.0.0",
+    "remark-cli": "^7.0.1",
     "remark-preset-lint-recommended": "^3.0.3",
     "source-map-support": "^0.5.16",
-    "ts-node": "^8.4.1",
-    "tslint": "^5.20.0",
-    "typescript": "^3.6.4"
+    "ts-node": "^8.5.2",
+    "tslint": "^5.20.1",
+    "typescript": "^3.7.2"
   },
-  "dependencies": {},
+  "dependencies": {
+    "ieee754": "^1.1.13"
+  },
   "remarkConfig": {
@@ -78,3 +80,13 @@ "plugins": [
     "report-dir": "coverage"
-  }
+  },
+  "keywords": [
+    "token",
+    "integer",
+    "unsigned",
+    "numeric",
+    "float",
+    "IEEE",
+    "754",
+    "strtok3"
+  ]
 }

README.md

@@ -12,18 +12,45 @@ [![Build Status](https://travis-ci.org/Borewit/token-types.svg?branch=master)](https://travis-ci.org/Borewit/token-types)
 
+# strtok3
+
 A primitive token library used to read from, and to write a node `Buffer`.
+Although it is possible to use this module directly, it is designed to be used with [strtok3 tokenizer](https://github.com/Borewit/strtok3).
 
-### Tokens
+## Installation
 
+```sh
+npm add strtok3
+```
+
+## Tokens
+
 `node-strtok` supports a wide variety of numerical tokens out of the box:
 
-*   `UINT8`
-*   `UINT16_BE`, `UINT16_LE`
-*   `UINT24_BE`, `UINT24_LE`
-*   `UINT32_BE`, `UINT32_LE`
-*   `UINT64_BE`, `UINT64_LE`*
-*   `INT8`
-*   `INT16_BE`, `INT16_LE`
-*   `INT24_BE`, `INT24_LE`
-*   `INT32_BE`, `INT32_LE`
-*   `INT64_BE`, `UINT64_LE`*
+| Token         | Number           | Bits | Endianness     |
+|---------------|------------------|------|----------------|
+| `UINT8`       | Unsigned integer |    8 | n/a            |
+| `UINT16_BE`   | Unsigned integer |   16 | big endian     |
+| `UINT16_LE`   | Unsigned integer |   16 | little endian  |
+| `UINT24_BE`   | Unsigned integer |   24 | big endian     |
+| `UINT24_LE`   | Unsigned integer |   24 | little endian  |
+| `UINT32_BE`   | Unsigned integer |   32 | big endian     |
+| `UINT32_LE`   | Unsigned integer |   32 | little endian  |
+| `UINT64_BE`   | Unsigned integer |   64 | big endian     |
+| `UINT64_LE`*  | Unsigned integer |   64 | little endian  |
+| `INT8`        | Signed integer   |    8 | n/a            |
+| `INT16_BE`    | Signed integer   |   16 | big endian     |
+| `INT16_LE`    | Signed integer   |   16 | little endian  |
+| `INT24_BE`    | Signed integer   |   24 | big endian     |
+| `INT24_LE`    | Signed integer   |   24 | little endian  |
+| `INT32_BE`    | Signed integer   |   32 | big endian     |
+| `INT32_LE`    | Signed integer   |   32 | little endian  |
+| `INT64_BE`    | Signed integer   |   64 | big endian     |
+| `INT64_LE`*   | Signed integer   |   64 | little endian  |
+| `Float16_BE`  | IEEE 754 float   |   16 | big endian     |
+| `Float16_LE`  | IEEE 754 float   |   16 | little endian  |
+| `Float32_BE`  | IEEE 754 float   |   32 | big endian     |
+| `Float32_LE`  | IEEE 754 float   |   32 | little endian  |
+| `Float64_BE`  | IEEE 754 float   |   64 | big endian     |
+| `Float64_LE`  | IEEE 754 float   |   64 | little endian  |
+| `Float80_BE`* | IEEE 754 float   |   80 | big endian     |
+| `Float80_LE`* | IEEE 754 float   |   80 | little endian  |
 
@@ -34,3 +61,3 @@ String types:
   
-*) The 64-bit tokens are best effort based, since JavaScript limit value size to less than 2^64.
+*) The tokens exceed the JavaScript IEEE 754 64-bit Floating Point precision, decoding and encoding is best effort based.
 
@@ -37,0 +64,0 @@ Complex tokens can be added, which makes very suitable for reading binary files or network messages:

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

30820

increased by18.46%

Lines of code

847

increased by17.97%

Number of lines in readme file

81

increased by50%

Worsened metrics

Dependency count

1

increased byInfinity%

Dependency changes

• + Addedieee754@^1.1.13

• + Addedieee754@1.2.1(transitive)