camstreamerlib 4.0.33 → 4.0.34-be26059

package/esm/node/HttpRequestSender.test.js

@@ -0,0 +1,136 @@
+import * as http from 'http';
+import { FormData } from 'undici';
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { HttpRequestSender } from './HttpRequestSender';
+const DIGEST_CHALLENGE = 'Digest realm="test", qop="auth", nonce="abc123", opaque="xyz"';
+const okHandler = (_req, res) => {
+    res.end('ok');
+};
+const digestHandler = (req, res) => {
+    if (req.headers.authorization?.startsWith('Digest ') !== true) {
+        res.writeHead(401, { 'WWW-Authenticate': DIGEST_CHALLENGE });
+        res.end();
+        return;
+    }
+    res.end('ok');
+};
+describe('HttpRequestSender', () => {
+    let server;
+    let received;
+    let handler;
+    const options = (overrides = {}) => ({
+        protocol: 'http:',
+        host: '127.0.0.1',
+        port: server.address().port,
+        path: '/test.cgi',
+        user: 'root',
+        pass: 'pass',
+        ...overrides,
+    });
+    beforeEach(async () => {
+        received = [];
+        handler = okHandler;
+        server = http.createServer((req, res) => {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                received.push({
+                    method: req.method,
+                    url: req.url,
+                    authorization: req.headers.authorization,
+                    contentType: req.headers['content-type'],
+                    body,
+                });
+                handler(req, res);
+            });
+        });
+        await new Promise((resolve) => {
+            server.listen(0, '127.0.0.1', resolve);
+        });
+    });
+    afterEach(async () => {
+        server.closeAllConnections();
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    });
+    test('sends basic auth when the server accepts it', async () => {
+        const res = await new HttpRequestSender().sendRequest(options());
+        expect(res.status).toBe(200);
+        expect(await res.text()).toBe('ok');
+        expect(received).toHaveLength(1);
+        expect(received[0]?.authorization).toBe(`Basic ${Buffer.from('root:pass').toString('base64')}`);
+    });
+    test('sends no authorization without credentials', async () => {
+        await new HttpRequestSender().sendRequest(options({ user: undefined, pass: undefined }));
+        expect(received[0]?.authorization).toBeUndefined();
+    });
+    test('retries with digest auth on a digest 401 and reuses it for later requests', async () => {
+        handler = digestHandler;
+        const sender = new HttpRequestSender();
+        const first = await sender.sendRequest(options());
+        const second = await sender.sendRequest(options());
+        expect(first.status).toBe(200);
+        expect(second.status).toBe(200);
+        expect(received.map((r) => r.authorization?.split(' ')[0])).toEqual(['Basic', 'Digest', 'Digest']);
+    });
+    test('keeps digest auth after a non-401 error response', async () => {
+        const sender = new HttpRequestSender();
+        handler = digestHandler;
+        await sender.sendRequest(options());
+        handler = (_req, res) => {
+            res.writeHead(500);
+            res.end();
+        };
+        await sender.sendRequest(options());
+        handler = digestHandler;
+        const res = await sender.sendRequest(options());
+        expect(res.status).toBe(200);
+        expect(received.map((r) => r.authorization?.split(' ')[0])).toEqual(['Basic', 'Digest', 'Digest', 'Digest']);
+    });
+    test('retries a digest 401 only once', async () => {
+        handler = (_req, res) => {
+            res.writeHead(401, { 'WWW-Authenticate': DIGEST_CHALLENGE });
+            res.end();
+        };
+        const res = await new HttpRequestSender().sendRequest(options());
+        expect(res.status).toBe(401);
+        expect(received).toHaveLength(2);
+    });
+    test('rejects when the response does not arrive within the timeout', async () => {
+        handler = () => undefined;
+        await expect(new HttpRequestSender().sendRequest(options({ timeout: 200 }))).rejects.toThrow();
+    });
+    test('sends a url-encoded POST body', async () => {
+        const res = await new HttpRequestSender().sendRequest(options({ method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }), 'action=settext&text=hello');
+        expect(res.ok).toBe(true);
+        expect(received[0]).toMatchObject({
+            method: 'POST',
+            contentType: 'application/x-www-form-urlencoded',
+            body: 'action=settext&text=hello',
+        });
+    });
+    test('sends a JSON POST body', async () => {
+        const payload = JSON.stringify({ text: 'hello', index: 1 });
+        await new HttpRequestSender().sendRequest(options({ method: 'POST', headers: { 'Content-Type': 'application/json' } }), payload);
+        expect(received[0]).toMatchObject({ method: 'POST', contentType: 'application/json', body: payload });
+    });
+    test('sends a Buffer POST body', async () => {
+        await new HttpRequestSender().sendRequest(options({ method: 'POST' }), Buffer.from('binary-data'));
+        expect(received[0]?.body).toBe('binary-data');
+    });
+    test('sends a FormData POST body as multipart', async () => {
+        const formData = new FormData();
+        formData.append('field', 'value');
+        await new HttpRequestSender().sendRequest(options({ method: 'POST' }), formData);
+        expect(received[0]?.contentType).toMatch(/^multipart\/form-data; boundary=/);
+        expect(received[0]?.body).toContain('value');
+    });
+    test('resends the POST body on the digest retry', async () => {
+        handler = digestHandler;
+        await new HttpRequestSender().sendRequest(options({ method: 'POST' }), 'payload');
+        expect(received.map((r) => r.body)).toEqual(['payload', 'payload']);
+    });
+});

