Merge pull request #260 from jwetzell/dependabot/npm_and_yarn/biomejs/biome-2.5.7

Bump @biomejs/biome from 2.5.6 to 2.5.7

.prettierignore

@@ -1,2 +0,0 @@
-*.md
-*.min.*

.prettierrc.js

@@ -1,8 +0,0 @@
-module.exports = {
-  trailingComma: 'es5',
-  tabWidth: 2,
-  semi: true,
-  singleQuote: true,
-  bracketSameLine: true,
-  printWidth: 120,
-};

.vscode/extensions.json

@@ -1,3 +1,3 @@
 {
-  "recommendations": ["esbenp.prettier-vscode"]
+	"recommendations": ["esbenp.prettier-vscode"]
 }

.vscode/settings.json

@@ -1,8 +1,6 @@
 {
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
+	"editor.formatOnSave": true,
-  "editor.formatOnSave": true,
+	"editor.codeActionsOnSave": {
-  "editor.codeActionsOnSave": {
+		"source.fixAll": "explicit"
-    "source.fixAll": "explicit",
+	}
-    "source.organizeImports": "explicit"
-  }
 }

benchmark.js

@@ -6,70 +6,70 @@ const encoder = new Encoder('test encoder', 2, 3);
 const decoder = new Decoder();
 
 function getNTrackers(n) {
-  const trackers = [];
+	const trackers = [];
-  for (let index = 0; index < n; index += 1) {
+	for (let index = 0; index < n; index += 1) {
-    const tracker = new Tracker(index, `Tracker ${index}`);
+		const tracker = new Tracker(index, `Tracker ${index}`);
-    tracker.setPos(0, 0, 0);
+		tracker.setPos(0, 0, 0);
-    tracker.setSpeed(0, 0, 0);
+		tracker.setSpeed(0, 0, 0);
-    tracker.setOri(0, 0, 0);
+		tracker.setOri(0, 0, 0);
-    tracker.setAccel(0, 0, 0);
+		tracker.setAccel(0, 0, 0);
-    tracker.setTrgtPos(0, 0, 0);
+		tracker.setTrgtPos(0, 0, 0);
-    tracker.setStatus(1.0);
+		tracker.setStatus(1.0);
-    tracker.setTimestamp(Date.now());
+		tracker.setTimestamp(Date.now());
-    trackers.push(tracker);
+		trackers.push(tracker);
-  }
+	}
-  return trackers;
+	return trackers;
 }
 
 function benchmark(trackerCount, iterations) {
-  const benchmarkResults = {
+	const benchmarkResults = {
-    data: {},
+		data: {},
-    info: {},
+		info: {},
-  };
+	};
-  const trackers = getNTrackers(trackerCount);
+	const trackers = getNTrackers(trackerCount);
-  console.log(
+	console.log(
-    `processing ${trackers.length} tracker${trackers.length > 1 ? 's' : ''} ${iterations} time${
+		`processing ${trackers.length} tracker${trackers.length > 1 ? 's' : ''} ${iterations} time${
-      iterations > 1 ? 's' : ''
+			iterations > 1 ? 's' : ''
-    }`
+		}`
-  );
+	);
 
-  let latestEncodedPackets;
+	let latestEncodedPackets;
 
-  // DATA
+	// DATA
-  const dataEncoderStart = performance.now();
+	const dataEncoderStart = performance.now();
-  for (let index = 0; index < iterations; index += 1) {
+	for (let index = 0; index < iterations; index += 1) {
-    latestEncodedPackets = encoder.getDataPackets(Date.now(), trackers);
+		latestEncodedPackets = encoder.getDataPackets(Date.now(), trackers);
-  }
+	}
-  benchmarkResults.data.encode = performance.now() - dataEncoderStart;
+	benchmarkResults.data.encode = performance.now() - dataEncoderStart;
 
-  const dataDecodedStart = performance.now();
+	const dataDecodedStart = performance.now();
-  for (let index = 0; index < iterations; index += 1) {
+	for (let index = 0; index < iterations; index += 1) {
-    latestEncodedPackets.forEach((packet) => {
+		latestEncodedPackets.forEach((packet) => {
-      decoder.decode(packet);
+			decoder.decode(packet);
-    });
+		});
-  }
+	}
-  benchmarkResults.data.decode = performance.now() - dataDecodedStart;
+	benchmarkResults.data.decode = performance.now() - dataDecodedStart;
 
-  // INFO
+	// INFO
-  const infoEncoderStart = performance.now();
+	const infoEncoderStart = performance.now();
-  for (let index = 0; index < iterations; index += 1) {
+	for (let index = 0; index < iterations; index += 1) {
-    latestEncodedPackets = encoder.getInfoPackets(Date.now(), trackers);
+		latestEncodedPackets = encoder.getInfoPackets(Date.now(), trackers);
-  }
+	}
-  benchmarkResults.info.encode = performance.now() - infoEncoderStart;
+	benchmarkResults.info.encode = performance.now() - infoEncoderStart;
 
-  const infoDecodeStart = performance.now();
+	const infoDecodeStart = performance.now();
-  for (let index = 0; index < iterations; index += 1) {
+	for (let index = 0; index < iterations; index += 1) {
-    latestEncodedPackets.forEach((packet) => {
+		latestEncodedPackets.forEach((packet) => {
-      decoder.decode(packet);
+			decoder.decode(packet);
-    });
+		});
-  }
+	}
-  benchmarkResults.info.decode = performance.now() - infoDecodeStart;
+	benchmarkResults.info.decode = performance.now() - infoDecodeStart;
 
-  console.log(benchmarkResults);
+	console.log(benchmarkResults);
 }
 
 testSizes.forEach((iterations) => {
-  testSizes.forEach((trackerCount) => {
+	testSizes.forEach((trackerCount) => {
-    benchmark(trackerCount, iterations);
+		benchmark(trackerCount, iterations);
-  });
+	});
 });

biome.json

@@ -0,0 +1,35 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.5.3/schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"ignoreUnknown": false
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"preset": "recommended"
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "single",
+			"trailingCommas": "es5"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

eslint.config.mjs

@@ -1,13 +0,0 @@
-import pluginJs from '@eslint/js';
-import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
-import globals from 'globals';
-import tseslint from 'typescript-eslint';
-
-/** @type {import('eslint').Linter.Config[]} */
-export default [
-  { files: ['**/*.{js,mjs,cjs,ts}'] },
-  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
-  pluginJs.configs.recommended,
-  ...tseslint.configs.recommended,
-  eslintPluginPrettierRecommended,
-];

examples/decode.js

@@ -3,14 +3,17 @@ const { Decoder } = require('../dist/cjs');
 const decoder = new Decoder();
 
 const infoPacketBuffer = new Uint8Array([
-  0x56, 0x67, 0x34, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x01,
+	0x56, 0x67, 0x34, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-  0x01, 0x01, 0x00, 0x0b, 0x00, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x02, 0x00, 0x11,
+	0x00, 0x00, 0x00, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x0b, 0x00, 0x53, 0x65,
-  0x80, 0x01, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x09, 0x00, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x20, 0x31,
+	0x72, 0x76, 0x65, 0x72, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x02, 0x00, 0x11, 0x80,
+	0x01, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x09, 0x00, 0x54, 0x72, 0x61, 0x63, 0x6b,
+	0x65, 0x72, 0x20, 0x31,
 ]);
 const dataPacketBuffer = new Uint8Array([
-  0x55, 0x67, 0x28, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x01,
+	0x55, 0x67, 0x28, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-  0x01, 0x01, 0x00, 0x14, 0x80, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x14, 0x80, 0x01, 0x00,
-  0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f,
+	0x10, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80,
+	0x3f, 0x00, 0x00, 0x80, 0x3f,
 ]);
 
 decoder.decode(infoPacketBuffer);

examples/encode.js

@@ -16,11 +16,11 @@ const dataPackets = encoder.getDataPackets(timestamp, trackers);
 const infoPackets = encoder.getInfoPackets(timestamp, trackers);
 
 dataPackets.forEach((dataPacket) => {
-  console.log('send packet somehow');
+	console.log('send packet somehow');
-  console.log(dataPacket);
+	console.log(dataPacket);
 });
 
 infoPackets.forEach((infoPacket) => {
-  console.log('send packet somehow');
+	console.log('send packet somehow');
-  console.log(infoPacket);
+	console.log(infoPacket);
 });

examples/psn_client.js

@@ -1,56 +1,66 @@
 // recreation of psn_client.cpp example from https://github.com/vyv/psn-cpp
-const dgram = require('dgram');
+const dgram = require('node:dgram');
-const { Decoder } = require('../dist/cjs');
+const { Decoder } = require('@jwetzell/posistagenet');
 
 const client = dgram.createSocket('udp4');
 const decoder = new Decoder();
 
 client.on('listening', () => {
-  client.addMembership('236.10.10.10');
+	client.addMembership('236.10.10.10');
 });
 
 client.on('message', (buffer) => {
-  decoder.decode(buffer);
+	decoder.decode(buffer);
 });
 client.bind(56565, '0.0.0.0');
 
 setInterval(() => {
-  if (decoder.system_name) {
+	if (decoder.system_name) {
-    console.log(`System Name: ${decoder.system_name}`);
+		console.log(`System Name: ${decoder.system_name}`);
-  }
+	}
-  if (Object.keys(decoder.trackers).length > 0) {
+	if (Object.keys(decoder.trackers).length > 0) {
-    console.log(`Tracker Count: ${Object.keys(decoder.trackers).length}`);
+		console.log(`Tracker Count: ${Object.keys(decoder.trackers).length}`);
-  }
+	}
 
-  Object.entries(decoder.trackers).forEach(([trackerId, tracker]) => {
+	Object.entries(decoder.trackers).forEach(([trackerId, tracker]) => {
-    const trackerName = decoder.trackers[trackerId]?.name;
+		const trackerName = decoder.trackers[trackerId]?.name;
-    console.log(`Tracker - id: ${trackerId} | name: ${trackerName || ''}`);
+		console.log(`Tracker - id: ${trackerId} | name: ${trackerName || ''}`);
-    if (tracker.pos) {
+		if (tracker.pos) {
-      console.log(`\tpos: ${tracker.pos.x}, ${tracker.pos.x}, ${tracker.pos.x}`);
+			console.log(
-    }
+				`\tpos: ${tracker.pos.x}, ${tracker.pos.x}, ${tracker.pos.x}`
+			);
+		}
 
-    if (tracker.speed) {
+		if (tracker.speed) {
-      console.log(`\tspeed: ${tracker.speed.x}, ${tracker.speed.y}, ${tracker.speed.z}`);
+			console.log(
-    }
+				`\tspeed: ${tracker.speed.x}, ${tracker.speed.y}, ${tracker.speed.z}`
+			);
+		}
 
-    if (tracker.ori) {
+		if (tracker.ori) {
-      console.log(`\tori: ${tracker.ori.x}, ${tracker.ori.y}, ${tracker.ori.z}`);
+			console.log(
-    }
+				`\tori: ${tracker.ori.x}, ${tracker.ori.y}, ${tracker.ori.z}`
+			);
+		}
 
-    if (tracker.status) {
+		if (tracker.status) {
-      console.log(`\tstatus: ${tracker.status.validity}`);
+			console.log(`\tstatus: ${tracker.status.validity}`);
-    }
+		}
 
-    if (tracker.accel) {
+		if (tracker.accel) {
-      console.log(`\taccel: ${tracker.accel.x}, ${tracker.accel.y}, ${tracker.accel.z}`);
+			console.log(
-    }
+				`\taccel: ${tracker.accel.x}, ${tracker.accel.y}, ${tracker.accel.z}`
+			);
+		}
 
-    if (tracker.trgtpos) {
+		if (tracker.trgtpos) {
-      console.log(`\ttrgtpos: ${tracker.trgtpos.x}, ${tracker.trgtpos.y}, ${tracker.trgtpos.z}`);
+			console.log(
-    }
+				`\ttrgtpos: ${tracker.trgtpos.x}, ${tracker.trgtpos.y}, ${tracker.trgtpos.z}`
+			);
+		}
 
-    if (tracker.timestamp) {
+		if (tracker.timestamp) {
-      console.log(`\ttimestamp: ${tracker.timestamp}`);
+			console.log(`\ttimestamp: ${tracker.timestamp}`);
-    }
+		}
-  });
+	});
 }, 1000);

examples/psn_server.js

@@ -1,6 +1,6 @@
 // recreation of psn_server.cpp example from https://github.com/vyv/psn-cpp
-const dgram = require('dgram');
+const dgram = require('node:dgram');
-const { Encoder, Tracker } = require('../dist/cjs');
+const { Encoder, Tracker } = require('@jwetzell/posistagenet');
 
 const client = dgram.createSocket('udp4');
 const encoder = new Encoder('Test PSN Server', 2, 0);
@@ -19,38 +19,40 @@ trackers.push(new Tracker(8, 'Neptune'));
 trackers.push(new Tracker(9, 'Pluto'));
 
 const orbits = [1.0, 88.0, 224.7, 365.2, 687, 4332, 10760, 30700, 60200, 90600];
