chore: update dev dependencies

package.json

@@ -24,15 +24,15 @@
     "tsc-build": "tsc --project tsconfig.build.json"
   },
   "devDependencies": {
-    "@types/node": "^22.15.29",
-    "@vitest/coverage-v8": "^3.1.4",
-    "@zakodium/tsconfig": "^1.0.0",
-    "eslint": "^9.28.0",
-    "eslint-config-cheminfo-typescript": "^18.0.1",
-    "prettier": "^3.5.3",
+    "@types/node": "^24.0.14",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@zakodium/tsconfig": "^1.0.2",
+    "eslint": "^9.31.0",
+    "eslint-config-cheminfo-typescript": "^19.0.0",
+    "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.4"
+    "vitest": "^3.2.4"
   },
   "repository": {
     "type": "git",

src/__tests__/core.test.ts

@@ -4,6 +4,7 @@ import { IOBuffer } from '../iobuffer.ts';
 
 describe('core methods', () => {
   let buffer: IOBuffer;
+
   beforeEach(() => {
     buffer = new IOBuffer();
   });
@@ -14,13 +15,18 @@ describe('core methods', () => {
 
   it('should report availability', () => {
     buffer.length = 15;
+
     expect(buffer.available(15)).toBe(true);
     expect(buffer.available(20)).toBe(false);
+
     buffer.skip(1);
+
     expect(buffer.available(15)).toBe(false);
     expect(buffer.available(14)).toBe(true);
     expect(buffer.available(5)).toBe(true);
+
     buffer.seek(14);
+
     expect(buffer.available()).toBe(true);
     expect(buffer.available(1)).toBe(true);
     expect(buffer.available(2)).toBe(false);
@@ -29,39 +35,56 @@ describe('core methods', () => {
   it('get/set endianess', () => {
     expect(buffer.isLittleEndian()).toBe(true);
     expect(buffer.isBigEndian()).toBe(false);
+
     buffer.setBigEndian();
+
     expect(buffer.isLittleEndian()).toBe(false);
     expect(buffer.isBigEndian()).toBe(true);
+
     buffer.setLittleEndian();
+
     expect(buffer.isLittleEndian()).toBe(true);
     expect(buffer.isBigEndian()).toBe(false);
   });
 
   it('skip', () => {
     buffer.skip();
+
     expect(buffer.offset).toBe(1);
+
     buffer.skip();
     buffer.skip(1);
+
     expect(buffer.offset).toBe(3);
+
     buffer.skip(5);
+
     expect(buffer.offset).toBe(8);
   });
 
   it('back', () => {
     buffer.offset = 8;
     buffer.back(5);
+
     expect(buffer.offset).toBe(3);
+
     buffer.back(1);
     buffer.back();
+
     expect(buffer.offset).toBe(1);
+
     buffer.back();
+
     expect(buffer.offset).toBe(0);
   });
 
   it('seek', () => {
     buffer.seek(0);
+
     expect(buffer.offset).toBe(0);
+
     buffer.seek(12);
+
     expect(buffer.offset).toBe(12);
   });
 
@@ -71,6 +94,7 @@ describe('core methods', () => {
     buffer.skip(2);
     buffer.seek(3);
     buffer.reset();
+
     expect(buffer.offset).toBe(12);
   });
 
@@ -79,15 +103,22 @@ describe('core methods', () => {
     buffer.pushMark();
     buffer.seek(10);
     buffer.popMark();
+
     expect(buffer.offset).toBe(5);
+
     buffer.pushMark();
     buffer.seek(12);
     buffer.pushMark();
     buffer.skip(1);
+
     expect(buffer.offset).toBe(13);
+
     buffer.popMark();
+
     expect(buffer.offset).toBe(12);
+
     buffer.popMark();
+
     expect(buffer.offset).toBe(5);
     expect(() => {
       buffer.popMark();
@@ -97,11 +128,13 @@ describe('core methods', () => {
   it('rewind', () => {
     buffer.seek(10);
     buffer.rewind();
+
     expect(buffer.offset).toBe(0);
   });
 
   it('is chainable', () => {
     const io = new IOBuffer();
+
     expect(() => {
       io.writeChars('abc')
         .writeUint32(10)

src/__tests__/offset.test.ts

@@ -7,14 +7,17 @@ describe('test with offset', () => {
     const io1 = new IOBuffer(10);
     io1.writeBytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
     const io2 = new IOBuffer(io1, { offset: 4 });
+
     expect(io2).toHaveLength(6);
     expect(io2.readByte()).toBe(4);
     expect(io2.readByte()).toBe(5);
     expect(io2.readByte()).toBe(6);
     expect(io2.readByte()).toBe(7);
   });
+
   it('should add offset for new data', () => {
     const io = new IOBuffer(128, { offset: 10 });
+
     expect(io.byteLength).toBe(118);
   });
 });

src/__tests__/read.test.ts

@@ -5,27 +5,36 @@ import { IOBuffer } from '../iobuffer.ts';
 describe('read data', () => {
   const data = new Uint32Array([0xff00ff00, 0x00ff00ff]);
   let buffer: IOBuffer;
+
   beforeEach(() => {
     buffer = new IOBuffer(data);
   });
 
   it('construct', () => {
     // ArrayBuffer
     let theBuffer = new IOBuffer(new ArrayBuffer(4));
+
     expect(theBuffer).toHaveLength(4);
+
     // Typed array
     theBuffer = new IOBuffer(new Uint8Array(2));
+
     expect(theBuffer).toHaveLength(2);
+
     theBuffer = new IOBuffer(new Uint16Array(2));
+
     expect(theBuffer).toHaveLength(4);
+
     // Node.js buffer
     theBuffer = new IOBuffer(Buffer.alloc(5));
+
     expect(theBuffer).toHaveLength(5);
   });
 
   it('read too far', () => {
     buffer.readUint16();
     buffer.readUint32();
+
     expect(() => buffer.readUint32()).toThrow(RangeError);
   });
 
@@ -102,6 +111,7 @@ describe('read data', () => {
       .split('')
       .map((char) => char.codePointAt(0) as number);
     const theBuffer = new IOBuffer(new Uint8Array(chars));
+
     expect(theBuffer.readChar()).toBe('h');
     expect(theBuffer.readChars()).toBe('e');
     expect(theBuffer.readChars(3)).toBe('llo');
@@ -111,11 +121,16 @@ describe('read data', () => {
     const theBuffer = new IOBuffer(
       Buffer.from([42, 0x34, 0x32, 0xe2, 0x82, 0xac, 42]),
     );
+
     expect(theBuffer.readByte()).toBe(42);
+
     const str = theBuffer.readUtf8(5);
+
     expect(str).toBe('42€');
     expect(theBuffer.readByte()).toBe(42);
+
     theBuffer.seek(1);
+
     expect(theBuffer.readUtf8()).toBe('4');
   });
 
@@ -126,11 +141,16 @@ describe('read data', () => {
         0x79, 0x6f, 0x73, 0x65, 0x6d, 0x69, 0x74, 0x65,
       ]),
     );
+
     expect(theBuffer.readByte()).toBe(42);
+
     const strE1 = theBuffer.decodeText(5);
+
     expect(strE1).toBe('42€');
     expect(theBuffer.readByte()).toBe(42);
+
     const strE2 = theBuffer.decodeText(4, 'windows-1251');
+
     expect(strE2).toBe('run!');
     expect(theBuffer.decodeText(1, 'windows-1251')).toBe('П');
     expect(theBuffer.decodeText(8, 'ISO-8859-2')).toBe('yosemite');

src/__tests__/read_array.test.ts

@@ -7,6 +7,7 @@ describe('readArray', () => {
     const buffer = new IOBuffer(new Uint8Array([1, 2]));
 
     const result = buffer.readArray(0, 'int8');
+
     // return empty typed array
     expect(result).toStrictEqual(new Int8Array([]));
     // do not change offset
@@ -18,11 +19,13 @@ describe('readArray', () => {
     buffer.setLittleEndian();
     buffer.readArray(0, 'int8');
     const sameLE = buffer.readArray(4, 'uint8');
+
     expect(buffer.offset).toBe(4);
 
     buffer.setBigEndian();
     buffer.offset = 0;
     const sameBE = buffer.readArray(4, 'uint8');
+
     expect(buffer.offset).toBe(4);
 
     expect(sameLE).toStrictEqual(sameBE);
@@ -41,6 +44,7 @@ describe('readArray', () => {
     // little endian
     let buffer = new IOBuffer(dataFromLE);
     const LeRes = buffer.readArray(2, 'uint16');
+
     expect(buffer.offset).toBe(4);
     expect(LeRes[0]).toBe(firstNumber);
     expect(LeRes[1]).toBe(secondNumber);
@@ -49,6 +53,7 @@ describe('readArray', () => {
     buffer = new IOBuffer(dataFromBE);
     buffer.setBigEndian();
     const BeRes = buffer.readArray(2, 'uint16');
+
     expect(buffer.offset).toBe(4);
     expect(BeRes[0]).toBe(firstNumber);
     expect(BeRes[1]).toBe(secondNumber);
@@ -64,6 +69,7 @@ describe('readArray', () => {
     // little endian
     let buffer = new IOBuffer(dataFromLE);
     const LeRes = buffer.readArray(2, 'int32');
+
     expect(buffer.offset).toBe(8);
     expect(LeRes[0]).toBe(firstNumber);
     expect(LeRes[1]).toBe(secondNumber);
@@ -72,10 +78,12 @@ describe('readArray', () => {
     buffer = new IOBuffer(dataFromBE);
     buffer.setBigEndian();
     const BeRes = buffer.readArray(2, 'int32');
+
     expect(buffer.offset).toBe(8);
     expect(BeRes[0]).toBe(firstNumber);
     expect(BeRes[1]).toBe(secondNumber);
   });
+
   it('uint 64', () => {
     //numbers taken from Buffer.readBigUIntLE in Node.js
     const dataFromLE = new Uint8Array([
@@ -90,6 +98,7 @@ describe('readArray', () => {
     // little endian
     let buffer = new IOBuffer(dataFromLE);
     const LeRes = buffer.readArray(2, 'uint64');
+
     expect(buffer.offset).toBe(16);
     expect(LeRes[0]).toBe(firstNumber);
     expect(LeRes[1]).toBe(secondNumber);
@@ -98,10 +107,12 @@ describe('readArray', () => {
     buffer = new IOBuffer(dataFromBE);
     buffer.setBigEndian();
     const BeRes = buffer.readArray(2, 'uint64');
+
     expect(buffer.offset).toBe(16);
     expect(BeRes[0]).toBe(firstNumber);
     expect(BeRes[1]).toBe(secondNumber);
   });
+
   it('float 32', () => {
     //numbers taken from Buffer.readFloatLE in Node.js
     const dataFromLE = new Uint8Array([1, 5, 3, 31, 3, 4, 40, 8]);
@@ -113,6 +124,7 @@ describe('readArray', () => {
     // little endian
     let buffer = new IOBuffer(dataFromLE);
     const res = buffer.readArray(2, 'float32');
+
     expect(buffer.offset).toBe(8);
     expect(res[0]).toBe(firstNumber);
     expect(res[1]).toBe(secondNumber);
@@ -122,10 +134,12 @@ describe('readArray', () => {
     buffer.offset = 0;
     buffer.setBigEndian();
     const resBE = buffer.readArray(2, 'float32');
+
     expect(buffer.offset).toBe(8);
     expect(resBE[0]).toBe(firstNumber);
     expect(resBE[1]).toBe(secondNumber);
   });
+
   it('float 64', () => {
     //numbers taken from Buffer.readDoubleLE in Node.js
     const dataFromLE = new Uint8Array([
@@ -140,6 +154,7 @@ describe('readArray', () => {
     // little endian
     let buffer = new IOBuffer(dataFromLE);
     const res = buffer.readArray(2, 'float64');
+
     expect(buffer.offset).toBe(16);
     expect(res[0]).toBe(firstNumber);
     expect(res[1]).toBe(secondNumber);
@@ -149,6 +164,7 @@ describe('readArray', () => {
     buffer.offset = 0;
     buffer.setBigEndian();
     const resBE = buffer.readArray(2, 'float64');
+
     expect(buffer.offset).toBe(16);
     expect(resBE[0]).toBe(firstNumber);
     expect(resBE[1]).toBe(secondNumber);