package/esm/types/PlaneTrackerAPI.js

@@ -37,13 +37,59 @@ const labelOptionsSchema = z.union([
     z.literal('flight_number'),
     z.literal('icao'),
 ]);
-const identificationLabelSchema = z.object({
+const aircraftIdentificationLabelSchema = z.object({
     firstRow: labelOptionsSchema,
     secondRow: labelOptionsSchema,
     thirdRow: labelOptionsSchema,
     fourthRow: labelOptionsSchema,
     opacity: z.number().positive(),
 });
+const droneLabelOptionsSchema = z.union([z.literal('blank'), z.literal('remote_id')]);
+const droneIdentificationLabelSchema = z.object({
+    firstRow: droneLabelOptionsSchema,
+    opacity: z.number().positive(),
+});
+const DEFAULT_DRONE_IDENTIFICATION_LABEL = {
+    firstRow: 'remote_id',
+    opacity: 30,
+};
+const identificationLabelSchema = z.union([
+    z.object({
+        aircraft: aircraftIdentificationLabelSchema,
+        drone: droneIdentificationLabelSchema.default(DEFAULT_DRONE_IDENTIFICATION_LABEL),
+    }),
+    aircraftIdentificationLabelSchema.transform((aircraft) => ({
+        aircraft,
+        drone: { ...DEFAULT_DRONE_IDENTIFICATION_LABEL },
+    })),
+]);
+const captureConfigSchema = z.object({
+    defaultCaptureSizeMeters: z.number().positive(),
+    captureSizeExtensionMeters: z.number().positive(),
+});
+const DEFAULT_CAPTURE_CONFIG = {
+    defaultCaptureSizeMeters: 120,
+    captureSizeExtensionMeters: 80,
+};
+const cameraConfigSchema = z.union([
+    z.object({
+        aircraft: captureConfigSchema,
+        drone: captureConfigSchema.default(() => ({ ...DEFAULT_CAPTURE_CONFIG })),
+    }),
+    z
+        .object({
+        defaultCaptureSizeMeters: z.number().positive().default(DEFAULT_CAPTURE_CONFIG.defaultCaptureSizeMeters),
+        captureSizeExtensionMeters: z
+            .number()
+            .positive()
+            .default(DEFAULT_CAPTURE_CONFIG.captureSizeExtensionMeters),
+    })
+        .strict()
+        .transform((captureConfig) => ({
+        aircraft: captureConfig,
+        drone: { ...captureConfig },
+    })),
+]);
 export const cameraSettingsSchema = z.object({
     units: z.union([z.literal('metric'), z.literal('imperial')]).default('imperial'),
     adsbSource: z
@@ -81,15 +127,10 @@ export const cameraSettingsSchema = z.object({
         nightSkyCalibrationFocusValue: 9000,
         focusCalibrationPoints: '',
     }),
-    cameraConfig: z
-        .object({
-        defaultCaptureSizeMeters: z.number().positive().default(120),
-        captureSizeExtensionMeters: z.number().positive().default(80),
-    })
-        .default({
-        defaultCaptureSizeMeters: 120,
-        captureSizeExtensionMeters: 80,
-    }),
+    cameraConfig: cameraConfigSchema.default(() => ({
+        aircraft: { ...DEFAULT_CAPTURE_CONFIG },
+        drone: { ...DEFAULT_CAPTURE_CONFIG },
+    })),
     stream: z
         .object({
         width: z.number().positive(),
@@ -200,11 +241,14 @@ export const cameraSettingsSchema = z.object({
         port: 80,
     }),
     identificationLabel: identificationLabelSchema.default({
-        firstRow: 'registration',
-        secondRow: 'blank',
-        thirdRow: 'blank',
-        fourthRow: 'blank',
-        opacity: 30,
+        aircraft: {
+            firstRow: 'icao',
+            secondRow: 'call_sign',
+            thirdRow: 'blank',
+            fourthRow: 'blank',
+            opacity: 30,
+        },
+        drone: DEFAULT_DRONE_IDENTIFICATION_LABEL,
     }),
     acs: connectionSchema
         .extend({

package/esm/types/PlaneTrackerAPI.test.js

@@ -0,0 +1,88 @@
+import { cameraSettingsSchema } from './PlaneTrackerAPI';
+import { describe, test, expect } from '@jest/globals';
+const AIRCRAFT_LABEL = {
+    firstRow: 'icao',
+    secondRow: 'call_sign',
+    thirdRow: 'blank',
+    fourthRow: 'registration',
+    opacity: 50,
+};
+const DEFAULT_DRONE_LABEL = { firstRow: 'remote_id', opacity: 30 };
+describe('cameraSettingsSchema identificationLabel', () => {
+    test('defaults both aircraft and drone labels', () => {
+        expect(cameraSettingsSchema.parse({}).identificationLabel).toEqual({
+            aircraft: {
+                firstRow: 'icao',
+                secondRow: 'call_sign',
+                thirdRow: 'blank',
+                fourthRow: 'blank',
+                opacity: 30,
+            },
+            drone: DEFAULT_DRONE_LABEL,
+        });
+    });
+    test('parses the aircraft and drone label', () => {
+        const identificationLabel = { aircraft: AIRCRAFT_LABEL, drone: { firstRow: 'blank', opacity: 70 } };
+        expect(cameraSettingsSchema.parse({ identificationLabel }).identificationLabel).toEqual(identificationLabel);
+    });
+    test('defaults a missing drone label', () => {
+        expect(cameraSettingsSchema.parse({ identificationLabel: { aircraft: AIRCRAFT_LABEL } }).identificationLabel).toEqual({ aircraft: AIRCRAFT_LABEL, drone: DEFAULT_DRONE_LABEL });
+    });
+    test('converts the legacy flat label to the aircraft label', () => {
+        expect(cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL }).identificationLabel).toEqual({
+            aircraft: AIRCRAFT_LABEL,
+            drone: DEFAULT_DRONE_LABEL,
+        });
+    });
+    test('returns an independent drone label for each legacy parse', () => {
+        const first = cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL });
+        first.identificationLabel.drone.opacity = 90;
+        const second = cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL });
+        expect(second.identificationLabel.drone).toEqual(DEFAULT_DRONE_LABEL);
+    });
+    test('rejects an unknown drone label row', () => {
+        const identificationLabel = { aircraft: AIRCRAFT_LABEL, drone: { firstRow: 'icao', opacity: 30 } };
+        expect(cameraSettingsSchema.safeParse({ identificationLabel }).success).toBe(false);
+    });
+});
+const CAPTURE_CONFIG = { defaultCaptureSizeMeters: 50, captureSizeExtensionMeters: 20 };
+const DEFAULT_CAPTURE_CONFIG = { defaultCaptureSizeMeters: 120, captureSizeExtensionMeters: 80 };
+describe('cameraSettingsSchema cameraConfig', () => {
+    test('defaults both aircraft and drone capture config', () => {
+        expect(cameraSettingsSchema.parse({}).cameraConfig).toEqual({
+            aircraft: DEFAULT_CAPTURE_CONFIG,
+            drone: DEFAULT_CAPTURE_CONFIG,
+        });
+    });
+    test('parses independent aircraft and drone capture config', () => {
+        const cameraConfig = {
+            aircraft: CAPTURE_CONFIG,
+            drone: { defaultCaptureSizeMeters: 5, captureSizeExtensionMeters: 3 },
+        };
+        expect(cameraSettingsSchema.parse({ cameraConfig }).cameraConfig).toEqual(cameraConfig);
+    });
+    test('defaults a missing drone capture config', () => {
+        expect(cameraSettingsSchema.parse({ cameraConfig: { aircraft: CAPTURE_CONFIG } }).cameraConfig).toEqual({
+            aircraft: CAPTURE_CONFIG,
+            drone: DEFAULT_CAPTURE_CONFIG,
+        });
+    });
+    test('copies the legacy flat capture config to both aircraft and drone', () => {
+        expect(cameraSettingsSchema.parse({ cameraConfig: CAPTURE_CONFIG }).cameraConfig).toEqual({
+            aircraft: CAPTURE_CONFIG,
+            drone: CAPTURE_CONFIG,
+        });
+    });
+    test('returns independent aircraft and drone objects', () => {
+        const legacy = cameraSettingsSchema.parse({ cameraConfig: CAPTURE_CONFIG }).cameraConfig;
+        legacy.drone.defaultCaptureSizeMeters = 1;
+        expect(legacy.aircraft).toEqual(CAPTURE_CONFIG);
+        const first = cameraSettingsSchema.parse({}).cameraConfig;
+        first.drone.defaultCaptureSizeMeters = 1;
+        expect(cameraSettingsSchema.parse({}).cameraConfig.drone).toEqual(DEFAULT_CAPTURE_CONFIG);
+    });
+    test('rejects a non-positive drone capture size', () => {
+        const cameraConfig = { aircraft: CAPTURE_CONFIG, drone: { ...CAPTURE_CONFIG, defaultCaptureSizeMeters: 0 } };
+        expect(cameraSettingsSchema.safeParse({ cameraConfig }).success).toBe(false);
+    });
+});

package/esm/types/ws/PlaneTrackerEvents.js

@@ -3,6 +3,7 @@ import { blackListSchema, friendlyListSchema, priorityListSchema, trackingModeSc
 const wsApiFlightDataSchema = z.object({
     targetId: z.string(),
     icao: z.string(),
+    callsign: z.string().optional(),
     domain: domainIdSchema,
     categoryId: z.string(),
     groupId: z.string().optional(),
@@ -44,6 +45,18 @@ const apiUserSchema = userSchema.extend({
     ip: z.string(),
     userPriority: z.number(),
 });
+export const USER_PRIORITY_MIN = 1;
+export const USER_PRIORITY_MAX = 255;
+const USER_PRIORITY_ERROR = `userPriority must be an integer between ${USER_PRIORITY_MIN} and ${USER_PRIORITY_MAX}, where ${USER_PRIORITY_MIN} is the highest priority`;
+export const apiUserInputSchema = apiUserSchema.omit({ ip: true }).extend({
+    userId: z.string().nonempty(),
+    userName: z.string().nonempty(),
+    userPriority: z
+        .number()
+        .int(USER_PRIORITY_ERROR)
+        .min(USER_PRIORITY_MIN, USER_PRIORITY_ERROR)
+        .max(USER_PRIORITY_MAX, USER_PRIORITY_ERROR),
+});
 export var EUserActions;
 (function (EUserActions) {
     EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
@@ -67,6 +80,7 @@ const eventsDataSchema = z.union([
         type: z.literal('TRACKING_START'),
         icao: z.string(),
         targetId: z.string(),
+        callsign: z.string().optional(),
         domain: domainIdSchema,
         categoryId: z.string(),
     }),

package/esm/ws/PlaneTrackerEvents.js

@@ -1,10 +1,10 @@
 import { WsEvents } from '../internal/WsEvents';
-import { ptrEventsSchema } from '../types/ws/PlaneTrackerEvents';
+import { ptrEventsSchema, apiUserInputSchema, } from '../types/ws/PlaneTrackerEvents';
 export class PlaneTrackerEvents extends WsEvents {
     _apiUser;
-    constructor(ws, _apiUser) {
+    constructor(ws, apiUser) {
         super((data) => ptrEventsSchema.parse(data), ws);
-        this._apiUser = _apiUser;
+        this._apiUser = apiUserInputSchema.parse(apiUser);
         this.ws.onOpen = this.sendInitMsg;
     }
     sendInitMsg = () => {

package/esm/ws/PlaneTrackerEvents.test.js

@@ -0,0 +1,25 @@
+import { PlaneTrackerEvents } from './PlaneTrackerEvents';
+import { USER_PRIORITY_MAX, USER_PRIORITY_MIN } from '../types/ws/PlaneTrackerEvents';
+const createWsClient = () => ({
+    send: jest.fn(),
+    onOpen: undefined,
+    onMessage: undefined,
+});
+const VALID_USER = { userId: 'asd', userName: 'Asd', userPriority: 1 };
+describe('PlaneTrackerEvents', () => {
+    it.each([0, -1, USER_PRIORITY_MAX + 1, 1.5])('rejects userPriority %p', (userPriority) => {
+        expect(() => new PlaneTrackerEvents(createWsClient(), { ...VALID_USER, userPriority })).toThrow(/userPriority must be an integer/);
+    });
+    it.each([USER_PRIORITY_MIN, USER_PRIORITY_MAX])('accepts userPriority %p', (userPriority) => {
+        expect(() => new PlaneTrackerEvents(createWsClient(), { ...VALID_USER, userPriority })).not.toThrow();
+    });
+    it('rejects an empty userId', () => {
+        expect(() => new PlaneTrackerEvents(createWsClient(), { ...VALID_USER, userId: '' })).toThrow();
+    });
+    it('sends USER_INFO once the socket opens', () => {
+        const ws = createWsClient();
+        new PlaneTrackerEvents(ws, VALID_USER);
+        ws.onOpen();
+        expect(ws.send).toHaveBeenCalledWith(JSON.stringify({ type: 'USER_INFO', ...VALID_USER }));
+    });
+});

package/package.json

@@ -1,113 +1,117 @@
 {
-    "name": "camstreamerlib",
-    "version": "4.0.33",
-    "description": "Helper library for CamStreamer ACAP applications.",
-    "prettier": "@camstreamer/prettier-config",
-    "engine": {
-        "node": ">=18.0.0"
+  "name": "camstreamerlib",
+  "version": "4.0.34-be26059",
+  "description": "Helper library for CamStreamer ACAP applications.",
+  "prettier": "@camstreamer/prettier-config",
+  "engine": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "adm-zip": "^0.6.0",
+    "eventemitter2": "^5.0.1",
+    "fast-xml-parser": "^5.3.6",
+    "type-fest": "^4.41.0",
+    "undici": "^6.28.1",
+    "ws": "^8.18.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@camstreamer/eslint-config": "^1.0.2",
+    "@camstreamer/prettier-config": "^2.0.4",
+    "@types/adm-zip": "^0.5.5",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^18.19.127",
+    "@types/ws": "^8.5.10",
+    "@typescript-eslint/eslint-plugin": "^8.71.1",
+    "@typescript-eslint/parser": "^8.71.1",
+    "esbuild": "^0.28.2",
+    "eslint": "^8.51.0",
+    "eslint-plugin-deprecation": "^2.0.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "jest": "^30.5.2",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.4.14",
+    "ts-node": "^10.7.0",
+    "typescript": "5.3.3"
+  },
+  "overrides": {
+    "js-yaml": "^4.3.2",
+    "browserslist": "^4.28.7",
+    "eslint-plugin-deprecation": {
+      "@typescript-eslint/utils": "^8.71.1"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf dist/*",
+    "build": "npm-run-all clean build:cjs build:esm copyPackage",
+    "build:cjs": "tsc --project tsconfig.cjs.json",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build:browser": "esbuild src/browser.index.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=examples/camstreamerlib.js",
+    "copyPackage": "cp -f LICENSE dist/ && cp -f README.md dist/ && cp -f package.json dist/ && cp -r -f examples dist/",
+    "publishPackage": "./publish.sh",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "pretty": "prettier --write \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",
+    "pretty:check": "prettier --check \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "audit": "npm audit --audit-level=high"
+  },
+  "files": [
+    "/**/*.js",
+    "/**/*.ts",
+    "/examples/**/*"
+  ],
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "types": "./types/index.d.ts"
     },
-    "dependencies": {
-        "adm-zip": "^0.6.0",
-        "eventemitter2": "^5.0.1",
-        "fast-xml-parser": "^5.3.6",
-        "type-fest": "^4.41.0",
-        "undici": "^6.28.0",
-        "ws": "^8.18.0",
-        "zod": "^3.25.76"
+    "./web": {
+      "import": "./esm/web/index.js",
+      "require": "./cjs/web/index.js",
+      "types": "./types/web/index.d.ts"
     },
-    "devDependencies": {
-        "@camstreamer/eslint-config": "^1.0.2",
-        "@camstreamer/prettier-config": "^2.0.4",
-        "@types/adm-zip": "^0.5.5",
-        "@types/jest": "^28.0.0",
-        "@types/node": "^18.19.127",
-        "@types/ws": "^8.5.10",
-        "@typescript-eslint/eslint-plugin": "^6.8.0",
-        "@typescript-eslint/parser": "^6.8.0",
-        "esbuild": "^0.28.2",
-        "eslint": "^8.51.0",
-        "eslint-plugin-deprecation": "^2.0.0",
-        "eslint-plugin-unused-imports": "^3.0.0",
-        "jest": "^28.1.3",
-        "npm-run-all": "^4.1.5",
-        "prettier": "^2.7.1",
-        "ts-jest": "^28.0.0",
-        "ts-node": "^10.7.0",
-        "typescript": "5.3.3"
+    "./node": {
+      "import": "./esm/node/index.js",
+      "require": "./cjs/node/index.js",
+      "types": "./types/node/index.d.ts"
     },
-    "overrides": {
-        "js-yaml": "^4.2.0"
+    "./cjs/index": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "types": "./types/index.d.ts"
     },
-    "scripts": {
-        "clean": "rimraf dist/*",
-        "build": "npm-run-all clean build:cjs build:esm copyPackage",
-        "build:cjs": "tsc --project tsconfig.cjs.json",
-        "build:esm": "tsc --project tsconfig.esm.json",
-        "build:browser": "esbuild src/browser.index.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=examples/camstreamerlib.js",
-        "copyPackage": "cp -f LICENSE dist/ && cp -f README.md dist/ && cp -f package.json dist/ && cp -r -f examples dist/",
-        "publishPackage": "./publish.sh",
-        "lint": "eslint \"src/**/*.ts\"",
-        "lint:fix": "eslint \"src/**/*.ts\" --fix",
-        "pretty": "prettier --write \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",
-        "pretty:check": "prettier --check \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",
-        "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-        "audit": "npm audit --audit-level=high"
+    "./cjs/node": {
+      "import": "./esm/node/index.js",
+      "require": "./cjs/node/index.js",
+      "types": "./types/node/index.js"
     },
-    "files": [
-        "/**/*.js",
-        "/**/*.ts",
-        "/examples/**/*"
-    ],
-    "main": "./cjs/index.js",
-    "module": "./esm/index.js",
-    "types": "types/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./esm/index.js",
-            "require": "./cjs/index.js",
-            "types": "./types/index.d.ts"
-        },
-        "./web": {
-            "import": "./esm/web/index.js",
-            "require": "./cjs/web/index.js",
-            "types": "./types/web/index.d.ts"
-        },
-        "./node": {
-            "import": "./esm/node/index.js",
-            "require": "./cjs/node/index.js",
-            "types": "./types/node/index.d.ts"
-        },
-        "./cjs/index": {
-            "import": "./esm/index.js",
-            "require": "./cjs/index.js",
-            "types": "./types/index.d.ts"
-        },
-        "./cjs/node": {
-            "import": "./esm/node/index.js",
-            "require": "./cjs/node/index.js",
-            "types": "./types/node/index.js"
-        },
-        "./cjs/node/index": {
-            "import": "./esm/node/index.js",
-            "require": "./cjs/node/index.js",
-            "types": "./types/node/index.js"
-        }
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/CamStreamer/CamStreamerLib.git"
-    },
-    "keywords": [
-        "CamStreamer",
-        "CamOverlay",
-        "CamScripter",
-        "Camera",
-        "Axis"
-    ],
-    "author": "CamStreamer s.r.o",
-    "license": "ISC",
-    "bugs": {
-        "url": "https://github.com/CamStreamer/CamStreamerLib/issues"
-    },
-    "homepage": "https://github.com/CamStreamer/CamStreamerLib#readme"
+    "./cjs/node/index": {
+      "import": "./esm/node/index.js",
+      "require": "./cjs/node/index.js",
+      "types": "./types/node/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CamStreamer/CamStreamerLib.git"
+  },
+  "keywords": [
+    "CamStreamer",
+    "CamOverlay",
+    "CamScripter",
+    "Camera",
+    "Axis"
+  ],
+  "author": "CamStreamer s.r.o",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/CamStreamer/CamStreamerLib/issues"
+  },
+  "homepage": "https://github.com/CamStreamer/CamStreamerLib#readme"
 }