-const distFromSun = [0, 0.58, 1.08, 1.5, 2.28, 7.78, 14.29, 28.71, 45.04, 59.13];
+const distFromSun = [
+	0, 0.58, 1.08, 1.5, 2.28, 7.78, 14.29, 28.71, 45.04, 59.13,
+];
 
 let timestamp = 0;
 setInterval(() => {
-  orbits.forEach((orbit, index) => {
+	orbits.forEach((_, index) => {
-    const a = 1.0 / orbits[index];
+		const a = 1.0 / orbits[index];
-    const b = distFromSun[index];
+		const b = distFromSun[index];
-    const x = timestamp;
+		const x = timestamp;
-    const cb = Math.cos(a * x) * b;
+		const cb = Math.cos(a * x) * b;
-    const sb = Math.sin(a * x) * b;
+		const sb = Math.sin(a * x) * b;
 
-    trackers[index].setPos(sb, 0, cb);
+		trackers[index].setPos(sb, 0, cb);
-    trackers[index].setSpeed(a * cb, 0, -a * sb);
+		trackers[index].setSpeed(a * cb, 0, -a * sb);
-    trackers[index].setOri(0, x / 1000.0, 0);
+		trackers[index].setOri(0, x / 1000.0, 0);
-    trackers[index].setAccel(-a * a * sb, 0, -a * a * cb);
+		trackers[index].setAccel(-a * a * sb, 0, -a * a * cb);
-    trackers[index].setTrgtPos(3, 14, 16);
+		trackers[index].setTrgtPos(3, 14, 16);
-    trackers[index].setStatus(index / 10.0);
+		trackers[index].setStatus(index / 10.0);
-    trackers[index].setTimestamp(timestamp);
+		trackers[index].setTimestamp(timestamp);
-  });
+	});
 
-  console.log(`Sending Data Packets`);
+	console.log(`Sending Data Packets`);
-  const dataPackets = encoder.getDataPackets(timestamp, trackers);
+	const dataPackets = encoder.getDataPackets(timestamp, trackers);
-  dataPackets.forEach((packet) => {
+	dataPackets.forEach((packet) => {
-    client.send(packet, 56565, '236.10.10.10');
+		client.send(packet, 56565, '236.10.10.10');
-  });
+	});
-  timestamp += 1;
+	timestamp += 1;
 }, 5);
 
 setInterval(() => {
-  console.log(`Sending Info Packets`);
+	console.log(`Sending Info Packets`);
-  const infoPackets = encoder.getInfoPackets(timestamp, trackers);
+	const infoPackets = encoder.getInfoPackets(timestamp, trackers);
-  infoPackets.forEach((packet) => {
+	infoPackets.forEach((packet) => {
-    client.send(packet, 56565, '236.10.10.10');
+		client.send(packet, 56565, '236.10.10.10');
-  });
+	});
 }, 500);

package.json

@@ -1,50 +1,47 @@
 {
-  "name": "@jwetzell/posistagenet",
+	"name": "@jwetzell/posistagenet",
-  "version": "2.1.2",
+	"version": "2.1.2",
-  "description": "",
+	"description": "",
-  "main": "./dist/index.cjs",
+	"main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
-  "types": "./dist/index.d.cts",
+	"types": "./dist/index.d.cts",
-  "exports": {
+	"exports": {
-    ".": {
+		".": {
-      "import": "./dist/index.mjs",
+			"import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+			"require": "./dist/index.cjs"
-    },
+		},
-    "./package.json": "./package.json"
+		"./package.json": "./package.json"
-  },
+	},
-  "scripts": {
+	"scripts": {
-    "prebuild": "rimraf dist",
+		"prebuild": "rimraf dist",
-    "build": "tsdown",
+		"build": "tsdown",
-    "example:client": "node examples/psn_client.js",
+		"example:client": "node examples/psn_client.js",
-    "example:server": "node examples/psn_server.js",
+		"example:server": "node examples/psn_server.js",
-    "prepublishOnly": "npm run build",
+		"prepublishOnly": "npm run build",
-    "lint:check": "eslint ./src",
+		"lint:check": "biome lint",
-    "format:check": "prettier ./ --check",
+		"lint:write": "biome lint --write",
-    "format:write": "prettier ./ --write",
+		"format:check": "biome format",
-    "pretest": "npm run build",
+		"format:write": "biome format --write",
-    "test": "node --test --experimental-test-coverage"
+		"pretest": "npm run build",
-  },
+		"test": "node --test --experimental-test-coverage"
-  "files": [
+	},
-    "dist"
+	"files": [
-  ],
+		"dist"
-  "author": {
+	],
-    "name": "Joel Wetzell",
+	"author": {
-    "email": "me@jwetzell.com",
+		"name": "Joel Wetzell",
-    "url": "https://jwetzell.com"
+		"email": "me@jwetzell.com",
-  },
+		"url": "https://jwetzell.com"
-  "repository": "https://github.com/jwetzell/psn-js",
+	},
-  "license": "MIT",
+	"repository": "https://github.com/jwetzell/psn-js",
-  "devDependencies": {
+	"license": "MIT",
-    "@eslint/js": "10.0.1",
+	"devDependencies": {
-    "@types/node": "24.7.2",
+		"@biomejs/biome": "2.5.7",
-    "eslint": "10.5.0",
+		"@eslint/js": "10.0.1",
-    "eslint-config-prettier": "10.1.8",
+		"@types/node": "24.7.2",
-    "eslint-plugin-prettier": "5.5.6",
+		"globals": "17.9.0",
-    "globals": "17.6.0",
+		"rimraf": "6.1.3",
-    "prettier": "3.8.4",
+		"tsdown": "0.22.14",
-    "rimraf": "6.1.3",
+		"typescript": "7.0.2"
-    "tsdown": "0.22.2",
+	}
-    "typescript": "6.0.3",
-    "typescript-eslint": "8.61.0"
-  }
 }

src/constants.ts

@@ -1,5 +1,5 @@
 export class Constants {
-  static readonly PACKET_HEADER_SIZE = 16;
+	static readonly PACKET_HEADER_SIZE = 16;
-  static readonly MAX_UDP_PACKET_SIZE = 1500;
+	static readonly MAX_UDP_PACKET_SIZE = 1500;
-  static readonly CHUNK_HEADER_SIZE = 4;
+	static readonly CHUNK_HEADER_SIZE = 4;
 }

src/decoder.ts

@@ -1,119 +1,132 @@
 import { Decoders } from './index.js';
 import {
-  type DataPacketChunk,
+	type DataPacketChunk,
-  type InfoPacketChunk,
+	type InfoPacketChunk,
-  Tracker,
+	type Tracker,
-  TrackerFromData,
+	TrackerFromData,
-  TrackerFromInfo,
+	TrackerFromInfo,
 } from './models/index.js';
 
 export class Decoder {
-  infoPacketFrames: { [key: number]: InfoPacketChunk[] } = {};
+	infoPacketFrames: { [key: number]: InfoPacketChunk[] } = {};
 
-  dataPacketFrames: { [key: number]: DataPacketChunk[] } = {};
+	dataPacketFrames: { [key: number]: DataPacketChunk[] } = {};
 
-  trackers: { [key: string]: Tracker } = {};
+	trackers: { [key: string]: Tracker } = {};
 
-  systemName: string = '';
+	systemName: string = '';
-  constructor() {}
 
-  updateInfo(framePackets: InfoPacketChunk[]) {
+	updateInfo(framePackets: InfoPacketChunk[]) {
-    framePackets.forEach((packet) => {
+		framePackets.forEach((packet) => {
-      if (packet.data.systemName?.data) {
+			if (packet.data.systemName?.data) {
-        this.systemName = packet.data.systemName?.data.systemName;
+				this.systemName = packet.data.systemName?.data.systemName;
-      }
+			}
 
-      if (packet.data.trackerList?.data) {
+			if (packet.data.trackerList?.data) {
-        packet.data.trackerList.data.trackers.forEach((infoTrackerChunk) => {
+				packet.data.trackerList.data.trackers.forEach((infoTrackerChunk) => {
-          if (!this.trackers[infoTrackerChunk.chunk.header.id]) {
+					if (!this.trackers[infoTrackerChunk.chunk.header.id]) {
-            const tracker = TrackerFromInfo(infoTrackerChunk);
+						const tracker = TrackerFromInfo(infoTrackerChunk);
-            if (tracker) {
+						if (tracker) {
-              this.trackers[infoTrackerChunk.chunk.header.id] = tracker;
+							this.trackers[infoTrackerChunk.chunk.header.id] = tracker;
-            }
+						}
-          }
+					}
-          const tracker = this.trackers[infoTrackerChunk.chunk.header.id];
+					const tracker = this.trackers[infoTrackerChunk.chunk.header.id];
-          tracker.updateInfo(infoTrackerChunk);
+					tracker.updateInfo(infoTrackerChunk);
-        });
+				});
-      }
+			}
-    });
+		});
-  }
+	}
 
-  updateData(framePackets: DataPacketChunk[]) {
+	updateData(framePackets: DataPacketChunk[]) {
-    framePackets.forEach((packet) => {
+		framePackets.forEach((packet) => {
-      if (packet.data.trackerList) {
+			if (packet.data.trackerList) {
-        packet.data.trackerList?.data.trackers.forEach((dataTrackerChunk) => {
+				packet.data.trackerList?.data.trackers.forEach((dataTrackerChunk) => {
-          if (!this.trackers[dataTrackerChunk.chunk.header.id]) {
+					if (!this.trackers[dataTrackerChunk.chunk.header.id]) {
-            const tracker = TrackerFromData(dataTrackerChunk);
+						const tracker = TrackerFromData(dataTrackerChunk);
-            if (tracker) {
+						if (tracker) {
-              this.trackers[dataTrackerChunk.chunk.header.id] = tracker;
+							this.trackers[dataTrackerChunk.chunk.header.id] = tracker;
-            }
+						}
-          }
+					}
-          const tracker = this.trackers[dataTrackerChunk.chunk.header.id];
+					const tracker = this.trackers[dataTrackerChunk.chunk.header.id];
-          tracker.updateData(dataTrackerChunk);
+					tracker.updateData(dataTrackerChunk);
-        });
+				});
-      }
+			}
-    });
+		});
-  }
+	}
 
-  // TODO(jwetzell): add invalid frame id decoding. Scenario where a frame id is reused before one is complete
+	// TODO(jwetzell): add invalid frame id decoding. Scenario where a frame id is reused before one is complete
-  decode(packetBuf: Uint8Array) {
+	decode(packetBuf: Uint8Array) {
-    const packet = Decoders.Chunk(packetBuf);
+		const packet = Decoders.Chunk(packetBuf);
-    if (packet === undefined) {
+		if (packet === undefined) {
-      return packet;
+			return packet;
-    }
+		}
 
-    if (packet.header.id === 0x6756) {
+		if (packet.header.id === 0x6756) {
-      const infoPacket = Decoders.InfoPacketChunk(packetBuf);
+			const infoPacket = Decoders.InfoPacketChunk(packetBuf);
-      if (infoPacket && infoPacket.chunk.header.hasSubchunks) {
+			if (infoPacket?.chunk.header.hasSubchunks) {
-        const currentInfoPacketHeader = infoPacket.data.packetHeader;
+				const currentInfoPacketHeader = infoPacket.data.packetHeader;
-        if (!currentInfoPacketHeader) {
+				if (!currentInfoPacketHeader) {
-          // NOTE(jwetzell): not sure that info packets without a header subchunk are valid?
+					// NOTE(jwetzell): not sure that info packets without a header subchunk are valid?
-          throw new Error('malformed packet');
+					throw new Error('malformed packet');
-        }
+				}
 
-        const systemSubChunk = infoPacket.data.systemName;
+				const systemSubChunk = infoPacket.data.systemName;
-        if (!systemSubChunk) {
+				if (!systemSubChunk) {
-          // NOTE(jwetzell): not sure that info packets without a system subchunk are valid?
+					// NOTE(jwetzell): not sure that info packets without a system subchunk are valid?
-          throw new Error('malformed packet');
+					throw new Error('malformed packet');
-        }
+				}
-        if (currentInfoPacketHeader.data.frameId) {
+				if (currentInfoPacketHeader.data.frameId) {
-          if (this.infoPacketFrames[currentInfoPacketHeader.data.frameId] === undefined) {
+					if (
-            this.infoPacketFrames[currentInfoPacketHeader.data.frameId] = [];
+						this.infoPacketFrames[currentInfoPacketHeader.data.frameId] ===
-          }
+						undefined
-          this.infoPacketFrames[currentInfoPacketHeader.data.frameId].push(infoPacket);
+					) {
+						this.infoPacketFrames[currentInfoPacketHeader.data.frameId] = [];
+					}
+					this.infoPacketFrames[currentInfoPacketHeader.data.frameId].push(
+						infoPacket
+					);
 
-          if (
+					if (
-            this.infoPacketFrames[currentInfoPacketHeader.data.frameId].length ===
+						this.infoPacketFrames[currentInfoPacketHeader.data.frameId]
-            currentInfoPacketHeader.data.framePacketCount
+							.length === currentInfoPacketHeader.data.framePacketCount
-          ) {
+					) {
-            this.updateInfo(this.infoPacketFrames[currentInfoPacketHeader.data.frameId]);
+						this.updateInfo(
-            delete this.infoPacketFrames[currentInfoPacketHeader.data.frameId];
+							this.infoPacketFrames[currentInfoPacketHeader.data.frameId]
-          }
+						);
-        }
+						delete this.infoPacketFrames[currentInfoPacketHeader.data.frameId];
-      }
+					}
-    } else if (packet.header.id === 0x6755) {
+				}
-      const dataPacket = Decoders.DataPacketChunk(packetBuf);
+			}
-      if (dataPacket.chunk.header.hasSubchunks) {
+		} else if (packet.header.id === 0x6755) {
-        const currentDataPacketHeader = dataPacket.data.packetHeader;
+			const dataPacket = Decoders.DataPacketChunk(packetBuf);
-        if (!currentDataPacketHeader) {
+			if (dataPacket.chunk.header.hasSubchunks) {
-          // NOTE(jwetzell): not sure that info packets without a header subchunk are valid?
+				const currentDataPacketHeader = dataPacket.data.packetHeader;
-          throw new Error('malformed packet');
+				if (!currentDataPacketHeader) {
-        }
+					// NOTE(jwetzell): not sure that info packets without a header subchunk are valid?
+					throw new Error('malformed packet');
+				}
 
-        if (currentDataPacketHeader.data.frameId) {
+				if (currentDataPacketHeader.data.frameId) {
-          if (this.dataPacketFrames[currentDataPacketHeader.data.frameId] === undefined) {
+					if (
-            this.dataPacketFrames[currentDataPacketHeader.data.frameId] = [];
+						this.dataPacketFrames[currentDataPacketHeader.data.frameId] ===
-          }
+						undefined
-          this.dataPacketFrames[currentDataPacketHeader.data.frameId].push(dataPacket);
+					) {
-          if (
+						this.dataPacketFrames[currentDataPacketHeader.data.frameId] = [];
-            this.dataPacketFrames[currentDataPacketHeader.data.frameId].length ===
+					}
-            currentDataPacketHeader.data.framePacketCount
+					this.dataPacketFrames[currentDataPacketHeader.data.frameId].push(
-          ) {
+						dataPacket
-            this.updateData(this.dataPacketFrames[currentDataPacketHeader.data.frameId]);
+					);
-            delete this.dataPacketFrames[currentDataPacketHeader.data.frameId];
+					if (
-          }
+						this.dataPacketFrames[currentDataPacketHeader.data.frameId]
-        }
+							.length === currentDataPacketHeader.data.framePacketCount
-      }
+					) {
-    }
+						this.updateData(
-  }
+							this.dataPacketFrames[currentDataPacketHeader.data.frameId]
+						);
+						delete this.dataPacketFrames[currentDataPacketHeader.data.frameId];
+					}
+				}
+			}
+		}
+	}
 }

