strtok3 7.1.0 → 8.0.0

package/README.md

@@ -1,4 +1,5 @@
-![Node.js CI](https://github.com/Borewit/strtok3/workflows/Node.js%20CI/badge.svg)
+[![Node.js CI](https://github.com/Borewit/strtok3/actions/workflows/nodejs-ci.yml/badge.svg?branch=master)](https://github.com/Borewit/strtok3/actions/workflows/nodejs-ci.yml?query=branch%3Amaster)
+[![CodeQL](https://github.com/Borewit/strtok3/actions/workflows/codeql.yml/badge.svg?branch=master)](https://github.com/Borewit/strtok3/actions/workflows/codeql.yml)
 [![NPM version](https://badge.fury.io/js/strtok3.svg)](https://npmjs.org/package/strtok3)
 [![npm downloads](http://img.shields.io/npm/dm/strtok3.svg)](https://npmcharts.com/compare/strtok3,token-types?start=1200&interval=30)
 [![DeepScan grade](https://deepscan.io/api/teams/5165/projects/8526/branches/103329/badge/grade.svg)](https://deepscan.io/dashboard#view=project&tid=5165&pid=8526&bid=103329)
@@ -32,7 +33,7 @@ npm install strtok3
 
 Module: version 7 migrated from [CommonJS](https://en.wikipedia.org/wiki/CommonJS) to [pure ECMAScript Module (ESM)](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
 JavaScript is compliant with [ECMAScript 2019 (ES10)](https://en.wikipedia.org/wiki/ECMAScript#10th_Edition_%E2%80%93_ECMAScript_2019).
-Requires Node.js ≥ 14.16 engine.
+Requires Node.js ≥ 16 engine.
 
 ## API
 

package/lib/AbstractTokenizer.d.ts

@@ -1,5 +1,5 @@
-import { ITokenizer, IFileInfo, IReadChunkOptions } from './types.js';
-import { IGetToken, IToken } from '@tokenizer/token';
+import type { ITokenizer, IFileInfo, IReadChunkOptions, ITokenizerOptions } from './types.js';
+import type { IGetToken, IToken } from '@tokenizer/token';
 interface INormalizedReadChunkOptions extends IReadChunkOptions {
     offset: number;
     length: number;
@@ -11,7 +11,13 @@ interface INormalizedReadChunkOptions extends IReadChunkOptions {
  */
 export declare abstract class AbstractTokenizer implements ITokenizer {
     fileInfo: IFileInfo;
-    protected constructor(fileInfo?: IFileInfo);
+    private onClose?;
+    /**
+     * Constructor
+     * @param options Tokenizer options
+     * @protected
+     */
+    protected constructor(options?: ITokenizerOptions);
     /**
      * Tokenizer-stream position
      */
@@ -26,7 +32,7 @@ export declare abstract class AbstractTokenizer implements ITokenizer {
     abstract readBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
     /**
      * Peek (read ahead) buffer from tokenizer
-     * @param uint8Array- Target buffer to fill with data peek from the tokenizer-stream
+     * @param uint8Array - Target buffer to fill with data peeked from the tokenizer-stream
      * @param options - Peek behaviour options
      * @returns Promise with number of bytes read
      */

package/lib/AbstractTokenizer.js

@@ -3,13 +3,20 @@ import { EndOfStreamError } from 'peek-readable';
  * Core tokenizer
  */
 export class AbstractTokenizer {
-    constructor(fileInfo) {
+    /**
+     * Constructor
+     * @param options Tokenizer options
+     * @protected
+     */
+    constructor(options) {
+        var _a;
         /**
          * Tokenizer-stream position
          */
         this.position = 0;
         this.numBuffer = new Uint8Array(8);
-        this.fileInfo = fileInfo ? fileInfo : {};
+        this.fileInfo = (_a = options === null || options === void 0 ? void 0 : options.fileInfo) !== null && _a !== void 0 ? _a : {};
+        this.onClose = options === null || options === void 0 ? void 0 : options.onClose;
     }
     /**
      * Read a token from the tokenizer-stream
@@ -76,7 +83,8 @@ export class AbstractTokenizer {
         return length;
     }
     async close() {
-        // empty
+        var _a;
+        await ((_a = this.onClose) === null || _a === void 0 ? void 0 : _a.call(this));
     }
     normalizeOptions(uint8Array, options) {
         if (options && options.position !== undefined && options.position < this.position) {

package/lib/BufferTokenizer.d.ts

@@ -1,13 +1,13 @@
-import { IFileInfo, IReadChunkOptions } from './types.js';
+import { ITokenizerOptions, IReadChunkOptions } from './types.js';
 import { AbstractTokenizer } from './AbstractTokenizer.js';
 export declare class BufferTokenizer extends AbstractTokenizer {
     private uint8Array;
     /**
      * Construct BufferTokenizer
      * @param uint8Array - Uint8Array to tokenize
-     * @param fileInfo - Pass additional file information to the tokenizer
+     * @param options Tokenizer options
      */
-    constructor(uint8Array: Uint8Array, fileInfo?: IFileInfo);
+    constructor(uint8Array: Uint8Array, options?: ITokenizerOptions);
     /**
      * Read buffer from tokenizer
      * @param uint8Array - Uint8Array to tokenize

package/lib/BufferTokenizer.js

@@ -4,10 +4,10 @@ export class BufferTokenizer extends AbstractTokenizer {
     /**
      * Construct BufferTokenizer
      * @param uint8Array - Uint8Array to tokenize
-     * @param fileInfo - Pass additional file information to the tokenizer
+     * @param options Tokenizer options
      */
-    constructor(uint8Array, fileInfo) {
-        super(fileInfo);
+    constructor(uint8Array, options) {
+        super(options);
         this.uint8Array = uint8Array;
         this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
     }
@@ -45,7 +45,7 @@ export class BufferTokenizer extends AbstractTokenizer {
             return bytes2read;
         }
     }
-    async close() {
-        // empty
+    close() {
+        return super.close();
     }
 }

package/lib/FileTokenizer.d.ts

@@ -1,8 +1,9 @@
 import { AbstractTokenizer } from './AbstractTokenizer.js';
-import { IFileInfo, IReadChunkOptions } from './types.js';
+import type { IReadChunkOptions, ITokenizerOptions } from './types.js';
+import { FileHandle } from 'node:fs/promises';
 export declare class FileTokenizer extends AbstractTokenizer {
-    private fd;
-    constructor(fd: number, fileInfo: IFileInfo);
+    private fileHandle;
+    constructor(fileHandle: FileHandle, options: ITokenizerOptions);
     /**
      * Read buffer from file
      * @param uint8Array - Uint8Array to write result to

package/lib/FileTokenizer.js

@@ -1,10 +1,10 @@
 import { AbstractTokenizer } from './AbstractTokenizer.js';
 import { EndOfStreamError } from 'peek-readable';
-import * as fs from './FsPromise.js';
+import { open as fsOpen } from 'node:fs/promises';
 export class FileTokenizer extends AbstractTokenizer {
-    constructor(fd, fileInfo) {
-        super(fileInfo);
-        this.fd = fd;
+    constructor(fileHandle, options) {
+        super(options);
+        this.fileHandle = fileHandle;
     }
     /**
      * Read buffer from file
@@ -15,7 +15,7 @@ export class FileTokenizer extends AbstractTokenizer {
     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);
+        const res = await this.fileHandle.read(uint8Array, normOptions.offset, normOptions.length, normOptions.position);
         this.position += res.bytesRead;
         if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
             throw new EndOfStreamError();
@@ -30,21 +30,19 @@ export class FileTokenizer extends AbstractTokenizer {
      */
     async peekBuffer(uint8Array, options) {
         const normOptions = this.normalizeOptions(uint8Array, options);
-        const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
+        const res = await this.fileHandle.read(uint8Array, normOptions.offset, normOptions.length, normOptions.position);
         if ((!normOptions.mayBeLess) && res.bytesRead < normOptions.length) {
             throw new EndOfStreamError();
         }
         return res.bytesRead;
     }
     async close() {
-        return fs.close(this.fd);
+        await this.fileHandle.close();
+        return super.close();
     }
 }
 export async function fromFile(sourceFilePath) {
-    const stat = await fs.stat(sourceFilePath);
-    if (!stat.isFile) {
-        throw new Error(`File not a file: ${sourceFilePath}`);
-    }
-    const fd = await fs.open(sourceFilePath, 'r');
-    return new FileTokenizer(fd, { path: sourceFilePath, size: stat.size });
+    const fileHandle = await fsOpen(sourceFilePath, 'r');
+    const stat = await fileHandle.stat();
+    return new FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat.size } });
 }

package/lib/ReadStreamTokenizer.d.ts

@@ -1,14 +1,14 @@
 import { AbstractTokenizer } from './AbstractTokenizer.js';
-import { IStreamReader } from 'peek-readable';
-import { IFileInfo, IReadChunkOptions } from './types.js';
+import { type IStreamReader } from 'peek-readable';
+import type { IReadChunkOptions, ITokenizerOptions } from './types.js';
 export declare class ReadStreamTokenizer extends AbstractTokenizer {
     private streamReader;
-    constructor(streamReader: IStreamReader, fileInfo?: IFileInfo);
     /**
-     * Get file information, an HTTP-client may implement this doing a HEAD request
-     * @return Promise with file information
+     * Constructor
+     * @param streamReader stream-reader to read from
+     * @param options Tokenizer options
      */
-    getFileInfo(): Promise<IFileInfo>;
+    constructor(streamReader: IStreamReader, options?: ITokenizerOptions);
     /**
      * Read buffer from tokenizer
      * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream

package/lib/ReadStreamTokenizer.js

@@ -2,16 +2,14 @@ import { AbstractTokenizer } from './AbstractTokenizer.js';
 import { EndOfStreamError } from 'peek-readable';
 const maxBufferSize = 256000;
 export class ReadStreamTokenizer extends AbstractTokenizer {
-    constructor(streamReader, fileInfo) {
-        super(fileInfo);
-        this.streamReader = streamReader;
-    }
     /**
-     * Get file information, an HTTP-client may implement this doing a HEAD request
-     * @return Promise with file information
+     * Constructor
+     * @param streamReader stream-reader to read from
+     * @param options Tokenizer options
      */
-    async getFileInfo() {
-        return this.fileInfo;
+    constructor(streamReader, options) {
+        super(options);
+        this.streamReader = streamReader;
     }
     /**
      * Read buffer from tokenizer

package/lib/core.d.ts

@@ -1,31 +1,31 @@
 import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
-import { Readable } from 'node:stream';
 import { BufferTokenizer } from './BufferTokenizer.js';
-import { IFileInfo } from './types.js';
+import type { ITokenizerOptions } from './types.js';
 import type { ReadableStream } from 'node:stream/web';
+import type { Readable } from 'node:stream';
 export { EndOfStreamError } from 'peek-readable';
-export { ITokenizer, IFileInfo } from './types.js';
-export { IToken, IGetToken } from '@tokenizer/token';
+export type { ITokenizer, IFileInfo, ITokenizerOptions, OnClose } from './types.js';
+export type { 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 corresponding stream.
+ * @param options - Tokenizer options
  * @returns ReadStreamTokenizer
  */
-export declare function fromStream(stream: Readable, fileInfo?: IFileInfo): ReadStreamTokenizer;
+export declare function fromStream(stream: Readable, options?: ITokenizerOptions): ReadStreamTokenizer;
 /**
  * Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
  * Will set fileSize, if provided given Stream has set the .path property/
  * @param webStream - Read from Node.js Stream.Readable
- * @param fileInfo - Pass the file information, like size and MIME-type of the corresponding stream.
+ * @param options - Tokenizer options
  * @returns ReadStreamTokenizer
  */
-export declare function fromWebStream(webStream: ReadableStream<Uint8Array>, fileInfo?: IFileInfo): ReadStreamTokenizer;
+export declare function fromWebStream(webStream: ReadableStream<Uint8Array>, options?: ITokenizerOptions): ReadStreamTokenizer;
 /**
  * Construct ReadStreamTokenizer from given Buffer.
  * @param uint8Array - Uint8Array to tokenize
- * @param fileInfo - Pass additional file information to the tokenizer
+ * @param options - Tokenizer options
  * @returns BufferTokenizer
  */
-export declare function fromBuffer(uint8Array: Uint8Array, fileInfo?: IFileInfo): BufferTokenizer;
+export declare function fromBuffer(uint8Array: Uint8Array, options?: ITokenizerOptions): BufferTokenizer;

package/lib/core.js

@@ -1,35 +1,33 @@
 import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
 import { BufferTokenizer } from './BufferTokenizer.js';
-import { StreamReader, WebStreamReader } from "peek-readable";
+import { StreamReader, WebStreamReader } from 'peek-readable';
 export { EndOfStreamError } from 'peek-readable';
 /**
  * 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 corresponding stream.
+ * @param options - Tokenizer options
  * @returns ReadStreamTokenizer
  */
-export function fromStream(stream, fileInfo) {
-    fileInfo = fileInfo ? fileInfo : {};
-    return new ReadStreamTokenizer(new StreamReader(stream), fileInfo);
+export function fromStream(stream, options) {
+    return new ReadStreamTokenizer(new StreamReader(stream), options);
 }
 /**
  * Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
  * Will set fileSize, if provided given Stream has set the .path property/
  * @param webStream - Read from Node.js Stream.Readable
- * @param fileInfo - Pass the file information, like size and MIME-type of the corresponding stream.
+ * @param options - Tokenizer options
  * @returns ReadStreamTokenizer
  */
-export function fromWebStream(webStream, fileInfo) {
-    fileInfo = fileInfo ? fileInfo : {};
-    return new ReadStreamTokenizer(new WebStreamReader(webStream), fileInfo);
+export function fromWebStream(webStream, options) {
+    return new ReadStreamTokenizer(new WebStreamReader(webStream), options);
 }
 /**
  * Construct ReadStreamTokenizer from given Buffer.
  * @param uint8Array - Uint8Array to tokenize
- * @param fileInfo - Pass additional file information to the tokenizer
+ * @param options - Tokenizer options
  * @returns BufferTokenizer
  */
-export function fromBuffer(uint8Array, fileInfo) {
-    return new BufferTokenizer(uint8Array, fileInfo);
+export function fromBuffer(uint8Array, options) {
+    return new BufferTokenizer(uint8Array, options);
 }

package/lib/index.d.ts

@@ -1,14 +1,14 @@
 import { Readable } from 'node:stream';
 import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
-import * as core from './core.js';
+import { type ITokenizerOptions } from './core.js';
 export { fromFile } from './FileTokenizer.js';
-export { ITokenizer, EndOfStreamError, fromBuffer, fromWebStream, IFileInfo } from './core.js';
+export { ITokenizer, EndOfStreamError, fromBuffer, fromWebStream, IFileInfo, ITokenizerOptions, OnClose } from './core.js';
 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 - Node.js Stream.Readable
- * @param fileInfo - Pass additional file information to the tokenizer
+ * @param options - Pass additional file information to the tokenizer
  * @returns Tokenizer
  */
-export declare function fromStream(stream: Readable, fileInfo?: core.IFileInfo): Promise<ReadStreamTokenizer>;
+export declare function fromStream(stream: Readable, options?: ITokenizerOptions): Promise<ReadStreamTokenizer>;

package/lib/index.js

@@ -1,20 +1,22 @@
-import * as fs from './FsPromise.js';
-import * as core from './core.js';
+import { stat as fsStat } from 'node:fs/promises';
+import { fromStream as coreFromStream } from './core.js';
 export { fromFile } from './FileTokenizer.js';
 export { EndOfStreamError, fromBuffer, fromWebStream } from './core.js';
 /**
  * Construct ReadStreamTokenizer from given Stream.
  * Will set fileSize, if provided given Stream has set the .path property.
  * @param stream - Node.js Stream.Readable
- * @param fileInfo - Pass additional file information to the tokenizer
+ * @param options - Pass additional file information to the tokenizer
  * @returns Tokenizer
  */
-export async function fromStream(stream, fileInfo) {
-    fileInfo = fileInfo ? fileInfo : {};
+export async function fromStream(stream, options) {
+    var _a;
+    const augmentedOptions = options !== null && options !== void 0 ? options : {};
+    augmentedOptions.fileInfo = (_a = augmentedOptions.fileInfo) !== null && _a !== void 0 ? _a : {};
     if (stream.path) {
-        const stat = await fs.stat(stream.path);
-        fileInfo.path = stream.path;
-        fileInfo.size = stat.size;
+        const stat = await fsStat(stream.path);
+        augmentedOptions.fileInfo.path = stream.path;
+        augmentedOptions.fileInfo.size = stat.size;
     }
-    return core.fromStream(stream, fileInfo);
+    return coreFromStream(stream, augmentedOptions);
 }

package/lib/types.d.ts

@@ -100,3 +100,14 @@ export interface ITokenizer {
      */
     close(): Promise<void>;
 }
+export type OnClose = () => Promise<void>;
+export interface ITokenizerOptions {
+    /**
+     * Pass additional file information to the tokenizer
+     */
+    fileInfo?: IFileInfo;
+    /**
+     * On tokenizer close handler
+     */
+    onClose?: OnClose;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strtok3",
-  "version": "7.1.0",
+  "version": "8.0.0",
   "description": "A promise based streaming tokenizer",
   "author": {
     "name": "Borewit",
@@ -11,12 +11,12 @@
     "url": "https://github.com/sponsors/Borewit"
   },
   "scripts": {
-    "clean": "del-cli lib/**/*.js lib/**/*.js.map lib/**/*.d.ts test/**/*.js test/**/*.js.map",
+    "clean": "del-cli 'lib/**/*.js' 'lib/**/*.js.map' 'lib/**/*.d.ts' 'test/**/*.js' 'test/**/*.js.map'",
     "compile-src": "tsc -p lib",
     "compile-test": "tsc -p test",
     "compile": "npm run compile-src && npm run compile-test",
     "build": "npm run clean && npm run compile",
-    "eslint": "eslint lib test --ext .ts --ignore-pattern *.d.ts",
+    "eslint": "eslint lib test",
     "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",
@@ -26,7 +26,7 @@
     "start": "npm run compile && npm run lint && npm run cover-test"
   },
   "engines": {
-    "node": ">=14.16"
+    "node": ">=16"
   },
   "repository": {
     "type": "git",
@@ -50,22 +50,26 @@
     "url": "https://github.com/Borewit/strtok3/issues"
   },
   "devDependencies": {
+    "@eslint/compat": "^1.1.1",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.7.0",
     "@types/chai": "^4.3.16",
     "@types/debug": "^4.1.12",
     "@types/mocha": "^10.0.7",
-    "@types/node": "^20.14.9",
-    "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "@typescript-eslint/parser": "^7.15.0",
+    "@types/node": "^20.14.10",
+    "@typescript-eslint/eslint-plugin": "^7.16.1",
+    "@typescript-eslint/parser": "^7.16.1",
     "c8": "^10.1.2",
     "chai": "^5.1.1",
     "del-cli": "^5.1.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.0.0",
+    "eslint": "^9.7.0",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-jsdoc": "^46.8.2",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^48.7.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-unicorn": "^54.0.0",
+    "global": "^4.4.0",
     "mocha": "^10.6.0",
     "remark-cli": "^12.0.1",
     "remark-preset-lint-recommended": "^7.0.0",
@@ -76,7 +80,7 @@
   },
   "dependencies": {
     "@tokenizer/token": "^0.3.0",
-    "peek-readable": "^5.1.1"
+    "peek-readable": "^5.1.3"
   },
   "keywords": [
     "tokenizer",
@@ -91,5 +95,6 @@
     "uint",
     "stream",
     "streaming"
-  ]
+  ],
+  "packageManager": "yarn@4.3.1"
 }

package/lib/FsPromise.d.ts

@@ -1,17 +0,0 @@
-/**
- * Module convert fs functions to promise based functions
- */
-import fs from 'node:fs';
-export interface IReadResult {
-    bytesRead: number;
-    buffer: Uint8Array;
-}
-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: 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: Uint8Array | string, options?: fs.WriteFileOptions): Promise<void>;
-export declare function writeFileSync(path: fs.PathLike, data: Uint8Array | string): void;
-export declare function readFile(path: fs.PathLike): Promise<Uint8Array>;

package/lib/FsPromise.js

@@ -1,69 +0,0 @@
-/**
- * Module convert fs functions to promise based functions
- */
-import fs from 'node:fs';
-export const pathExists = fs.existsSync;
-export const createReadStream = fs.createReadStream;
-export async function stat(path) {
-    return new Promise((resolve, reject) => {
-        fs.stat(path, (err, stats) => {
-            if (err)
-                reject(err);
-            else
-                resolve(stats);
-        });
-    });
-}
-export async function close(fd) {
-    return new Promise((resolve, reject) => {
-        fs.close(fd, err => {
-            if (err)
-                reject(err);
-            else
-                resolve();
-        });
-    });
-}
-export async function open(path, mode) {
-    return new Promise((resolve, reject) => {
-        fs.open(path, mode, (err, fd) => {
-            if (err)
-                reject(err);
-            else
-                resolve(fd);
-        });
-    });
-}
-export async function read(fd, buffer, offset, length, position) {
-    return new Promise((resolve, reject) => {
-        fs.read(fd, buffer, offset, length, position, (err, bytesRead, _buffer) => {
-            if (err)
-                reject(err);
-            else
-                resolve({ bytesRead, buffer: _buffer });
-        });
-    });
-}
-export async function writeFile(path, data, options = null) {
-    return new Promise((resolve, reject) => {
-        fs.writeFile(path, data, options, err => {
-            if (err)
-                reject(err);
-            else
-                resolve();
-        });
-    });
-}
-export function writeFileSync(path, data) {
-    fs.writeFileSync(path, data);
-}
-export async function readFile(path) {
-    return new Promise((resolve, reject) => {
-        fs.readFile(path, (err, buffer) => {
-            if (err)
-                reject(err);
-            else
-                resolve(buffer);
-        });
-    });
-}