strtok3 6.2.1 → 6.3.0

package/README.md

@@ -30,6 +30,10 @@ It can read from:
 npm install strtok3
 ```
 
+### Compatibility
+
+NPM module is compliant with [ECMAScript 2018 (ES9)](https://en.wikipedia.org/wiki/ECMAScript#9th_Edition_%E2%80%93_ECMAScript_2018).
+
 ## API
 
 Use one of the methods to instantiate an [*abstract tokenizer*](#tokenizer):
@@ -48,7 +52,7 @@ All of the strtok3 methods return a [*tokenizer*](#tokenizer), either directly o
 |-----------|-----------------------|----------------------------|
 | path      | Path to file (string) | Path to file to read from  |
 
-Note that [file-information](#file-information) is automatically added.
+> __Note__: that [file-information](#file-information) is automatically added.
 
 Returns, via a promise, a [*tokenizer*](#tokenizer) which can be used to parse a file.
 
@@ -131,10 +135,9 @@ If a *position* is provided to a *read* or *peek* method, is should be, at least
 
 ### Tokenizer methods 
 
-There are to groups of methods
-
-*   *read* methods: used to read a *token* of [Buffer](https://nodejs.org/api/buffer.html) from the [*tokenizer*](#tokenizer). The position of the *tokenizer-stream* will advance with the size of the token.
-*   *peek* methods: same as the read, but it will *not* advance the pointer. It allows to read (peek) ahead.
+There are two kind of methods:
+1.   *read* methods: used to read a *token* of [Buffer](https://nodejs.org/api/buffer.html) from the [*tokenizer*](#tokenizer). The position of the *tokenizer-stream* will advance with the size of the token.
+2.   *peek* methods: same as the read, but it will *not* advance the pointer. It allows to read (peek) ahead.
 
 #### Method `tokenizer.readBuffer()`
 

package/lib/AbstractTokenizer.d.ts

@@ -1,5 +1,11 @@
 import { ITokenizer, IFileInfo, IReadChunkOptions } from './types';
 import { IGetToken, IToken } from '@tokenizer/token';
+interface INormalizedReadChunkOptions extends IReadChunkOptions {
+    offset: number;
+    length: number;
+    position: number;
+    mayBeLess?: boolean;
+}
 /**
  * Core tokenizer
  */
@@ -20,11 +26,11 @@ export declare abstract class AbstractTokenizer implements ITokenizer {
     abstract readBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     /**
      * Peek (read ahead) buffer from tokenizer
-     * @param buffer - Target buffer to fill with data peek from the tokenizer-stream
+     * @param uint8Array- Target buffer to fill with data peek from the tokenizer-stream
      * @param options - Peek behaviour options
      * @returns Promise with number of bytes read
      */
-    abstract peekBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    abstract peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     /**
      * Read a token from the tokenizer-stream
      * @param token - The token to read
@@ -53,9 +59,11 @@ export declare abstract class AbstractTokenizer implements ITokenizer {
     peekNumber(token: IToken<number>): Promise<number>;
     /**
      * Ignore number of bytes, advances the pointer in under tokenizer-stream.
-     * @param length - Number of bytes to skip (ignore)
-     * @return actual number of bytes ignored
+     * @param length - Number of bytes to ignore
+     * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
      */
-    abstract ignore(length: number): Promise<number>;
+    ignore(length: number): Promise<number>;
     close(): Promise<void>;
+    protected normalizeOptions(uint8Array: Uint8Array, options?: IReadChunkOptions): INormalizedReadChunkOptions;
 }
+export {};

package/lib/AbstractTokenizer.js

@@ -20,7 +20,7 @@ class AbstractTokenizer {
      * @param position - If provided, the desired position in the tokenizer-stream
      * @returns Promise with token data
      */
-    async readToken(token, position) {
+    async readToken(token, position = this.position) {
         const uint8Array = Buffer.alloc(token.len);
         const len = await this.readBuffer(uint8Array, { position });
         if (len < token.len)
@@ -62,8 +62,43 @@ class AbstractTokenizer {
             throw new peek_readable_1.EndOfStreamError();
         return token.get(this.numBuffer, 0);
     }
+    /**
+     * Ignore number of bytes, advances the pointer in under tokenizer-stream.
+     * @param length - Number of bytes to ignore
+     * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
+     */
+    async ignore(length) {
+        if (this.fileInfo.size !== undefined) {
+            const bytesLeft = this.fileInfo.size - this.position;
+            if (length > bytesLeft) {
+                this.position += bytesLeft;
+                return bytesLeft;
+            }
+        }
+        this.position += length;
+        return length;
+    }
     async close() {
         // empty
     }
+    normalizeOptions(uint8Array, options) {
+        if (options && options.position !== undefined && options.position < this.position) {
+            throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
+        }
+        if (options) {
+            return {
+                mayBeLess: options.mayBeLess === true,
+                offset: options.offset ? options.offset : 0,
+                length: options.length ? options.length : (uint8Array.length - (options.offset ? options.offset : 0)),
+                position: options.position ? options.position : this.position
+            };
+        }
+        return {
+            mayBeLess: false,
+            offset: 0,
+            length: uint8Array.length,
+            position: this.position
+        };
+    }
 }
 exports.AbstractTokenizer = AbstractTokenizer;

package/lib/BufferTokenizer.d.ts

@@ -1,22 +1,20 @@
-import { IFileInfo, IReadChunkOptions, ITokenizer } from './types';
-import { IGetToken, IToken } from '@tokenizer/token';
-export declare class BufferTokenizer implements ITokenizer {
+import { IFileInfo, IReadChunkOptions } from './types';
+import { AbstractTokenizer } from './AbstractTokenizer';
+export declare class BufferTokenizer extends AbstractTokenizer {
     private uint8Array;
-    fileInfo: IFileInfo;
-    position: number;
     /**
      * Construct BufferTokenizer
-     * @param buffer - Buffer to tokenize
+     * @param uint8Array - Uint8Array to tokenize
      * @param fileInfo - Pass additional file information to the tokenizer
      */
     constructor(uint8Array: Uint8Array, fileInfo?: IFileInfo);
     /**
      * Read buffer from tokenizer
-     * @param buffer
+     * @param uint8Array - Uint8Array to tokenize
      * @param options - Read behaviour options
      * @returns {Promise<number>}
      */
-    readBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    readBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     /**
      * Peek (read ahead) buffer from tokenizer
      * @param uint8Array
@@ -24,13 +22,5 @@ export declare class BufferTokenizer implements ITokenizer {
      * @returns {Promise<number>}
      */
     peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    readToken<T>(token: IGetToken<T>, position?: number): Promise<T>;
-    peekToken<T>(token: IGetToken<T>, position?: number): Promise<T>;
-    readNumber(token: IToken<number>): Promise<number>;
-    peekNumber(token: IToken<number>): Promise<number>;
-    /**
-     * @return actual number of bytes ignored
-     */
-    ignore(length: number): Promise<number>;
     close(): Promise<void>;
 }

package/lib/BufferTokenizer.js

@@ -2,35 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferTokenizer = void 0;
 const peek_readable_1 = require("peek-readable");
-class BufferTokenizer {
+const AbstractTokenizer_1 = require("./AbstractTokenizer");
+class BufferTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
     /**
      * Construct BufferTokenizer
-     * @param buffer - Buffer to tokenize
+     * @param uint8Array - Uint8Array to tokenize
      * @param fileInfo - Pass additional file information to the tokenizer
      */
     constructor(uint8Array, fileInfo) {
+        super(fileInfo);
         this.uint8Array = uint8Array;
-        this.position = 0;
-        this.fileInfo = fileInfo ? fileInfo : {};
         this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
     }
     /**
      * Read buffer from tokenizer
-     * @param buffer
+     * @param uint8Array - Uint8Array to tokenize
      * @param options - Read behaviour options
      * @returns {Promise<number>}
      */
-    async readBuffer(buffer, options) {
+    async readBuffer(uint8Array, options) {
         if (options && options.position) {
             if (options.position < this.position) {
                 throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
             }
             this.position = options.position;
         }
-        return this.peekBuffer(buffer, options).then(bytesRead => {
-            this.position += bytesRead;
-            return bytesRead;
-        });
+        const bytesRead = await this.peekBuffer(uint8Array, options);
+        this.position += bytesRead;
+        return bytesRead;
     }
     /**
      * Peek (read ahead) buffer from tokenizer
@@ -39,74 +38,16 @@ class BufferTokenizer {
      * @returns {Promise<number>}
      */
     async peekBuffer(uint8Array, options) {
-        let offset = 0;
-        let length = uint8Array.length;
-        let position = this.position;
-        if (options) {
-            if (options.position) {
-                if (options.position < this.position) {
-                    throw new Error('`options.position` can be less than `tokenizer.position`');
-                }
-                position = options.position;
-            }
-            if (Number.isInteger(options.length)) {
-                length = options.length;
-            }
-            else {
-                length -= options.offset || 0;
-            }
-            if (options.offset) {
-                offset = options.offset;
-            }
-        }
-        if (length === 0) {
-            return Promise.resolve(0);
-        }
-        position = position || this.position;
-        if (!length) {
-            length = uint8Array.length;
-        }
-        const bytes2read = Math.min(this.uint8Array.length - position, length);
-        if ((!options || !options.mayBeLess) && bytes2read < length) {
+        const normOptions = this.normalizeOptions(uint8Array, options);
+        const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
+        if ((!normOptions.mayBeLess) && bytes2read < normOptions.length) {
             throw new peek_readable_1.EndOfStreamError();
         }
         else {
-            uint8Array.set(this.uint8Array.subarray(position, position + bytes2read), offset);
+            uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);
             return bytes2read;
         }
     }
-    async readToken(token, position) {
-        this.position = position || this.position;
-        try {
-            const tv = this.peekToken(token, this.position);
-            this.position += token.len;
-            return tv;
-        }
-        catch (err) {
-            this.position += this.uint8Array.length - position;
-            throw err;
-        }
-    }
-    async peekToken(token, position = this.position) {
-        if (this.uint8Array.length - position < token.len) {
-            throw new peek_readable_1.EndOfStreamError();
-        }
-        return token.get(this.uint8Array, position);
-    }
-    async readNumber(token) {
-        return this.readToken(token);
-    }
-    async peekNumber(token) {
-        return this.peekToken(token);
-    }
-    /**
-     * @return actual number of bytes ignored
-     */
-    async ignore(length) {
-        const bytesIgnored = Math.min(this.uint8Array.length - this.position, length);
-        this.position += bytesIgnored;
-        return bytesIgnored;
-    }
     async close() {
         // empty
     }

package/lib/FileTokenizer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { AbstractTokenizer } from './AbstractTokenizer';
 import { IFileInfo, IReadChunkOptions } from './types';
 export declare class FileTokenizer extends AbstractTokenizer {
@@ -6,23 +5,18 @@ export declare class FileTokenizer extends AbstractTokenizer {
     constructor(fd: number, fileInfo: IFileInfo);
     /**
      * Read buffer from file
-     * @param buffer
+     * @param uint8Array - Uint8Array to write result to
      * @param options - Read behaviour options
      * @returns Promise number of bytes read
      */
-    readBuffer(buffer: Buffer, options?: IReadChunkOptions): Promise<number>;
+    readBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     /**
      * Peek buffer from file
-     * @param buffer
+     * @param uint8Array - Uint8Array (or Buffer) to write data to
      * @param options - Read behaviour options
      * @returns Promise number of bytes read
      */
-    peekBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    /**
-     * @param length - Number of bytes to ignore
-     * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
-     */
-    ignore(length: number): Promise<number>;
+    peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     close(): Promise<void>;
 }
 export declare function fromFile(sourceFilePath: string): Promise<FileTokenizer>;

package/lib/FileTokenizer.js

@@ -11,91 +11,34 @@ class FileTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
     }
     /**
      * Read buffer from file
-     * @param buffer
+     * @param uint8Array - Uint8Array to write result to
      * @param options - Read behaviour options
      * @returns Promise number of bytes read
      */
-    async readBuffer(buffer, options) {
-        let offset = 0;
-        let length = buffer.length;
-        if (options) {
-            if (options.position) {
-                if (options.position < this.position) {
-                    throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
-                }
-                this.position = options.position;
-            }
-            if (Number.isInteger(options.length)) {
-                length = options.length;
-            }
-            else {
-                length -= options.offset || 0;
-            }
-            if (options.offset) {
-                offset = options.offset;
-            }
-        }
-        if (length === 0) {
-            return Promise.resolve(0);
-        }
-        const res = await fs.read(this.fd, buffer, offset, length, this.position);
+    async readBuffer(uint8Array, options) {
+        const normOptions = this.normalizeOptions(uint8Array, options);
+        this.position = normOptions.position;
+        const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
         this.position += res.bytesRead;
-        if (res.bytesRead < length && (!options || !options.mayBeLess)) {
+        if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
             throw new peek_readable_1.EndOfStreamError();
         }
         return res.bytesRead;
     }
     /**
      * Peek buffer from file
-     * @param buffer
+     * @param uint8Array - Uint8Array (or Buffer) to write data to
      * @param options - Read behaviour options
      * @returns Promise number of bytes read
      */
-    async peekBuffer(buffer, options) {
-        let offset = 0;
-        let length = buffer.length;
-        let position = this.position;
-        if (options) {
-            if (options.position) {
-                if (options.position < this.position) {
-                    throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
-                }
-                position = options.position;
-            }
-            if (Number.isInteger(options.length)) {
-                length = options.length;
-            }
-            else {
-                length -= options.offset || 0;
-            }
-            if (options.offset) {
-                offset = options.offset;
-            }
-        }
-        if (length === 0) {
-            return Promise.resolve(0);
-        }
-        const res = await fs.read(this.fd, buffer, offset, length, position);
-        if ((!options || !options.mayBeLess) && res.bytesRead < length) {
+    async peekBuffer(uint8Array, options) {
+        const normOptions = this.normalizeOptions(uint8Array, options);
+        const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
+        if ((!normOptions.mayBeLess) && res.bytesRead < normOptions.length) {
             throw new peek_readable_1.EndOfStreamError();
         }
         return res.bytesRead;
     }
-    /**
-     * @param length - Number of bytes to ignore
-     * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
-     */
-    async ignore(length) {
-        const bytesLeft = this.fileInfo.size - this.position;
-        if (length <= bytesLeft) {
-            this.position += length;
-            return length;
-        }
-        else {
-            this.position += bytesLeft;
-            return bytesLeft;
-        }
-    }
     async close() {
         return fs.close(this.fd);
     }

package/lib/FsPromise.d.ts

@@ -11,7 +11,7 @@ export declare const pathExists: typeof fs.existsSync;
 export declare const createReadStream: typeof fs.createReadStream;
 export declare function stat(path: fs.PathLike): Promise<fs.Stats>;
 export declare function close(fd: number): Promise<void>;
-export declare function open(path: fs.PathLike, mode?: string): Promise<number>;
+export declare function open(path: fs.PathLike, mode: fs.Mode): Promise<number>;
 export declare function read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number): Promise<IReadResult>;
 export declare function writeFile(path: fs.PathLike, data: Buffer | string): Promise<void>;
 export declare function writeFileSync(path: fs.PathLike, data: Buffer | string): void;

package/lib/ReadStreamTokenizer.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import { AbstractTokenizer } from './AbstractTokenizer';
-import * as Stream from 'stream';
+import { Readable } from 'stream';
 import { IFileInfo, IReadChunkOptions } from './types';
 export declare class ReadStreamTokenizer extends AbstractTokenizer {
     private streamReader;
-    constructor(stream: Stream.Readable, fileInfo?: IFileInfo);
+    constructor(stream: Readable, fileInfo?: IFileInfo);
     /**
      * Get file information, an HTTP-client may implement this doing a HEAD request
      * @return Promise with file information
@@ -12,17 +12,17 @@ export declare class ReadStreamTokenizer extends AbstractTokenizer {
     getFileInfo(): Promise<IFileInfo>;
     /**
      * Read buffer from tokenizer
-     * @param buffer - Target buffer to fill with data read from the tokenizer-stream
+     * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
      * @param options - Read behaviour options
      * @returns Promise with number of bytes read
      */
-    readBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    readBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     /**
      * Peek (read ahead) buffer from tokenizer
-     * @param buffer - Target buffer to write the data read to
+     * @param uint8Array - Uint8Array (or Buffer) to write data to
      * @param options - Read behaviour options
      * @returns Promise with number of bytes peeked
      */
-    peekBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     ignore(length: number): Promise<number>;
 }

package/lib/ReadStreamTokenizer.js

@@ -18,92 +18,64 @@ class ReadStreamTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
     }
     /**
      * Read buffer from tokenizer
-     * @param buffer - Target buffer to fill with data read from the tokenizer-stream
+     * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
      * @param options - Read behaviour options
      * @returns Promise with number of bytes read
      */
-    async readBuffer(buffer, options) {
-        // const _offset = position ? position : this.position;
-        // debug(`readBuffer ${_offset}...${_offset + length - 1}`);
-        let offset = 0;
-        let length = buffer.length;
-        if (options) {
-            if (Number.isInteger(options.length)) {
-                length = options.length;
-            }
-            else {
-                length -= options.offset || 0;
-            }
-            if (options.position) {
-                const skipBytes = options.position - this.position;
-                if (skipBytes > 0) {
-                    await this.ignore(skipBytes);
-                    return this.readBuffer(buffer, options);
-                }
-                else if (skipBytes < 0) {
-                    throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
-                }
-            }
-            if (options.offset) {
-                offset = options.offset;
-            }
+    async readBuffer(uint8Array, options) {
+        const normOptions = this.normalizeOptions(uint8Array, options);
+        const skipBytes = normOptions.position - this.position;
+        if (skipBytes > 0) {
+            await this.ignore(skipBytes);
+            return this.readBuffer(uint8Array, options);
+        }
+        else if (skipBytes < 0) {
+            throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
         }
-        if (length === 0) {
+        if (normOptions.length === 0) {
             return 0;
         }
-        const bytesRead = await this.streamReader.read(buffer, offset, length);
+        const bytesRead = await this.streamReader.read(uint8Array, normOptions.offset, normOptions.length);
         this.position += bytesRead;
-        if ((!options || !options.mayBeLess) && bytesRead < length) {
+        if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) {
             throw new peek_readable_1.EndOfStreamError();
         }
         return bytesRead;
     }
     /**
      * Peek (read ahead) buffer from tokenizer
-     * @param buffer - Target buffer to write the data read to
+     * @param uint8Array - Uint8Array (or Buffer) to write data to
      * @param options - Read behaviour options
      * @returns Promise with number of bytes peeked
      */
-    async peekBuffer(buffer, options) {
-        // const _offset = position ? position : this.position;
-        // debug(`peek ${_offset}...${_offset + length - 1}`);
-        let offset = 0;
-        let bytesRead;
-        let length = buffer.length;
-        if (options) {
-            if (options.offset) {
-                offset = options.offset;
+    async peekBuffer(uint8Array, options) {
+        const normOptions = this.normalizeOptions(uint8Array, options);
+        let bytesRead = 0;
+        if (normOptions.position) {
+            const skipBytes = normOptions.position - this.position;
+            if (skipBytes > 0) {
+                const skipBuffer = new Uint8Array(normOptions.length + skipBytes);
+                bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess });
+                uint8Array.set(skipBuffer.subarray(skipBytes), normOptions.offset);
+                return bytesRead - skipBytes;
             }
-            if (Number.isInteger(options.length)) {
-                length = options.length;
+            else if (skipBytes < 0) {
+                throw new Error('Cannot peek from a negative offset in a stream');
             }
-            else {
-                length -= options.offset || 0;
+        }
+        if (normOptions.length > 0) {
+            try {
+                bytesRead = await this.streamReader.peek(uint8Array, normOptions.offset, normOptions.length);
             }
-            if (options.position) {
-                const skipBytes = options.position - this.position;
-                if (skipBytes > 0) {
-                    const skipBuffer = new Uint8Array(length + skipBytes);
-                    bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: options.mayBeLess });
-                    buffer.set(skipBuffer.subarray(skipBytes), offset);
-                    return bytesRead - skipBytes;
-                }
-                else if (skipBytes < 0) {
-                    throw new Error('Cannot peek from a negative offset in a stream');
+            catch (err) {
+                if (options && options.mayBeLess && err instanceof peek_readable_1.EndOfStreamError) {
+                    return 0;
                 }
+                throw err;
             }
-        }
-        try {
-            bytesRead = await this.streamReader.peek(buffer, offset, length);
-        }
-        catch (err) {
-            if (options && options.mayBeLess && err instanceof peek_readable_1.EndOfStreamError) {
-                return 0;
+            if ((!normOptions.mayBeLess) && bytesRead < normOptions.length) {
+                throw new peek_readable_1.EndOfStreamError();
             }
-            throw err;
-        }
-        if ((!options || !options.mayBeLess) && bytesRead < length) {
-            throw new peek_readable_1.EndOfStreamError();
         }
         return bytesRead;
     }

package/lib/core.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { ReadStreamTokenizer } from './ReadStreamTokenizer';
-import * as Stream from 'stream';
+import { Readable } from 'stream';
 import { BufferTokenizer } from './BufferTokenizer';
 import { IFileInfo } from './types';
 export { EndOfStreamError } from 'peek-readable';
@@ -10,10 +10,10 @@ export { IToken, IGetToken } from '@tokenizer/token';
  * Construct ReadStreamTokenizer from given Stream.
  * Will set fileSize, if provided given Stream has set the .path property/
  * @param stream - Read from Node.js Stream.Readable
- * @param fileInfo - Pass the file information, like size and MIME-type of the correspnding stream.
+ * @param fileInfo - Pass the file information, like size and MIME-type of the corresponding stream.
  * @returns ReadStreamTokenizer
  */
-export declare function fromStream(stream: Stream.Readable, fileInfo?: IFileInfo): ReadStreamTokenizer;
+export declare function fromStream(stream: Readable, fileInfo?: IFileInfo): ReadStreamTokenizer;
 /**
  * Construct ReadStreamTokenizer from given Buffer.
  * @param uint8Array - Uint8Array to tokenize

package/lib/core.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: func
  * Construct ReadStreamTokenizer from given Stream.
  * Will set fileSize, if provided given Stream has set the .path property/
  * @param stream - Read from Node.js Stream.Readable
- * @param fileInfo - Pass the file information, like size and MIME-type of the correspnding stream.
+ * @param fileInfo - Pass the file information, like size and MIME-type of the corresponding stream.
  * @returns ReadStreamTokenizer
  */
 function fromStream(stream, fileInfo) {

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import * as Stream from 'stream';
+import { Readable } from 'stream';
 import { ReadStreamTokenizer } from './ReadStreamTokenizer';
 import * as core from './core';
 export { fromFile } from './FileTokenizer';
@@ -12,4 +12,4 @@ export { IToken, IGetToken } from '@tokenizer/token';
  * @param fileInfo - Pass additional file information to the tokenizer
  * @returns Tokenizer
  */
-export declare function fromStream(stream: Stream.Readable, fileInfo?: core.IFileInfo): Promise<ReadStreamTokenizer>;
+export declare function fromStream(stream: Readable, fileInfo?: core.IFileInfo): Promise<ReadStreamTokenizer>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strtok3",
-  "version": "6.2.1",
+  "version": "6.3.0",
   "description": "A promise based streaming tokenizer",
   "author": {
     "name": "Borewit",
@@ -19,6 +19,7 @@
     "eslint": "eslint lib test --ext .ts --ignore-pattern *.d.ts",
     "lint-md": "remark -u preset-lint-recommended .",
     "lint": "npm run lint-md && npm run eslint",
+    "fix": "eslint lib test --ext .ts --ignore-pattern *.d.ts --fix",
     "test": "mocha --require ts-node/register --require source-map-support/register --full-trace test/test.ts",
     "test-coverage": "nyc npm run test",
     "send-coveralls": "nyc report --reporter=text-lcov | coveralls",
@@ -43,32 +44,34 @@
     "url": "https://github.com/Borewit/strtok3/issues"
   },
   "devDependencies": {
-    "@tokenizer/token": "^0.3.0",
-    "@types/chai": "^4.2.21",
-    "@types/debug": "^4.1.6",
-    "@types/mocha": "^8.2.3",
-    "@types/node": "^16.3.2",
-    "@typescript-eslint/eslint-plugin": "^2.34.0",
-    "@typescript-eslint/eslint-plugin-tslint": "^4.28.3",
-    "@typescript-eslint/parser": "^2.34.0",
-    "chai": "^4.3.4",
+    "@types/chai": "^4.3.0",
+    "@types/debug": "^4.1.7",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^17.0.14",
+    "@typescript-eslint/eslint-plugin": "^5.10.2",
+    "@typescript-eslint/parser": "^5.10.2",
+    "chai": "^4.3.6",
     "coveralls": "^3.1.1",
     "del-cli": "^4.0.1",
-    "eslint": "^6.8.0",
-    "eslint-plugin-import": "^2.23.4",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
-    "mocha": "^9.0.2",
+    "eslint": "^8.8.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-import-resolver-typescript": "^2.5.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jsdoc": "^37.7.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-unicorn": "^40.1.0",
+    "mocha": "^9.2.0",
     "nyc": "^15.1.0",
-    "remark-cli": "^9.0.0",
-    "remark-preset-lint-recommended": "^5.0.0",
-    "source-map-support": "^0.5.16",
-    "token-types": "^4.0.1",
-    "ts-node": "^10.1.0",
-    "tslint": "^6.1.3",
-    "typescript": "^4.3.5"
+    "remark-cli": "^10.0.1",
+    "remark-preset-lint-recommended": "^6.1.2",
+    "source-map-support": "^0.5.21",
+    "token-types": "^4.1.1",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.5"
   },
   "dependencies": {
-    "peek-readable": "^4.0.0"
+    "@tokenizer/token": "^0.3.0",
+    "peek-readable": "^4.1.0"
   },
   "keywords": [
     "tokenizer",