src/decoders/chunk.ts

@@ -1,29 +1,31 @@
 import type { Chunk } from '../models/chunk.js';
 
 export default (buffer: Uint8Array): Chunk => {
-  if (buffer.length < 4) {
+	if (buffer.length < 4) {
-    throw new Error('Chunk buffer must be at least 4 bytes');
+		throw new Error('Chunk buffer must be at least 4 bytes');
-  }
+	}
 
-  const id = (buffer[1] << 8) + buffer[0];
+	const id = (buffer[1] << 8) + buffer[0];
 
-  // NOTE(jwetzell): this data is split up as 1 bit for hasSubchunks and 15 bits for the dataLen
+	// NOTE(jwetzell): this data is split up as 1 bit for hasSubchunks and 15 bits for the dataLen
-  const combinedLengthAndFlag = (buffer[3] << 8) + buffer[2];
+	const combinedLengthAndFlag = (buffer[3] << 8) + buffer[2];
-  const hasSubchunks = combinedLengthAndFlag > 32768;
+	const hasSubchunks = combinedLengthAndFlag > 32768;
-  const dataLen = hasSubchunks ? combinedLengthAndFlag - 32768 : combinedLengthAndFlag;
+	const dataLen = hasSubchunks
+		? combinedLengthAndFlag - 32768
+		: combinedLengthAndFlag;
 
-  const header = {
+	const header = {
-    id,
+		id,
-    dataLen,
+		dataLen,
-    hasSubchunks,
+		hasSubchunks,
-  };
+	};
 
-  const chunkData = buffer.subarray(4, 4 + header.dataLen);
+	const chunkData = buffer.subarray(4, 4 + header.dataLen);
 
-  const chunk = {
+	const chunk = {
-    chunkData,
+		chunkData,
-    header,
+		header,
-  };
+	};
 
-  return chunk;
+	return chunk;
 };

src/decoders/data/data-packet-chunk.ts

@@ -1,39 +1,48 @@
 import { Constants } from '../../constants.js';
-import type { DataPacketChunk, DataPacketChunkData } from '../../models/data/data-packet-chunk.js';
+import type {
+	DataPacketChunk,
+	DataPacketChunkData,
+} from '../../models/data/data-packet-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): DataPacketChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const data: DataPacketChunkData = {};
+	const data: DataPacketChunkData = {};
 
-  if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
+	if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
-    let offset = 0;
+		let offset = 0;
-    while (offset < chunk.header.dataLen) {
+		while (offset < chunk.header.dataLen) {
-      const chunkId = (chunk.chunkData.subarray(offset)[1] << 8) + chunk.chunkData.subarray(offset)[0];
+			const chunkId =
-      switch (chunkId) {
+				(chunk.chunkData.subarray(offset)[1] << 8) +
-        case 0x0000:
+				chunk.chunkData.subarray(offset)[0];
-          data.packetHeader = Decoders.PacketHeaderChunk(chunk.chunkData.subarray(offset));
+			switch (chunkId) {
-          offset += Constants.CHUNK_HEADER_SIZE;
+				case 0x0000:
-          if (data.packetHeader.chunk.header.dataLen) {
+					data.packetHeader = Decoders.PacketHeaderChunk(
-            offset += data.packetHeader.chunk.header.dataLen;
+						chunk.chunkData.subarray(offset)
-          }
+					);
-          break;
+					offset += Constants.CHUNK_HEADER_SIZE;
-        case 0x0001:
+					if (data.packetHeader.chunk.header.dataLen) {
-          data.trackerList = Decoders.DataTrackerListChunk(chunk.chunkData.subarray(offset));
+						offset += data.packetHeader.chunk.header.dataLen;
-          offset += Constants.CHUNK_HEADER_SIZE;
+					}
-          if (data.trackerList.chunk.header.dataLen) {
+					break;
-            offset += data.trackerList.chunk.header.dataLen;
+				case 0x0001:
-          }
+					data.trackerList = Decoders.DataTrackerListChunk(
-          break;
+						chunk.chunkData.subarray(offset)
-        default:
+					);
-          break;
+					offset += Constants.CHUNK_HEADER_SIZE;
-      }
+					if (data.trackerList.chunk.header.dataLen) {
-    }
+						offset += data.trackerList.chunk.header.dataLen;
-  }
+					}
+					break;
+				default:
+					break;
+			}
+		}
+	}
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/data/data-tracker-chunk.ts

@@ -1,46 +1,65 @@
 import { Constants } from '../../constants.js';
-import type { DataTrackerChunk, DataTrackerChunkData } from '../../models/data/data-tracker-chunk.js';
+import type {
+	DataTrackerChunk,
+	DataTrackerChunkData,
+} from '../../models/data/data-tracker-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): DataTrackerChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
-  const data: DataTrackerChunkData = {};
+	const data: DataTrackerChunkData = {};
-  if (chunk.chunkData && chunk.header.dataLen) {
+	if (chunk.chunkData && chunk.header.dataLen) {
-    let offset = 0;
+		let offset = 0;
-    while (offset < chunk.header.dataLen) {
+		while (offset < chunk.header.dataLen) {
-      const trackerFieldChunk = Decoders.Chunk(chunk.chunkData.subarray(offset));
+			const trackerFieldChunk = Decoders.Chunk(
-      switch (trackerFieldChunk.header.id) {
+				chunk.chunkData.subarray(offset)
-        case 0x0000:
+			);
-          data.pos = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+			switch (trackerFieldChunk.header.id) {
-          break;
+				case 0x0000:
-        case 0x0001:
+					data.pos = Decoders.DataTrackerXYZChunk(
-          data.speed = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+						chunk.chunkData.subarray(offset)
-          break;
+					);
-        case 0x0002:
+					break;
-          data.ori = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+				case 0x0001:
-          break;
+					data.speed = Decoders.DataTrackerXYZChunk(
-        case 0x0003:
+						chunk.chunkData.subarray(offset)
-          data.status = Decoders.DataTrackerStatusChunk(chunk.chunkData.subarray(offset));
+					);
-          break;
+					break;
-        case 0x0004:
+				case 0x0002:
-          data.accel = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+					data.ori = Decoders.DataTrackerXYZChunk(
-          break;
+						chunk.chunkData.subarray(offset)
-        case 0x0005:
+					);
-          data.trgtpos = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+					break;
-          break;
+				case 0x0003:
-        case 0x0006:
+					data.status = Decoders.DataTrackerStatusChunk(
-          data.timestamp = Decoders.DataTrackerTimestampChunk(chunk.chunkData.subarray(offset));
+						chunk.chunkData.subarray(offset)
-          break;
+					);
-        default:
+					break;
-          break;
+				case 0x0004:
-      }
+					data.accel = Decoders.DataTrackerXYZChunk(
-      offset += Constants.CHUNK_HEADER_SIZE;
+						chunk.chunkData.subarray(offset)
-      offset += trackerFieldChunk.header.dataLen;
+					);
-    }
+					break;
-  }
+				case 0x0005:
+					data.trgtpos = Decoders.DataTrackerXYZChunk(
+						chunk.chunkData.subarray(offset)
+					);
+					break;
+				case 0x0006:
+					data.timestamp = Decoders.DataTrackerTimestampChunk(
+						chunk.chunkData.subarray(offset)
+					);
+					break;
+				default:
+					break;
+			}
+			offset += Constants.CHUNK_HEADER_SIZE;
+			offset += trackerFieldChunk.header.dataLen;
+		}
+	}
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/data/data-tracker-list-chunk.ts

@@ -1,33 +1,38 @@
 import { Constants } from '../../constants.js';
-import type { DataTrackerListChunk, DataTrackerListChunkData } from '../../models/data/data-tracker-list-chunk.js';
+import type {
+	DataTrackerListChunk,
+	DataTrackerListChunkData,
+} from '../../models/data/data-tracker-list-chunk.js';
 import type { DataTrackerChunk } from '../../models/index.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): DataTrackerListChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
-  const trackers: DataTrackerChunk[] = [];
+	const trackers: DataTrackerChunk[] = [];
 
-  // TODO(jwetzell): add error handling
+	// TODO(jwetzell): add error handling
-  if (chunk.chunkData) {
+	if (chunk.chunkData) {
-    let offset = 0;
+		let offset = 0;
-    while (offset < chunk.chunkData.length) {
+		while (offset < chunk.chunkData.length) {
-      const trackerChunk = Decoders.DataTrackerChunk(chunk.chunkData.subarray(offset));
+			const trackerChunk = Decoders.DataTrackerChunk(
-      offset += Constants.CHUNK_HEADER_SIZE;
+				chunk.chunkData.subarray(offset)
-      if (trackerChunk.chunk.header.dataLen) {
+			);
-        offset += trackerChunk.chunk.header.dataLen;
+			offset += Constants.CHUNK_HEADER_SIZE;
-      }
+			if (trackerChunk.chunk.header.dataLen) {
-      if (trackerChunk.chunk.header.id !== undefined) {
+				offset += trackerChunk.chunk.header.dataLen;
-        trackers.push(trackerChunk);
+			}
-      }
+			if (trackerChunk.chunk.header.id !== undefined) {
-    }
+				trackers.push(trackerChunk);
-  }
+			}
+		}
+	}
 
-  const data: DataTrackerListChunkData = {
+	const data: DataTrackerListChunkData = {
-    trackers,
+		trackers,
-  };
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/data/data-tracker-status-chunk.ts

@@ -1,21 +1,25 @@
 import type {
-  DataTrackerStatusChunk,
+	DataTrackerStatusChunk,
-  DataTrackerStatusChunkData,
+	DataTrackerStatusChunkData,
 } from '../../models/data/data-tracker-status-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): DataTrackerStatusChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const view = new DataView(chunk.chunkData.buffer, chunk.chunkData.byteOffset, chunk.chunkData.byteLength);
+	const view = new DataView(
-  const validity = view.getFloat32(0, true);
+		chunk.chunkData.buffer,
+		chunk.chunkData.byteOffset,
+		chunk.chunkData.byteLength
+	);
+	const validity = view.getFloat32(0, true);
 
-  const data: DataTrackerStatusChunkData = {
+	const data: DataTrackerStatusChunkData = {
-    validity,
+		validity,
-  };
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/data/data-tracker-timestamp-chunk.ts

@@ -1,21 +1,25 @@
 import type {
-  DataTrackerTimestampChunk,
+	DataTrackerTimestampChunk,
-  DataTrackerTimestampChunkData,
+	DataTrackerTimestampChunkData,
 } from '../../models/data/data-tracker-timestamp-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): DataTrackerTimestampChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const view = new DataView(chunk.chunkData.buffer, chunk.chunkData.byteOffset, chunk.chunkData.byteLength);
+	const view = new DataView(
-  const timestamp = view.getBigUint64(0, true);
+		chunk.chunkData.buffer,
+		chunk.chunkData.byteOffset,
+		chunk.chunkData.byteLength
+	);
+	const timestamp = view.getBigUint64(0, true);
 
-  const data: DataTrackerTimestampChunkData = {
+	const data: DataTrackerTimestampChunkData = {
-    timestamp,
+		timestamp,
-  };
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/data/data-tracker-xyz-chunk.ts

@@ -1,20 +1,27 @@
-import type { DataTrackerXYZChunk, DataTrackerXYZChunkData } from '../../models/data/data-tracker-xyz-chunk.js';
+import type {
+	DataTrackerXYZChunk,
+	DataTrackerXYZChunkData,
+} from '../../models/data/data-tracker-xyz-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): DataTrackerXYZChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  // TODO(jwetzell): add error handling
+	// TODO(jwetzell): add error handling
-  const view = new DataView(chunk.chunkData.buffer, chunk.chunkData.byteOffset, chunk.chunkData.byteLength);
+	const view = new DataView(
+		chunk.chunkData.buffer,
+		chunk.chunkData.byteOffset,
+		chunk.chunkData.byteLength
+	);
 
-  const data: DataTrackerXYZChunkData = {
+	const data: DataTrackerXYZChunkData = {
-    x: view.getFloat32(0, true),
+		x: view.getFloat32(0, true),
-    y: view.getFloat32(4, true),
+		y: view.getFloat32(4, true),
-    z: view.getFloat32(8, true),
+		z: view.getFloat32(8, true),
-  };
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/index.ts

@@ -15,17 +15,17 @@ import InfoTrackerListChunk from './info/info-tracker-list-chunk.js';
 import InfoTrackerNameChunk from './info/info-tracker-name-chunk.js';
 
 export const Decoders = {
-  Chunk,
+	Chunk,
-  PacketHeaderChunk,
+	PacketHeaderChunk,
-  DataPacketChunk,
+	DataPacketChunk,
-  DataTrackerChunk,
+	DataTrackerChunk,
-  DataTrackerXYZChunk,
+	DataTrackerXYZChunk,
-  DataTrackerStatusChunk,
+	DataTrackerStatusChunk,
-  DataTrackerTimestampChunk,
+	DataTrackerTimestampChunk,
-  DataTrackerListChunk,
+	DataTrackerListChunk,
-  InfoPacketChunk,
+	InfoPacketChunk,
-  InfoSystemNameChunk,
+	InfoSystemNameChunk,
-  InfoTrackerChunk,
+	InfoTrackerChunk,
-  InfoTrackerListChunk,
+	InfoTrackerListChunk,
-  InfoTrackerNameChunk,
+	InfoTrackerNameChunk,
 };

src/decoders/info/info-packet-chunk.ts

@@ -1,46 +1,57 @@
 import { Constants } from '../../constants.js';
-import type { InfoPacketChunk, InfoPacketChunkData } from '../../models/info/info-packet-chunk.js';
+import type {
+	InfoPacketChunk,
+	InfoPacketChunkData,
+} from '../../models/info/info-packet-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): InfoPacketChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const data: InfoPacketChunkData = {};
+	const data: InfoPacketChunkData = {};
 
-  if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
+	if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
-    let offset = 0;
+		let offset = 0;
-    while (offset < chunk.header.dataLen) {
+		while (offset < chunk.header.dataLen) {
-      const chunkId = (chunk.chunkData.subarray(offset)[1] << 8) + chunk.chunkData.subarray(offset)[0];
+			const chunkId =
-      switch (chunkId) {
+				(chunk.chunkData.subarray(offset)[1] << 8) +
-        case 0x0000:
+				chunk.chunkData.subarray(offset)[0];
-          data.packetHeader = Decoders.PacketHeaderChunk(chunk.chunkData.subarray(offset));
+			switch (chunkId) {
-          offset += Constants.CHUNK_HEADER_SIZE;
+				case 0x0000:
-          if (data.packetHeader?.chunk.header.dataLen) {
+					data.packetHeader = Decoders.PacketHeaderChunk(
-            offset += data.packetHeader.chunk.header.dataLen;
+						chunk.chunkData.subarray(offset)
-          }
+					);
-          break;
+					offset += Constants.CHUNK_HEADER_SIZE;
-        case 0x0001:
+					if (data.packetHeader?.chunk.header.dataLen) {
-          data.systemName = Decoders.InfoSystemNameChunk(chunk.chunkData.subarray(offset));
+						offset += data.packetHeader.chunk.header.dataLen;
-          offset += Constants.CHUNK_HEADER_SIZE;
+					}
-          if (data.systemName?.chunk.header.dataLen) {
+					break;
-            offset += data.systemName?.chunk.header.dataLen;
+				case 0x0001:
-          }
+					data.systemName = Decoders.InfoSystemNameChunk(
-          break;
+						chunk.chunkData.subarray(offset)
-        case 0x0002:
+					);
-          data.trackerList = Decoders.InfoTrackerListChunk(chunk.chunkData.subarray(offset));
+					offset += Constants.CHUNK_HEADER_SIZE;
-          offset += Constants.CHUNK_HEADER_SIZE;
+					if (data.systemName?.chunk.header.dataLen) {
-          if (data.trackerList?.chunk.header.dataLen) {
+						offset += data.systemName?.chunk.header.dataLen;
-            offset += data.trackerList.chunk.header.dataLen;
+					}
-          }
+					break;
-          break;
+				case 0x0002:
-        default:
+					data.trackerList = Decoders.InfoTrackerListChunk(
-          break;
+						chunk.chunkData.subarray(offset)
-      }
+					);
-    }
+					offset += Constants.CHUNK_HEADER_SIZE;
-  }
+					if (data.trackerList?.chunk.header.dataLen) {
+						offset += data.trackerList.chunk.header.dataLen;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+	}
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/info/info-system-name-chunk.ts

@@ -1,16 +1,21 @@
-import type { InfoSystemNameChunk, InfoSystemNameChunkData } from '../../models/info/info-system-name-chunk.js';
+import type {
+	InfoSystemNameChunk,
+	InfoSystemNameChunkData,
+} from '../../models/info/info-system-name-chunk.js';
 import { Decoders } from '../index.js';
 
 const nameDecoder = new TextDecoder();
 export default (buffer: Uint8Array): InfoSystemNameChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const data: InfoSystemNameChunkData = {
+	const data: InfoSystemNameChunkData = {
-    systemName: nameDecoder.decode(chunk.chunkData.subarray(0, chunk.header.dataLen)),
+		systemName: nameDecoder.decode(
-  };
+			chunk.chunkData.subarray(0, chunk.header.dataLen)
+		),
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/info/info-tracker-chunk.ts

@@ -1,35 +1,42 @@
 import { Constants } from '../../constants.js';
-import type { InfoTrackerChunk, InfoTrackerChunkData } from '../../models/info/info-tracker-chunk.js';
+import type {
+	InfoTrackerChunk,
+	InfoTrackerChunkData,
+} from '../../models/info/info-tracker-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): InfoTrackerChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
+	if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
-    let offset = 0;
+		let offset = 0;
-    while (offset < chunk.header.dataLen) {
+		while (offset < chunk.header.dataLen) {
-      const chunkId = (chunk.chunkData.subarray(offset)[1] << 8) + chunk.chunkData.subarray(offset)[0];
+			const chunkId =
-      switch (chunkId) {
+				(chunk.chunkData.subarray(offset)[1] << 8) +
-        case 0x0000: {
+				chunk.chunkData.subarray(offset)[0];
-          const data: InfoTrackerChunkData = {
+			switch (chunkId) {
-            trackerName: Decoders.InfoTrackerNameChunk(chunk.chunkData.subarray(offset)),
+				case 0x0000: {
-          };
+					const data: InfoTrackerChunkData = {
-          offset += Constants.CHUNK_HEADER_SIZE;
+						trackerName: Decoders.InfoTrackerNameChunk(
-          if (data.trackerName.chunk.header.dataLen) {
+							chunk.chunkData.subarray(offset)
-            offset += data.trackerName.chunk.header.dataLen;
+						),
-          }
+					};
-          return {
+					offset += Constants.CHUNK_HEADER_SIZE;
-            chunk,
+					if (data.trackerName.chunk.header.dataLen) {
-            data,
+						offset += data.trackerName.chunk.header.dataLen;
-          };
+					}
-        }
+					return {
-        default:
+						chunk,
-          break;
+						data,
-      }
+					};
-    }
+				}
-  }
+				default:
+					break;
+			}
+		}
+	}
 
-  return {
+	return {
-    chunk,
+		chunk,
-  };
+	};
 };

src/decoders/info/info-tracker-list-chunk.ts

@@ -1,33 +1,38 @@
 import { Constants } from '../../constants.js';
 import type { InfoTrackerChunk } from '../../models/info/info-tracker-chunk.js';
-import type { InfoTrackerListChunk, InfoTrackerListChunkData } from '../../models/info/info-tracker-list-chunk.js';
+import type {
+	InfoTrackerListChunk,
+	InfoTrackerListChunkData,
+} from '../../models/info/info-tracker-list-chunk.js';
 import { Decoders } from '../index.js';
 
 export default (buffer: Uint8Array): InfoTrackerListChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const trackers: InfoTrackerChunk[] = [];
+	const trackers: InfoTrackerChunk[] = [];
 
-  if (chunk.header.hasSubchunks && chunk.chunkData) {
+	if (chunk.header.hasSubchunks && chunk.chunkData) {
-    let offset = 0;
+		let offset = 0;
-    if (chunk.header.dataLen) {
+		if (chunk.header.dataLen) {
-      while (offset < chunk.header.dataLen) {
+			while (offset < chunk.header.dataLen) {
-        const trackerChunk = Decoders.InfoTrackerChunk(chunk.chunkData.subarray(offset));
+				const trackerChunk = Decoders.InfoTrackerChunk(
-        offset += Constants.CHUNK_HEADER_SIZE;
+					chunk.chunkData.subarray(offset)
-        if (trackerChunk.chunk.header.dataLen) {
+				);
-          offset += trackerChunk.chunk.header.dataLen;
+				offset += Constants.CHUNK_HEADER_SIZE;
-        }
+				if (trackerChunk.chunk.header.dataLen) {
-        if (trackerChunk.chunk.header.id !== undefined) {
+					offset += trackerChunk.chunk.header.dataLen;
-          trackers.push(trackerChunk);
+				}
-        }
+				if (trackerChunk.chunk.header.id !== undefined) {
-      }
+					trackers.push(trackerChunk);
-    }
+				}
-  }
+			}
-  const data: InfoTrackerListChunkData = {
+		}
-    trackers,
+	}
-  };
+	const data: InfoTrackerListChunkData = {
-  return {
+		trackers,
-    chunk,
+	};
-    data,
+	return {
-  };
+		chunk,
+		data,
+	};
 };

src/decoders/info/info-tracker-name-chunk.ts

@@ -1,16 +1,21 @@
-import type { InfoTrackerNameChunk, InfoTrackerNameChunkData } from '../../models/info/info-tracker-name-chunk.js';
+import type {
+	InfoTrackerNameChunk,
+	InfoTrackerNameChunkData,
+} from '../../models/info/info-tracker-name-chunk.js';
 import { Decoders } from '../index.js';
 
 const nameDecoder = new TextDecoder();
 export default (buffer: Uint8Array): InfoTrackerNameChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  const data: InfoTrackerNameChunkData = {
+	const data: InfoTrackerNameChunkData = {
-    trackerName: nameDecoder.decode(chunk.chunkData.subarray(0, chunk.header.dataLen)),
+		trackerName: nameDecoder.decode(
-  };
+			chunk.chunkData.subarray(0, chunk.header.dataLen)
+		),
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/decoders/packet-header-chunk.ts

@@ -1,27 +1,30 @@
-import type { PacketHeaderChunk, PacketHeaderChunkData } from '../models/packet-header-chunk.js';
+import type {
+	PacketHeaderChunk,
+	PacketHeaderChunkData,
+} from '../models/packet-header-chunk.js';
 import { Decoders } from './index.js';
 
 export default (buffer: Uint8Array): PacketHeaderChunk => {
-  const chunk = Decoders.Chunk(buffer);
+	const chunk = Decoders.Chunk(buffer);
 
-  let packetTimestamp = BigInt(chunk.chunkData[7]) << BigInt(56);
+	let packetTimestamp = BigInt(chunk.chunkData[7]) << BigInt(56);
-  packetTimestamp += BigInt(chunk.chunkData[6]) << BigInt(48);
+	packetTimestamp += BigInt(chunk.chunkData[6]) << BigInt(48);
-  packetTimestamp += BigInt(chunk.chunkData[5]) << BigInt(40);
+	packetTimestamp += BigInt(chunk.chunkData[5]) << BigInt(40);
-  packetTimestamp += BigInt(chunk.chunkData[4]) << BigInt(32);
+	packetTimestamp += BigInt(chunk.chunkData[4]) << BigInt(32);
-  packetTimestamp += BigInt(chunk.chunkData[3]) << BigInt(24);
+	packetTimestamp += BigInt(chunk.chunkData[3]) << BigInt(24);
-  packetTimestamp += BigInt(chunk.chunkData[2]) << BigInt(16);
+	packetTimestamp += BigInt(chunk.chunkData[2]) << BigInt(16);
-  packetTimestamp += BigInt(chunk.chunkData[1]) << BigInt(8);
+	packetTimestamp += BigInt(chunk.chunkData[1]) << BigInt(8);
-  packetTimestamp += BigInt(chunk.chunkData[0]);
+	packetTimestamp += BigInt(chunk.chunkData[0]);
-  const data: PacketHeaderChunkData = {
+	const data: PacketHeaderChunkData = {
-    packetTimestamp,
+		packetTimestamp,
-    versionHigh: chunk.chunkData[8],
+		versionHigh: chunk.chunkData[8],
-    versionLow: chunk.chunkData[9],
+		versionLow: chunk.chunkData[9],
-    frameId: chunk.chunkData[10],
+		frameId: chunk.chunkData[10],
-    framePacketCount: chunk.chunkData[11],
+		framePacketCount: chunk.chunkData[11],
-  };
+	};
 
-  return {
+	return {
-    chunk,
+		chunk,
-    data,
+		data,
-  };
+	};
 };

src/encoder.ts

@@ -1,132 +1,157 @@
 import { Constants } from './constants.js';
-import { Encoders, Tracker } from './index.js';
+import { Encoders, type Tracker } from './index.js';
 
 export class Encoder {
-  private systemName: string;
+	private systemName: string;
-  private versionHigh: number;
+	private versionHigh: number;
-  private versionLow: number;
+	private versionLow: number;
-  dataFrameId: number = 1;
+	dataFrameId: number = 1;
-  infoFrameId: number = 1;
+	infoFrameId: number = 1;
-  constructor(systemName: string, versionHigh: number = 2, versionLow: number = 3) {
+	constructor(
-    this.systemName = systemName;
+		systemName: string,
-    this.versionHigh = versionHigh;
+		versionHigh: number = 2,
-    this.versionLow = versionLow;
+		versionLow: number = 3
-  }
+	) {
+		this.systemName = systemName;
+		this.versionHigh = versionHigh;
+		this.versionLow = versionLow;
+	}
 
-  setSystemName(systemName: string) {
+	setSystemName(systemName: string) {
-    this.systemName = systemName;
+		this.systemName = systemName;
-  }
+	}
-  setVersionHigh(versionHigh: number) {
+	setVersionHigh(versionHigh: number) {
-    this.versionHigh = versionHigh;
+		this.versionHigh = versionHigh;
-  }
+	}
 
-  setVersionLow(versionLow: number) {
+	setVersionLow(versionLow: number) {
-    this.versionLow = versionLow;
+		this.versionLow = versionLow;
-  }
+	}
 
-  resetDataFrameId() {
+	resetDataFrameId() {
-    this.dataFrameId = 1;
+		this.dataFrameId = 1;
-  }
+	}
 
-  resetInfoFrameId() {
+	resetInfoFrameId() {
-    this.infoFrameId = 1;
+		this.infoFrameId = 1;
-  }
+	}
 
-  getInfoPackets(timestamp: bigint, trackers: Tracker[], frameId?: number) {
+	getInfoPackets(timestamp: bigint, trackers: Tracker[], frameId?: number) {
-    if (frameId !== undefined) {
+		if (frameId !== undefined) {
-      if (!Number.isInteger(frameId)) {
+			if (!Number.isInteger(frameId)) {
-        throw new Error('frame id must be an integer');
+				throw new Error('frame id must be an integer');
-      }
+			}
 
-      if (frameId > 255 || frameId < 0) {
+			if (frameId > 255 || frameId < 0) {
-        throw new Error('frame id must be >= 0 and <= 255');
+				throw new Error('frame id must be >= 0 and <= 255');
-      }
+			}
-    }
+		}
 
-    const systemNameChunk = Encoders.InfoSystemNameChunk(this.systemName);
+		const systemNameChunk = Encoders.InfoSystemNameChunk(this.systemName);
 
-    const trackerChunks = trackers.map((tracker: Tracker) => tracker.getInfoChunk());
+		const trackerChunks = trackers.map((tracker: Tracker) =>
+			tracker.getInfoChunk()
+		);
 
-    const infoPackets: Uint8Array[] = [];
+		const infoPackets: Uint8Array[] = [];
 
-    const trackerChunksLists: Uint8Array[][] = [];
+		const trackerChunksLists: Uint8Array[][] = [];
-    let currentTrackerList: Uint8Array[] = [];
+		let currentTrackerList: Uint8Array[] = [];
 
-    let currentInfoPacketSize = Constants.PACKET_HEADER_SIZE + systemNameChunk.length + Constants.CHUNK_HEADER_SIZE;
+		let currentInfoPacketSize =
+			Constants.PACKET_HEADER_SIZE +
+			systemNameChunk.length +
+			Constants.CHUNK_HEADER_SIZE;
 
-    trackerChunks.forEach((trackerChunk: Uint8Array) => {
+		trackerChunks.forEach((trackerChunk: Uint8Array) => {
-      if (currentInfoPacketSize + trackerChunk.length > Constants.MAX_UDP_PACKET_SIZE) {
+			if (
-        trackerChunksLists.push(currentTrackerList);
+				currentInfoPacketSize + trackerChunk.length >
-        currentTrackerList = [];
+				Constants.MAX_UDP_PACKET_SIZE
-        currentInfoPacketSize = 0;
+			) {
-      }
+				trackerChunksLists.push(currentTrackerList);
-      currentTrackerList.push(trackerChunk);
+				currentTrackerList = [];
-      currentInfoPacketSize += trackerChunk.length;
+				currentInfoPacketSize = 0;
-    });
+			}
-    trackerChunksLists.push(currentTrackerList);
+			currentTrackerList.push(trackerChunk);
-    const header = Encoders.PacketHeaderChunk(
+			currentInfoPacketSize += trackerChunk.length;
-      timestamp,
+		});
-      this.versionHigh,
+		trackerChunksLists.push(currentTrackerList);
-      this.versionLow,
+		const header = Encoders.PacketHeaderChunk(
-      frameId ? frameId : this.infoFrameId,
+			timestamp,
-      trackerChunksLists.length
+			this.versionHigh,
-    );
+			this.versionLow,
-    trackerChunksLists.forEach((trackerChunkList) => {
+			frameId ? frameId : this.infoFrameId,
-      infoPackets.push(
+			trackerChunksLists.length
-        Encoders.InfoPacketChunk(header, systemNameChunk, Encoders.InfoTrackerListChunk(trackerChunkList))
+		);
-      );
+		trackerChunksLists.forEach((trackerChunkList) => {
-    });
+			infoPackets.push(
-    this.infoFrameId += 1;
+				Encoders.InfoPacketChunk(
-    if (this.infoFrameId > 255) {
+					header,
-      this.infoFrameId = 0;
+					systemNameChunk,
-    }
+					Encoders.InfoTrackerListChunk(trackerChunkList)
-    return infoPackets;
+				)
-  }
+			);
+		});
+		this.infoFrameId += 1;
+		if (this.infoFrameId > 255) {
+			this.infoFrameId = 0;
+		}
+		return infoPackets;
+	}
 
-  getDataPackets(timestamp: bigint, trackers: Tracker[], frameId?: number) {
+	getDataPackets(timestamp: bigint, trackers: Tracker[], frameId?: number) {
-    if (frameId !== undefined) {
+		if (frameId !== undefined) {
-      if (!Number.isInteger(frameId)) {
+			if (!Number.isInteger(frameId)) {
-        throw new Error('frame id must be an integer');
+				throw new Error('frame id must be an integer');
-      }
+			}
 
-      if (frameId > 255 || frameId < 0) {
+			if (frameId > 255 || frameId < 0) {
-        throw new Error('frame id must be >= 0 and <= 255');
+				throw new Error('frame id must be >= 0 and <= 255');
-      }
+			}
-    }
+		}
 
-    const allTrackerChunks = trackers.map((tracker) => tracker.getDataChunk());
+		const allTrackerChunks = trackers.map((tracker) => tracker.getDataChunk());
-    const dataPackets: Uint8Array[] = [];
+		const dataPackets: Uint8Array[] = [];
 
-    const trackerChunksLists: Uint8Array[][] = [];
+		const trackerChunksLists: Uint8Array[][] = [];
-    let currentTrackerList: Uint8Array[] = [];
+		let currentTrackerList: Uint8Array[] = [];
 
-    let currentDataPacketSize = Constants.PACKET_HEADER_SIZE + Constants.CHUNK_HEADER_SIZE;
+		let currentDataPacketSize =
+			Constants.PACKET_HEADER_SIZE + Constants.CHUNK_HEADER_SIZE;
 
-    allTrackerChunks.forEach((trackerChunk) => {
+		allTrackerChunks.forEach((trackerChunk) => {
-      if (currentDataPacketSize + trackerChunk.length > Constants.MAX_UDP_PACKET_SIZE) {
+			if (
-        trackerChunksLists.push(currentTrackerList);
+				currentDataPacketSize + trackerChunk.length >
-        currentTrackerList = [];
+				Constants.MAX_UDP_PACKET_SIZE
-        currentDataPacketSize = 0;
+			) {
-      }
+				trackerChunksLists.push(currentTrackerList);
-      currentTrackerList.push(trackerChunk);
+				currentTrackerList = [];
-      currentDataPacketSize += trackerChunk.length;
+				currentDataPacketSize = 0;
-    });
+			}
-    trackerChunksLists.push(currentTrackerList);
+			currentTrackerList.push(trackerChunk);
+			currentDataPacketSize += trackerChunk.length;
+		});
+		trackerChunksLists.push(currentTrackerList);
 
-    const header = Encoders.PacketHeaderChunk(
+		const header = Encoders.PacketHeaderChunk(
-      timestamp,
+			timestamp,
-      this.versionHigh,
+			this.versionHigh,
-      this.versionLow,
+			this.versionLow,
-      frameId ? frameId : this.dataFrameId,
+			frameId ? frameId : this.dataFrameId,
-      trackerChunksLists.length
+			trackerChunksLists.length
-    );
+		);
-    trackerChunksLists.forEach((trackerChunks) => {
+		trackerChunksLists.forEach((trackerChunks) => {
-      dataPackets.push(Encoders.DataPacketChunk(header, Encoders.DataTrackerListChunk(trackerChunks)));
+			dataPackets.push(
-    });
+				Encoders.DataPacketChunk(
-    this.dataFrameId += 1;
+					header,
-    if (this.dataFrameId > 255) {
+					Encoders.DataTrackerListChunk(trackerChunks)
-      this.dataFrameId = 0;
+				)
-    }
+			);
-    return dataPackets;
+		});
-  }
+		this.dataFrameId += 1;
+		if (this.dataFrameId > 255) {
+			this.dataFrameId = 0;
+		}
+		return dataPackets;
+	}
 }

src/encoders/chunk.ts

@@ -1,25 +1,29 @@
 const header = new DataView(new ArrayBuffer(4));
-export default (id: number, chunkData: Uint8Array, hasSubchunks: boolean): Uint8Array => {
+export default (
-  if (!Number.isInteger(id)) {
+	id: number,
-    throw new Error('chunk id must be an integer');
+	chunkData: Uint8Array,
-  }
+	hasSubchunks: boolean
+): Uint8Array => {
+	if (!Number.isInteger(id)) {
+		throw new Error('chunk id must be an integer');
+	}
 
-  if (id > 0xffff || id < 0) {
+	if (id > 0xffff || id < 0) {
-    throw new Error('chunk id must be >= 0 and <= 65535');
+		throw new Error('chunk id must be >= 0 and <= 65535');
-  }
+	}
 
-  if (chunkData.length > 0x7fff) {
+	if (chunkData.length > 0x7fff) {
-    throw new Error('chunkData can not be greater than 32767 bytes');
+		throw new Error('chunkData can not be greater than 32767 bytes');
-  }
+	}
 
-  header.setUint16(0, id, true);
+	header.setUint16(0, id, true);
-  const hasSubChunksBit = (hasSubchunks ? 1 : 0) << 15;
+	const hasSubChunksBit = (hasSubchunks ? 1 : 0) << 15;
-  header.setUint16(2, hasSubChunksBit + chunkData.length, true);
+	header.setUint16(2, hasSubChunksBit + chunkData.length, true);
 
-  const headerBytes = new Uint8Array(header.buffer);
+	const headerBytes = new Uint8Array(header.buffer);
 
-  const bytes = new Uint8Array(headerBytes.length + chunkData.length);
+	const bytes = new Uint8Array(headerBytes.length + chunkData.length);
-  bytes.set(headerBytes);
+	bytes.set(headerBytes);
-  bytes.set(chunkData, headerBytes.length);
+	bytes.set(chunkData, headerBytes.length);
-  return bytes;
+	return bytes;
 };

src/encoders/data/data-packet-chunk.ts

@@ -1,7 +1,12 @@
 import chunk from '../chunk.js';
-export default (packetHeaderChunk: Uint8Array, trackerListChunk: Uint8Array): Uint8Array => {
+export default (
-  const chunkData = new Uint8Array(packetHeaderChunk.length + trackerListChunk.length);
+	packetHeaderChunk: Uint8Array,
-  chunkData.set(packetHeaderChunk);
+	trackerListChunk: Uint8Array
-  chunkData.set(trackerListChunk, packetHeaderChunk.length);
+): Uint8Array => {
-  return chunk(0x6755, chunkData, true);
+	const chunkData = new Uint8Array(
+		packetHeaderChunk.length + trackerListChunk.length
+	);
+	chunkData.set(packetHeaderChunk);
+	chunkData.set(trackerListChunk, packetHeaderChunk.length);
+	return chunk(0x6755, chunkData, true);
 };

src/encoders/data/data-tracker-accel-chunk.ts

@@ -2,8 +2,8 @@ import chunk from '../chunk.js';
 
 const floatArray = new Float32Array(3);
 export default (x: number, y: number, z: number): Uint8Array => {
-  floatArray[0] = x;
+	floatArray[0] = x;
-  floatArray[1] = y;
+	floatArray[1] = y;
-  floatArray[2] = z;
+	floatArray[2] = z;
-  return chunk(0x0004, new Uint8Array(floatArray.buffer), false);
+	return chunk(0x0004, new Uint8Array(floatArray.buffer), false);
 };

src/encoders/data/data-tracker-chunk.ts

@@ -1,20 +1,20 @@
 import chunk from '../chunk.js';
 
 export default (trackerId: number, fieldChunks: Uint8Array[]): Uint8Array => {
-  let fieldChunksTotalLength = 0;
+	let fieldChunksTotalLength = 0;
 
-  fieldChunks.forEach((fieldChunk) => {
+	fieldChunks.forEach((fieldChunk) => {
-    fieldChunksTotalLength += fieldChunk.length;
+		fieldChunksTotalLength += fieldChunk.length;
-  });
+	});
 
-  const fieldChunksBytes = new Uint8Array(fieldChunksTotalLength);
+	const fieldChunksBytes = new Uint8Array(fieldChunksTotalLength);
 
-  let offset = 0;
+	let offset = 0;
 
-  fieldChunks.forEach((fieldChunk) => {
+	fieldChunks.forEach((fieldChunk) => {
-    fieldChunksBytes.set(fieldChunk, offset);
+		fieldChunksBytes.set(fieldChunk, offset);
-    offset += fieldChunk.length;
+		offset += fieldChunk.length;
-  });
+	});
 
-  return chunk(trackerId, fieldChunksBytes, fieldChunks.length > 0);
+	return chunk(trackerId, fieldChunksBytes, fieldChunks.length > 0);
 };

src/encoders/data/data-tracker-list-chunk.ts

@@ -1,20 +1,20 @@
 import chunk from '../chunk.js';
 
 export default (trackerChunks: Uint8Array[]) => {
-  let trackerChunksTotalLength = 0;
+	let trackerChunksTotalLength = 0;
 
-  trackerChunks.forEach((trackerChunk) => {
+	trackerChunks.forEach((trackerChunk) => {
-    trackerChunksTotalLength += trackerChunk.length;
+		trackerChunksTotalLength += trackerChunk.length;
-  });
+	});
 
-  const trackerChunksBytes = new Uint8Array(trackerChunksTotalLength);
+	const trackerChunksBytes = new Uint8Array(trackerChunksTotalLength);
 
-  let offset = 0;
+	let offset = 0;
 
-  trackerChunks.forEach((trackerChunk) => {
+	trackerChunks.forEach((trackerChunk) => {
-    trackerChunksBytes.set(trackerChunk, offset);
+		trackerChunksBytes.set(trackerChunk, offset);
-    offset += trackerChunk.length;
+		offset += trackerChunk.length;
-  });
+	});
 
-  return chunk(0x0001, trackerChunksBytes, true);
+	return chunk(0x0001, trackerChunksBytes, true);
 };

src/encoders/data/data-tracker-ori-chunk.ts

@@ -2,8 +2,8 @@ import chunk from '../chunk.js';
 
 const floatArray = new Float32Array(3);
 export default (x: number, y: number, z: number): Uint8Array => {
-  floatArray[0] = x;
+	floatArray[0] = x;
-  floatArray[1] = y;
+	floatArray[1] = y;
-  floatArray[2] = z;
+	floatArray[2] = z;
-  return chunk(0x0002, new Uint8Array(floatArray.buffer), false);
+	return chunk(0x0002, new Uint8Array(floatArray.buffer), false);
 };

src/encoders/data/data-tracker-pos-chunk.ts

@@ -2,9 +2,9 @@ import chunk from '../chunk.js';
 
 const floatArray = new Float32Array(3);
 export default (x: number, y: number, z: number): Uint8Array => {
-  floatArray[0] = x;
+	floatArray[0] = x;
-  floatArray[1] = y;
+	floatArray[1] = y;
-  floatArray[2] = z;
+	floatArray[2] = z;
 
-  return chunk(0x0000, new Uint8Array(floatArray.buffer), false);
+	return chunk(0x0000, new Uint8Array(floatArray.buffer), false);
 };

src/encoders/data/data-tracker-speed-chunk.ts

@@ -2,9 +2,9 @@ import chunk from '../chunk.js';
 
 const floatArray = new Float32Array(3);
 export default (x: number, y: number, z: number): Uint8Array => {
-  floatArray[0] = x;
+	floatArray[0] = x;
-  floatArray[1] = y;
+	floatArray[1] = y;
-  floatArray[2] = z;
+	floatArray[2] = z;
 
-  return chunk(0x0001, new Uint8Array(floatArray.buffer), false);
+	return chunk(0x0001, new Uint8Array(floatArray.buffer), false);
 };

src/encoders/data/data-tracker-status-chunk.ts

@@ -2,6 +2,6 @@ import chunk from '../chunk.js';
 
 const floatArray = new Float32Array(1);
 export default (validity: number): Uint8Array => {
-  floatArray[0] = validity;
+	floatArray[0] = validity;
-  return chunk(0x0003, new Uint8Array(floatArray.buffer), false);
+	return chunk(0x0003, new Uint8Array(floatArray.buffer), false);
 };

src/encoders/data/data-tracker-timestamp-chunk.ts

@@ -2,6 +2,6 @@ import chunk from '../chunk.js';
 
 const buf = new DataView(new ArrayBuffer(8));
 export default (timestamp: bigint): Uint8Array => {
-  buf.setBigUint64(0, BigInt(timestamp), true);
+	buf.setBigUint64(0, BigInt(timestamp), true);
-  return chunk(0x0006, new Uint8Array(buf.buffer), false);
+	return chunk(0x0006, new Uint8Array(buf.buffer), false);
 };

src/encoders/data/data-tracker-trgtpos-chunk.ts

@@ -2,9 +2,9 @@ import chunk from '../chunk.js';
 
 const floatArray = new Float32Array(3);
 export default (x: number, y: number, z: number): Uint8Array => {
-  floatArray[0] = x;
+	floatArray[0] = x;
-  floatArray[1] = y;
+	floatArray[1] = y;
-  floatArray[2] = z;
+	floatArray[2] = z;
 
-  return chunk(0x0005, new Uint8Array(floatArray.buffer), false);
+	return chunk(0x0005, new Uint8Array(floatArray.buffer), false);
 };

src/encoders/index.ts

@@ -18,21 +18,21 @@ import InfoTrackerListChunk from './info/info-tracker-list-chunk.js';
 import InfoTrackerNameChunk from './info/info-tracker-name-chunk.js';
 
 export const Encoders = {
-  DataPacketChunk,
+	DataPacketChunk,
-  DataTrackerAccelChunk,
+	DataTrackerAccelChunk,
-  DataTrackerChunk,
+	DataTrackerChunk,
-  DataTrackerListChunk,
+	DataTrackerListChunk,
-  DataTrackerOriChunk,
+	DataTrackerOriChunk,
-  DataTrackerPosChunk,
+	DataTrackerPosChunk,
-  DataTrackerSpeedChunk,
+	DataTrackerSpeedChunk,
-  DataTrackerStatusChunk,
+	DataTrackerStatusChunk,
-  DataTrackerTimestampChunk,
+	DataTrackerTimestampChunk,
-  DataTrackerTrgtposChunk,
+	DataTrackerTrgtposChunk,
-  InfoPacketChunk,
+	InfoPacketChunk,
-  InfoSystemNameChunk,
+	InfoSystemNameChunk,
-  InfoTrackerChunk,
+	InfoTrackerChunk,
-  InfoTrackerListChunk,
+	InfoTrackerListChunk,
-  InfoTrackerNameChunk,
+	InfoTrackerNameChunk,
-  PacketHeaderChunk,
+	PacketHeaderChunk,
-  Chunk,
+	Chunk,
 };

src/encoders/info/info-packet-chunk.ts

@@ -1,14 +1,19 @@
 import chunk from '../chunk.js';
 
 export default (
-  packetHeaderChunk: Uint8Array,
+	packetHeaderChunk: Uint8Array,
-  systemNameChunk: Uint8Array,
+	systemNameChunk: Uint8Array,
-  trackerListChunk: Uint8Array
+	trackerListChunk: Uint8Array
 ): Uint8Array => {
-  const chunkData = new Uint8Array(packetHeaderChunk.length + systemNameChunk.length + trackerListChunk.length);
+	const chunkData = new Uint8Array(
+		packetHeaderChunk.length + systemNameChunk.length + trackerListChunk.length
+	);
 
-  chunkData.set(packetHeaderChunk);
+	chunkData.set(packetHeaderChunk);
-  chunkData.set(systemNameChunk, packetHeaderChunk.length);
+	chunkData.set(systemNameChunk, packetHeaderChunk.length);
-  chunkData.set(trackerListChunk, packetHeaderChunk.length + systemNameChunk.length);
+	chunkData.set(
-  return chunk(0x6756, chunkData, true);
+		trackerListChunk,
+		packetHeaderChunk.length + systemNameChunk.length
+	);
+	return chunk(0x6756, chunkData, true);
 };

src/encoders/info/info-system-name-chunk.ts

@@ -1,3 +1,4 @@
 import chunk from '../chunk.js';
 const nameEncoder = new TextEncoder();
-export default (systemName: string): Uint8Array => chunk(0x0001, nameEncoder.encode(systemName), false);
+export default (systemName: string): Uint8Array =>
+	chunk(0x0001, nameEncoder.encode(systemName), false);

src/encoders/info/info-tracker-chunk.ts

@@ -1,4 +1,4 @@
 import chunk from '../chunk.js';
 
 export default (trackerId: number, trackerNameChunk: Uint8Array): Uint8Array =>
-  chunk(trackerId, trackerNameChunk, true);
+	chunk(trackerId, trackerNameChunk, true);

src/encoders/info/info-tracker-list-chunk.ts

@@ -1,19 +1,19 @@
 import chunk from '../chunk.js';
 
 export default (trackerChunks: Uint8Array[]): Uint8Array => {
-  let trackerChunksTotalLength = 0;
+	let trackerChunksTotalLength = 0;
 
-  trackerChunks.forEach((trackerChunk) => {
+	trackerChunks.forEach((trackerChunk) => {
-    trackerChunksTotalLength += trackerChunk.length;
+		trackerChunksTotalLength += trackerChunk.length;
-  });
+	});
 
-  const trackerChunksBytes = new Uint8Array(trackerChunksTotalLength);
+	const trackerChunksBytes = new Uint8Array(trackerChunksTotalLength);
 
-  let offset = 0;
+	let offset = 0;
 
-  trackerChunks.forEach((trackerChunk) => {
+	trackerChunks.forEach((trackerChunk) => {
-    trackerChunksBytes.set(trackerChunk, offset);
+		trackerChunksBytes.set(trackerChunk, offset);
-    offset += trackerChunk.length;
+		offset += trackerChunk.length;
-  });
+	});
-  return chunk(0x0002, trackerChunksBytes, true);
+	return chunk(0x0002, trackerChunksBytes, true);
 };

src/encoders/info/info-tracker-name-chunk.ts

@@ -1,4 +1,5 @@
 import chunk from '../chunk.js';
 
 const nameEncoder = new TextEncoder();
-export default (trackerName: string) => chunk(0x0000, nameEncoder.encode(trackerName), false);
+export default (trackerName: string) =>
+	chunk(0x0000, nameEncoder.encode(trackerName), false);

src/encoders/packet-header-chunk.ts

@@ -2,43 +2,43 @@ import chunk from './chunk.js';
 
 const packetHeader = new DataView(new ArrayBuffer(12));
 export default (
-  timestamp: bigint,
+	timestamp: bigint,
-  versionHigh: number,
+	versionHigh: number,
-  versionLow: number,
+	versionLow: number,
-  frameId: number,
+	frameId: number,
-  framePacketCount: number
+	framePacketCount: number
 ): Uint8Array => {
-  if (!Number.isInteger(versionHigh)) {
+	if (!Number.isInteger(versionHigh)) {
-    throw new Error('version high must be an integer');
+		throw new Error('version high must be an integer');
-  }
+	}
-  if (!Number.isInteger(versionLow)) {
+	if (!Number.isInteger(versionLow)) {
-    throw new Error('version low must be an integer');
+		throw new Error('version low must be an integer');
-  }
+	}
-  if (!Number.isInteger(frameId)) {
+	if (!Number.isInteger(frameId)) {
-    throw new Error('frame id must be an integer');
+		throw new Error('frame id must be an integer');
-  }
+	}
-  if (!Number.isInteger(framePacketCount)) {
+	if (!Number.isInteger(framePacketCount)) {
-    throw new Error('frame packet count must be an integer');
+		throw new Error('frame packet count must be an integer');
-  }
+	}
 
-  if (versionHigh > 255 || versionHigh < 0) {
+	if (versionHigh > 255 || versionHigh < 0) {
-    throw new Error('version high must be >= 0 and <= 255');
+		throw new Error('version high must be >= 0 and <= 255');
-  }
+	}
-  if (versionLow > 255 || versionLow < 0) {
+	if (versionLow > 255 || versionLow < 0) {
-    throw new Error('version low must be >= 0 and <= 255');
+		throw new Error('version low must be >= 0 and <= 255');
-  }
+	}
-  if (frameId > 255 || frameId < 0) {
+	if (frameId > 255 || frameId < 0) {
-    throw new Error('frame id must be >= 0 and <= 255');
+		throw new Error('frame id must be >= 0 and <= 255');
-  }
+	}
-  if (framePacketCount > 255 || framePacketCount < 0) {
+	if (framePacketCount > 255 || framePacketCount < 0) {
-    throw new Error('frame packet count must be >= 0 and <= 255');
+		throw new Error('frame packet count must be >= 0 and <= 255');
-  }
+	}
 
-  packetHeader.setBigUint64(0, BigInt(timestamp), true);
+	packetHeader.setBigUint64(0, BigInt(timestamp), true);
-  packetHeader.setUint8(8, versionHigh);
+	packetHeader.setUint8(8, versionHigh);
-  packetHeader.setUint8(9, versionLow);
+	packetHeader.setUint8(9, versionLow);
-  packetHeader.setUint8(10, frameId);
+	packetHeader.setUint8(10, frameId);
-  packetHeader.setUint8(11, framePacketCount);
+	packetHeader.setUint8(11, framePacketCount);
 
-  return chunk(0x0000, new Uint8Array(packetHeader.buffer), false);
+	return chunk(0x0000, new Uint8Array(packetHeader.buffer), false);
 };

src/models/chunk.ts

@@ -1,10 +1,10 @@
 export interface ChunkHeader {
-  id: number;
+	id: number;
-  dataLen: number;
+	dataLen: number;
-  hasSubchunks: boolean;
+	hasSubchunks: boolean;
 }
 
 export interface Chunk {
-  chunkData: Uint8Array;
+	chunkData: Uint8Array;
-  header: ChunkHeader;
+	header: ChunkHeader;
 }

src/models/data/data-packet-chunk.ts

@@ -3,11 +3,11 @@ import type { PacketHeaderChunk } from '../packet-header-chunk.js';
 import type { DataTrackerListChunk } from './data-tracker-list-chunk.js';
 
 export interface DataPacketChunkData {
-  packetHeader?: PacketHeaderChunk;
+	packetHeader?: PacketHeaderChunk;
-  trackerList?: DataTrackerListChunk;
+	trackerList?: DataTrackerListChunk;
 }
 
 export interface DataPacketChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: DataPacketChunkData;
+	data: DataPacketChunkData;
 }

src/models/data/data-tracker-chunk.ts

@@ -4,16 +4,16 @@ import type { DataTrackerTimestampChunk } from './data-tracker-timestamp-chunk.j
 import type { DataTrackerXYZChunk } from './data-tracker-xyz-chunk.js';
 
 export interface DataTrackerChunkData {
-  pos?: DataTrackerXYZChunk;
+	pos?: DataTrackerXYZChunk;
-  speed?: DataTrackerXYZChunk;
+	speed?: DataTrackerXYZChunk;
-  ori?: DataTrackerXYZChunk;
+	ori?: DataTrackerXYZChunk;
-  status?: DataTrackerStatusChunk;
+	status?: DataTrackerStatusChunk;
-  accel?: DataTrackerXYZChunk;
+	accel?: DataTrackerXYZChunk;
-  trgtpos?: DataTrackerXYZChunk;
+	trgtpos?: DataTrackerXYZChunk;
-  timestamp?: DataTrackerTimestampChunk;
+	timestamp?: DataTrackerTimestampChunk;
 }
 
 export interface DataTrackerChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: DataTrackerChunkData;
+	data: DataTrackerChunkData;
 }

src/models/data/data-tracker-list-chunk.ts

@@ -2,10 +2,10 @@ import type { Chunk } from '../chunk.js';
 import type { DataTrackerChunk } from './data-tracker-chunk.js';
 
 export interface DataTrackerListChunkData {
-  trackers: DataTrackerChunk[];
+	trackers: DataTrackerChunk[];
 }
 
 export interface DataTrackerListChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: DataTrackerListChunkData;
+	data: DataTrackerListChunkData;
 }

src/models/data/data-tracker-status-chunk.ts

@@ -1,10 +1,10 @@
 import type { Chunk } from '../chunk.js';
 
 export interface DataTrackerStatusChunkData {
-  validity: number;
+	validity: number;
 }
 
 export interface DataTrackerStatusChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: DataTrackerStatusChunkData;
+	data: DataTrackerStatusChunkData;
 }

src/models/data/data-tracker-timestamp-chunk.ts

@@ -1,10 +1,10 @@
 import type { Chunk } from '../chunk.js';
 
 export interface DataTrackerTimestampChunkData {
-  timestamp: bigint;
+	timestamp: bigint;
 }
 
 export interface DataTrackerTimestampChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: DataTrackerTimestampChunkData;
+	data: DataTrackerTimestampChunkData;
 }

src/models/data/data-tracker-xyz-chunk.ts

@@ -1,12 +1,12 @@
 import type { Chunk } from '../chunk.js';
 
 export interface DataTrackerXYZChunkData {
-  x: number;
+	x: number;
-  y: number;
+	y: number;
-  z: number;
+	z: number;
 }
 
 export interface DataTrackerXYZChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: DataTrackerXYZChunkData;
+	data: DataTrackerXYZChunkData;
 }

src/models/info/info-packet-chunk.ts

@@ -4,11 +4,11 @@ import type { InfoSystemNameChunk } from './info-system-name-chunk.js';
 import type { InfoTrackerListChunk } from './info-tracker-list-chunk.js';
 
 export interface InfoPacketChunkData {
-  packetHeader?: PacketHeaderChunk;
+	packetHeader?: PacketHeaderChunk;
-  systemName?: InfoSystemNameChunk;
+	systemName?: InfoSystemNameChunk;
-  trackerList?: InfoTrackerListChunk;
+	trackerList?: InfoTrackerListChunk;
 }
 export interface InfoPacketChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: InfoPacketChunkData;
+	data: InfoPacketChunkData;
 }

src/models/info/info-system-name-chunk.ts

@@ -1,10 +1,10 @@
 import type { Chunk } from '../chunk.js';
 
 export interface InfoSystemNameChunkData {
-  systemName: string;
+	systemName: string;
 }
 
 export interface InfoSystemNameChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: InfoSystemNameChunkData;
+	data: InfoSystemNameChunkData;
 }

src/models/info/info-tracker-chunk.ts

@@ -2,10 +2,10 @@ import type { Chunk } from '../chunk.js';
 import type { InfoTrackerNameChunk } from './info-tracker-name-chunk.js';
 
 export interface InfoTrackerChunkData {
-  trackerName: InfoTrackerNameChunk;
+	trackerName: InfoTrackerNameChunk;
 }
 
 export interface InfoTrackerChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data?: InfoTrackerChunkData;
+	data?: InfoTrackerChunkData;
 }

src/models/info/info-tracker-list-chunk.ts

@@ -2,10 +2,10 @@ import type { Chunk } from '../chunk.js';
 import type { InfoTrackerChunk } from './info-tracker-chunk.js';
 
 export interface InfoTrackerListChunkData {
-  trackers: InfoTrackerChunk[];
+	trackers: InfoTrackerChunk[];
 }
 
 export interface InfoTrackerListChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: InfoTrackerListChunkData;
+	data: InfoTrackerListChunkData;
 }

src/models/info/info-tracker-name-chunk.ts

@@ -1,10 +1,10 @@
 import type { Chunk } from '../chunk.js';
 
 export interface InfoTrackerNameChunkData {
-  trackerName: string;
+	trackerName: string;
 }
 
 export interface InfoTrackerNameChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: InfoTrackerNameChunkData;
+	data: InfoTrackerNameChunkData;
 }

src/models/packet-header-chunk.ts

@@ -1,14 +1,14 @@
 import type { Chunk } from './chunk.js';
 
 export interface PacketHeaderChunkData {
-  packetTimestamp: bigint;
+	packetTimestamp: bigint;
-  versionHigh: number;
+	versionHigh: number;
-  versionLow: number;
+	versionLow: number;
-  frameId: number;
+	frameId: number;
-  framePacketCount: number;
+	framePacketCount: number;
 }
 
 export interface PacketHeaderChunk {
-  chunk: Chunk;
+	chunk: Chunk;
-  data: PacketHeaderChunkData;
+	data: PacketHeaderChunkData;
 }

src/models/tracker.ts

@@ -12,211 +12,228 @@ import type { DataTrackerChunk } from './data/data-tracker-chunk.js';
 import type { InfoTrackerChunk } from './info/info-tracker-chunk.js';
 
 export type XYZData = {
-  x: number;
+	x: number;
-  y: number;
+	y: number;
-  z: number;
+	z: number;
 };
 
 export class Tracker {
-  id: number;
+	id: number;
-  name: string;
+	name: string;
-  pos?: XYZData;
+	pos?: XYZData;
-  speed?: XYZData;
+	speed?: XYZData;
-  ori?: XYZData;
+	ori?: XYZData;
-  validity?: number;
+	validity?: number;
-  accel?: XYZData;
+	accel?: XYZData;
-  trgtpos?: XYZData;
+	trgtpos?: XYZData;
-  timestamp?: bigint;
+	timestamp?: bigint;
 
-  constructor(id: number, name: string) {
+	constructor(id: number, name: string) {
-    this.id = id;
+		this.id = id;
-    this.name = name;
+		this.name = name;
-    this.pos = undefined;
+		this.pos = undefined;
-    this.speed = undefined;
+		this.speed = undefined;
-    this.ori = undefined;
+		this.ori = undefined;
-    this.validity = undefined;
+		this.validity = undefined;
-    this.accel = undefined;
+		this.accel = undefined;
-    this.trgtpos = undefined;
+		this.trgtpos = undefined;
-    this.timestamp = undefined;
+		this.timestamp = undefined;
-  }
+	}
 
-  setPos(x: number, y: number, z: number) {
+	setPos(x: number, y: number, z: number) {
-    if (this.pos === undefined) {
+		if (this.pos === undefined) {
-      this.pos = {
+			this.pos = {
-        x,
+				x,
-        y,
+				y,
-        z,
+				z,
-      };
+			};
-    } else {
+		} else {
-      this.pos.x = x;
+			this.pos.x = x;
-      this.pos.y = y;
+			this.pos.y = y;
-      this.pos.z = z;
+			this.pos.z = z;
-    }
+		}
-  }
+	}
 
-  setSpeed(x: number, y: number, z: number) {
+	setSpeed(x: number, y: number, z: number) {
-    if (this.speed === undefined) {
+		if (this.speed === undefined) {
-      this.speed = {
+			this.speed = {
-        x,
+				x,
-        y,
+				y,
-        z,
+				z,
-      };
+			};
-    } else {
+		} else {
-      this.speed.x = x;
+			this.speed.x = x;
-      this.speed.y = y;
+			this.speed.y = y;
-      this.speed.z = z;
+			this.speed.z = z;
-    }
+		}
-  }
+	}
 
-  setOri(x: number, y: number, z: number) {
+	setOri(x: number, y: number, z: number) {
-    if (this.ori === undefined) {
+		if (this.ori === undefined) {
-      this.ori = {
+			this.ori = {
-        x,
+				x,
-        y,
+				y,
-        z,
+				z,
-      };
+			};
-    } else {
+		} else {
-      this.ori.x = x;
+			this.ori.x = x;
-      this.ori.y = y;
+			this.ori.y = y;
-      this.ori.z = z;
+			this.ori.z = z;
-    }
+		}
-  }
+	}
 
-  setStatus(validity: number) {
+	setStatus(validity: number) {
-    this.validity = validity;
+		this.validity = validity;
-  }
+	}
 
-  setAccel(x: number, y: number, z: number) {
+	setAccel(x: number, y: number, z: number) {
-    if (this.accel === undefined) {
+		if (this.accel === undefined) {
-      this.accel = {
+			this.accel = {
-        x,
+				x,
-        y,
+				y,
-        z,
+				z,
-      };
+			};
-    } else {
+		} else {
-      this.accel.x = x;
+			this.accel.x = x;
-      this.accel.y = y;
+			this.accel.y = y;
-      this.accel.z = z;
+			this.accel.z = z;
-    }
+		}
-  }
+	}
 
-  setTrgtPos(x: number, y: number, z: number) {
+	setTrgtPos(x: number, y: number, z: number) {
-    if (this.trgtpos === undefined) {
+		if (this.trgtpos === undefined) {
-      this.trgtpos = {
+			this.trgtpos = {
-        x,
+				x,
-        y,
+				y,
-        z,
+				z,
-      };
+			};
-    } else {
+		} else {
-      this.trgtpos.x = x;
+			this.trgtpos.x = x;
-      this.trgtpos.y = y;
+			this.trgtpos.y = y;
-      this.trgtpos.z = z;
+			this.trgtpos.z = z;
-    }
+		}
-  }
+	}
 
-  setTimestamp(timestamp: bigint) {
+	setTimestamp(timestamp: bigint) {
-    this.timestamp = timestamp;
+		this.timestamp = timestamp;
-  }
+	}
 
-  getDataChunk() {
+	getDataChunk() {
-    const fieldChunks: Uint8Array[] = [];
+		const fieldChunks: Uint8Array[] = [];
 
-    if (this.pos) {
+		if (this.pos) {
-      fieldChunks.push(dataTrackerPosChunk(this.pos.x, this.pos.y, this.pos.z));
+			fieldChunks.push(dataTrackerPosChunk(this.pos.x, this.pos.y, this.pos.z));
-    }
+		}
 
-    if (this.speed) {
+		if (this.speed) {
-      fieldChunks.push(dataTrackerSpeedChunk(this.speed.x, this.speed.y, this.speed.z));
+			fieldChunks.push(
-    }
+				dataTrackerSpeedChunk(this.speed.x, this.speed.y, this.speed.z)
+			);
+		}
 
-    if (this.ori) {
+		if (this.ori) {
-      fieldChunks.push(dataTrackerOriChunk(this.ori.x, this.ori.y, this.ori.z));
+			fieldChunks.push(dataTrackerOriChunk(this.ori.x, this.ori.y, this.ori.z));
-    }
+		}
 
-    if (this.validity) {
+		if (this.validity) {
-      fieldChunks.push(dataTrackerStatusChunk(this.validity));
+			fieldChunks.push(dataTrackerStatusChunk(this.validity));
-    }
+		}
 
-    if (this.accel) {
+		if (this.accel) {
-      fieldChunks.push(dataTrackerAccelChunk(this.accel.x, this.accel.y, this.accel.z));
+			fieldChunks.push(
-    }
+				dataTrackerAccelChunk(this.accel.x, this.accel.y, this.accel.z)
+			);
+		}
 
-    if (this.trgtpos) {
+		if (this.trgtpos) {
-      fieldChunks.push(dataTrackerTrgtposChunk(this.trgtpos.x, this.trgtpos.y, this.trgtpos.z));
+			fieldChunks.push(
-    }
+				dataTrackerTrgtposChunk(this.trgtpos.x, this.trgtpos.y, this.trgtpos.z)
+			);
+		}
 
-    if (this.timestamp) {
+		if (this.timestamp) {
-      fieldChunks.push(dataTrackerTimestampChunk(this.timestamp));
+			fieldChunks.push(dataTrackerTimestampChunk(this.timestamp));
-    }
+		}
 
-    return dataTrackerChunk(this.id, fieldChunks);
+		return dataTrackerChunk(this.id, fieldChunks);
-  }
+	}
 
-  getInfoChunk() {
+	getInfoChunk() {
-    return infoTrackerChunk(this.id, infoTrackerNameChunk(this.name));
+		return infoTrackerChunk(this.id, infoTrackerNameChunk(this.name));
-  }
+	}
 
-  updateInfo(infoTrackerChunk: InfoTrackerChunk) {
+	updateInfo(infoTrackerChunk: InfoTrackerChunk) {
-    if (infoTrackerChunk.data) {
+		if (infoTrackerChunk.data) {
-      this.name = infoTrackerChunk.data.trackerName.data.trackerName;
+			this.name = infoTrackerChunk.data.trackerName.data.trackerName;
-    }
+		}
-  }
+	}
 
-  updateData(dataTrackerChunk: DataTrackerChunk) {
+	updateData(dataTrackerChunk: DataTrackerChunk) {
-    if (dataTrackerChunk.data.pos) {
+		if (dataTrackerChunk.data.pos) {
-      this.setPos(dataTrackerChunk.data.pos.data.x, dataTrackerChunk.data.pos.data.y, dataTrackerChunk.data.pos.data.z);
+			this.setPos(
-    }
+				dataTrackerChunk.data.pos.data.x,
+				dataTrackerChunk.data.pos.data.y,
+				dataTrackerChunk.data.pos.data.z
+			);
+		}
 
-    if (dataTrackerChunk.data.speed) {
+		if (dataTrackerChunk.data.speed) {
-      this.setSpeed(
+			this.setSpeed(
-        dataTrackerChunk.data.speed.data.x,
+				dataTrackerChunk.data.speed.data.x,
-        dataTrackerChunk.data.speed.data.y,
+				dataTrackerChunk.data.speed.data.y,
-        dataTrackerChunk.data.speed.data.z
+				dataTrackerChunk.data.speed.data.z
-      );
+			);
-    }
+		}
 
-    if (dataTrackerChunk.data.ori) {
+		if (dataTrackerChunk.data.ori) {
-      this.setOri(dataTrackerChunk.data.ori.data.x, dataTrackerChunk.data.ori.data.y, dataTrackerChunk.data.ori.data.z);
+			this.setOri(
-    }
+				dataTrackerChunk.data.ori.data.x,
+				dataTrackerChunk.data.ori.data.y,
+				dataTrackerChunk.data.ori.data.z
+			);
+		}
 
-    if (dataTrackerChunk.data.status) {
+		if (dataTrackerChunk.data.status) {
-      this.setStatus(dataTrackerChunk.data.status.data.validity);
+			this.setStatus(dataTrackerChunk.data.status.data.validity);
-    }
+		}
 
-    if (dataTrackerChunk.data.accel) {
+		if (dataTrackerChunk.data.accel) {
-      this.setAccel(
+			this.setAccel(
-        dataTrackerChunk.data.accel.data.x,
+				dataTrackerChunk.data.accel.data.x,
-        dataTrackerChunk.data.accel.data.y,
+				dataTrackerChunk.data.accel.data.y,
-        dataTrackerChunk.data.accel.data.z
+				dataTrackerChunk.data.accel.data.z
-      );
+			);
-    }
+		}
 
-    if (dataTrackerChunk.data.trgtpos) {
+		if (dataTrackerChunk.data.trgtpos) {
-      this.setTrgtPos(
+			this.setTrgtPos(
-        dataTrackerChunk.data.trgtpos.data.x,
+				dataTrackerChunk.data.trgtpos.data.x,
-        dataTrackerChunk.data.trgtpos.data.y,
+				dataTrackerChunk.data.trgtpos.data.y,
-        dataTrackerChunk.data.trgtpos.data.z
+				dataTrackerChunk.data.trgtpos.data.z
-      );
+			);
-    }
+		}
 
-    if (dataTrackerChunk.data.timestamp) {
+		if (dataTrackerChunk.data.timestamp) {
-      this.setTimestamp(dataTrackerChunk.data.timestamp.data.timestamp);
+			this.setTimestamp(dataTrackerChunk.data.timestamp.data.timestamp);
-    }
+		}
-  }
+	}
 }
 
 export function TrackerFromInfo(infoTrackerChunk: InfoTrackerChunk) {
-  if (infoTrackerChunk.data) {
+	if (infoTrackerChunk.data) {
-    return new Tracker(infoTrackerChunk.chunk.header.id, infoTrackerChunk.data.trackerName.data.trackerName);
+		return new Tracker(
-  }
+			infoTrackerChunk.chunk.header.id,
-  return undefined;
+			infoTrackerChunk.data.trackerName.data.trackerName
+		);
+	}
+	return undefined;
 }
 
 export function TrackerFromData(dataTrackerChunk: DataTrackerChunk) {
-  if (dataTrackerChunk.data) {
+	if (dataTrackerChunk.data) {
-    const tracker = new Tracker(dataTrackerChunk.chunk.header.id, '');
+		const tracker = new Tracker(dataTrackerChunk.chunk.header.id, '');
-    tracker.updateData(dataTrackerChunk);
+		tracker.updateData(dataTrackerChunk);
-    return tracker;
+		return tracker;
-  }
+	}
-  return undefined;
+	return undefined;
 }

tests/encode.test.mjs

@@ -1,152 +1,193 @@
-import { Encoders } from '@jwetzell/posistagenet';
+import { deepEqual, throws } from 'node:assert';
-import { deepEqual, throws } from 'assert';
 import { describe, it } from 'node:test';
+import { Encoders } from '@jwetzell/posistagenet';
 
 const goodTests = [
-  {
+	{
-    description: 'DataTrackerPosChunk',
+		description: 'DataTrackerPosChunk',
-    expected: new Uint8Array([0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+		expected: new Uint8Array([
-    bytes: Encoders.DataTrackerPosChunk(1.0, 2.0, 3.0),
+			0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
-  },
+		]),
-  {
+		bytes: Encoders.DataTrackerPosChunk(1.0, 2.0, 3.0),
-    description: 'DataTrackerSpeedChunk',
+	},
-    expected: new Uint8Array([1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+	{
-    bytes: Encoders.DataTrackerSpeedChunk(1.0, 2.0, 3.0),
+		description: 'DataTrackerSpeedChunk',
-  },
+		expected: new Uint8Array([
-  {
+			1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
-    description: 'DataTrackerOriChunk',
+		]),
-    expected: new Uint8Array([2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+		bytes: Encoders.DataTrackerSpeedChunk(1.0, 2.0, 3.0),
-    bytes: Encoders.DataTrackerOriChunk(1.0, 2.0, 3.0),
+	},
-  },
+	{
-  {
+		description: 'DataTrackerOriChunk',
-    description: 'DataTrackerStatusChunk',
+		expected: new Uint8Array([
-    expected: new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
+			2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
-    bytes: Encoders.DataTrackerStatusChunk(1.0),
+		]),
-  },
+		bytes: Encoders.DataTrackerOriChunk(1.0, 2.0, 3.0),
-  {
+	},
-    description: 'DataTrackerAccelChunk',
+	{
-    expected: new Uint8Array([4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+		description: 'DataTrackerStatusChunk',
-    bytes: Encoders.DataTrackerAccelChunk(1.0, 2.0, 3.0),
+		expected: new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
-  },
+		bytes: Encoders.DataTrackerStatusChunk(1.0),
-  {
+	},
-    description: 'DataTrackerTrgtposChunk',
+	{
-    expected: new Uint8Array([5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+		description: 'DataTrackerAccelChunk',
-    bytes: Encoders.DataTrackerTrgtposChunk(1.0, 2.0, 3.0),
+		expected: new Uint8Array([
-  },
+			4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
-  {
+		]),
-    description: 'DataTrackerTimestampChunk',
+		bytes: Encoders.DataTrackerAccelChunk(1.0, 2.0, 3.0),
-    expected: new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
+	},
-    bytes: Encoders.DataTrackerTimestampChunk(1234567890n),
+	{
-  },
+		description: 'DataTrackerTrgtposChunk',
-  {
+		expected: new Uint8Array([
-    description: 'DataTrackerChunk',
+			5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
-    expected: new Uint8Array([
+		]),
-      1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
+		bytes: Encoders.DataTrackerTrgtposChunk(1.0, 2.0, 3.0),
-      0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0,
+	},
-      128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2,
+	{
-      150, 73, 0, 0, 0, 0,
+		description: 'DataTrackerTimestampChunk',
-    ]),
+		expected: new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
-    bytes: Encoders.DataTrackerChunk(1, [
+		bytes: Encoders.DataTrackerTimestampChunk(1234567890n),
-      new Uint8Array([0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+	},
-      new Uint8Array([1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+	{
-      new Uint8Array([2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+		description: 'DataTrackerChunk',
-      new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
+		expected: new Uint8Array([
-      new Uint8Array([4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+			1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1,
-      new Uint8Array([5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+			0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0,
-      new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
+			128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12,
-    ]),
+			0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63,
-  },
+			0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
-  {
+		]),
-    description: 'DataTrackerListChunk',
+		bytes: Encoders.DataTrackerChunk(1, [
-    expected: new Uint8Array([
+			new Uint8Array([0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
-      1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63,
+			new Uint8Array([1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
-      0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
+			new Uint8Array([2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
-      12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8,
+			new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
-      0, 210, 2, 150, 73, 0, 0, 0, 0,
+			new Uint8Array([4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
-    ]),
+			new Uint8Array([5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
-    bytes: Encoders.DataTrackerListChunk([
+			new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
-      new Uint8Array([
+		]),
-        1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
+	},
-        0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0,
+	{
-        0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210,
+		description: 'DataTrackerListChunk',
-        2, 150, 73, 0, 0, 0, 0,
+		expected: new Uint8Array([
-      ]),
+			1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
-    ]),
+			0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0,
-  },
+			12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128,
-  {
+			63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0,
-    description: 'DataPacketChunk',
+			0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0,
-    expected: new Uint8Array([
+			0, 0,
-      85, 103, 124, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 104, 128, 1, 0, 100, 128, 0, 0,
+		]),
-      12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12,
+		bytes: Encoders.DataTrackerListChunk([
-      0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
+			new Uint8Array([
-      0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+				1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
-    ]),
+				1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0,
-    bytes: Encoders.DataPacketChunk(
+				0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
-      new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+				12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128,
-      new Uint8Array([
+				63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
-        1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128,
+			]),
-        63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63,
+		]),
-        4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6,
+	},
-        0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+	{
-      ])
+		description: 'DataPacketChunk',
-    ),
+		expected: new Uint8Array([
-  },
+			85, 103, 124, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123,
-  {
+			1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
-    description: 'InfoTrackerNameChunk',
+			0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0,
-    expected: new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+			12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128,
-    bytes: Encoders.InfoTrackerNameChunk('Tracker 1'),
+			63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0,
-  },
+			0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0,
-  {
+			0, 0,
-    description: 'InfoSystemNameChunk',
+		]),
-    expected: new Uint8Array([1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+		bytes: Encoders.DataPacketChunk(
-    bytes: Encoders.InfoSystemNameChunk('PSN Server'),
+			new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
-  },
+			new Uint8Array([
-  {
+				1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
-    description: 'InfoTrackerChunk',
+				0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2,
-    expected: new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+				0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0,
-    bytes: Encoders.InfoTrackerChunk(1, new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49])),
+				128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0,
-  },
+				12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2,
-  {
+				150, 73, 0, 0, 0, 0,
-    description: 'InfoTrackerListChunk',
+			])
-    expected: new Uint8Array([2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+		),
-    bytes: Encoders.InfoTrackerListChunk([
+	},
-      new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+	{
-    ]),
+		description: 'InfoTrackerNameChunk',
-  },
+		expected: new Uint8Array([
-  {
+			0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
-    description: 'PacketHeaderChunk',
+		]),
-    expected: new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+		bytes: Encoders.InfoTrackerNameChunk('Tracker 1'),
-    bytes: Encoders.PacketHeaderChunk(1234567890n, 2, 3, 1, 123),
+	},
-  },
+	{
-  {
+		description: 'InfoSystemNameChunk',
-    description: 'InfoPacketChunk',
+		expected: new Uint8Array([
-    expected: new Uint8Array([
+			1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114,
-      86, 103, 51, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 10, 0, 80, 83, 78, 32, 83, 101,
+		]),
-      114, 118, 101, 114, 2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
+		bytes: Encoders.InfoSystemNameChunk('PSN Server'),
-    ]),
+	},
-    bytes: Encoders.InfoPacketChunk(
+	{
-      new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+		description: 'InfoTrackerChunk',
-      new Uint8Array([1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+		expected: new Uint8Array([
-      new Uint8Array([2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49])
+			1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
-    ),
+		]),
-  },
+		bytes: Encoders.InfoTrackerChunk(
+			1,
+			new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49])
+		),
+	},
+	{
+		description: 'InfoTrackerListChunk',
+		expected: new Uint8Array([
+			2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114,
+			32, 49,
+		]),
+		bytes: Encoders.InfoTrackerListChunk([
+			new Uint8Array([
+				1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
+			]),
+		]),
+	},
+	{
+		description: 'PacketHeaderChunk',
+		expected: new Uint8Array([
+			0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123,
+		]),
+		bytes: Encoders.PacketHeaderChunk(1234567890n, 2, 3, 1, 123),
+	},
+	{
+		description: 'InfoPacketChunk',
+		expected: new Uint8Array([
+			86, 103, 51, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123,
+			1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114, 2, 0, 17, 128,
+			1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
+		]),
+		bytes: Encoders.InfoPacketChunk(
+			new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+			new Uint8Array([
+				1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114,
+			]),
+			new Uint8Array([
+				2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101,
+				114, 32, 49,
+			])
+		),
+	},
 ];
 
 describe('PSN Message Encoding', () => {
-  goodTests.forEach((messageTest) => {
+	goodTests.forEach((messageTest) => {
-    it(messageTest.description, () => {
+		it(messageTest.description, () => {
-      deepEqual(messageTest.bytes, messageTest.expected);
+			deepEqual(messageTest.bytes, messageTest.expected);
-    });
+		});
-  });
+	});
 });
 
 //TODO(jwetzell): add tests that handle errors
 const badTests = [];
 
 describe('PSN Message Encoding Throws', () => {
-  badTests.forEach((messageTest) => {
+	badTests.forEach((messageTest) => {
-    it(messageTest.description, () => {
+		it(messageTest.description, () => {
-      throws(() => {}, messageTest.throwsMessage);
+			throws(() => {}, messageTest.throwsMessage);
-    });
+		});
-  });
+	});
 });

tsconfig.json

@@ -1,20 +1,20 @@
 {
-  "compilerOptions": {
+	"compilerOptions": {
-    "target": "esnext",
+		"target": "esnext",
-    "lib": ["es2023"],
+		"lib": ["es2023"],
-    "moduleDetection": "force",
+		"moduleDetection": "force",
-    "module": "preserve",
+		"module": "preserve",
-    "moduleResolution": "bundler",
+		"moduleResolution": "bundler",
-    "resolveJsonModule": true,
+		"resolveJsonModule": true,
-    "types": ["node"],
+		"types": ["node"],
-    "strict": true,
+		"strict": true,
-    "noUnusedLocals": true,
+		"noUnusedLocals": true,
-    "declaration": true,
+		"declaration": true,
-    "emitDeclarationOnly": true,
+		"emitDeclarationOnly": true,
-    "esModuleInterop": true,
+		"esModuleInterop": true,
-    "isolatedModules": true,
+		"isolatedModules": true,
-    "verbatimModuleSyntax": true,
+		"verbatimModuleSyntax": true,
-    "skipLibCheck": true
+		"skipLibCheck": true
-  },
+	},
-  "include": ["src"]
+	"include": ["src"]
 }

tsdown.config.ts

@@ -1,10 +1,10 @@
-import { defineConfig } from 'tsdown'
+import { defineConfig } from 'tsdown';
 
 export default defineConfig({
-  entry: 'src/index.ts',
+	entry: 'src/index.ts',
-  exports: true,
+	exports: true,
-  format: {
+	format: {
-    esm: {},
+		esm: {},
-    cjs: {},
+		cjs: {},
-  },
+	},
-})
+});