camstreamerlib 4.0.0-beta.11 → 4.0.0-beta.111

package/esm/{CreatePackage.js → bin/CreatePackage.js}

@@ -1,15 +1,15 @@
-import * as AdmZip from 'adm-zip';
-import * as Path from 'path';
+import AdmZip from 'adm-zip';
+import * as path from 'path';
 import * as fs from 'fs';
 import { execSync } from 'child_process';
 const productionModulesFolder = 'production_modules';
-function isDirectory(path) {
-    const stat = fs.statSync(path);
+function isDirectory(filePath) {
+    const stat = fs.statSync(filePath);
     return stat.isDirectory();
 }
 function getPackageInfo(folder) {
     try {
-        const manifest = fs.readFileSync(Path.join(folder, 'manifest.json'));
+        const manifest = fs.readFileSync(path.join(folder, 'manifest.json'));
         const manifestParsed = JSON.parse(manifest.toString());
         return {
             packageName: manifestParsed.package_name,
@@ -21,11 +21,11 @@ function getPackageInfo(folder) {
     }
 }
 function createZipArchive(zip, folder, options) {
-    const zipFileRegex = new RegExp(`${Path.basename(folder)}(_[0-9]){3}\\.zip`);
+    const zipFileRegex = new RegExp(`${path.basename(folder)}(_[0-9]){3}\\.zip`);
     const files = fs.readdirSync(folder);
     for (const file of files) {
-        const path = Path.join(folder, file);
-        const isDir = isDirectory(path);
+        const filePath = path.join(folder, file);
+        const isDir = isDirectory(filePath);
         if (file[0] === '.' ||
             zipFileRegex.test(file) ||
             file === 'node_modules' ||
@@ -34,16 +34,16 @@ function createZipArchive(zip, folder, options) {
             continue;
         }
         else if (file === 'dist' && options.typeScriptPackage) {
-            zip.addLocalFolder(path);
+            zip.addLocalFolder(filePath);
         }
         else if (file === productionModulesFolder && options.includeNodeModules) {
-            zip.addLocalFolder(Path.join(productionModulesFolder, 'node_modules'), 'node_modules');
+            zip.addLocalFolder(path.join(productionModulesFolder, 'node_modules'), 'node_modules');
         }
         else if (isDir) {
-            zip.addLocalFolder(path, file);
+            zip.addLocalFolder(filePath, file);
         }
         else {
-            zip.addLocalFile(path);
+            zip.addLocalFile(filePath);
         }
     }
 }
@@ -51,10 +51,10 @@ function installDependencies() {
     if (!fs.existsSync(productionModulesFolder)) {
         fs.mkdirSync(productionModulesFolder, {});
     }
-    fs.cpSync('package.json', Path.join(productionModulesFolder, 'package.json'));
-    fs.cpSync('package-lock.json', Path.join(productionModulesFolder, 'package-lock.json'));
+    fs.cpSync('package.json', path.join(productionModulesFolder, 'package.json'));
+    fs.cpSync('package-lock.json', path.join(productionModulesFolder, 'package-lock.json'));
     execSync(`npm ci --omit=dev`, {
-        cwd: Path.join(process.cwd(), productionModulesFolder),
+        cwd: path.join(process.cwd(), productionModulesFolder),
     });
 }
 function main(args) {
@@ -81,7 +81,7 @@ function main(args) {
     if (fs.existsSync('dist')) {
         options.typeScriptPackage = true;
     }
-    const folder = Path.resolve('.');
+    const folder = path.resolve('.');
     const packageInfo = getPackageInfo(folder);
     if (packageInfo === undefined) {
         console.error('Package info not found');

package/esm/errors/errors.js

@@ -1,3 +1,11 @@
+export class ErrorWithResponse extends Error {
+    res;
+    constructor(res) {
+        super(res.statusText);
+        this.res = res;
+        this.name = 'ErrorWithResponse';
+    }
+}
 export class ServiceUnavailableError extends Error {
     constructor() {
         super('Service is unavailable.');
@@ -16,21 +24,43 @@ export class ParsingBlobError extends Error {
         this.name = 'ParsingBlobError';
     }
 }
+export class JsonParseError extends Error {
+    constructor(paramName, data) {
+        super(`Error: in JSON parsing of ${paramName}. Cannot parse: ${data}`);
+        this.name = 'JsonParseError';
+    }
+}
+export class ParameterNotFoundError extends Error {
+    constructor(paramName) {
+        super(`Error: no parameter '${paramName}' was found`);
+        this.name = 'ParameterNotFoundError';
+    }
+}
+export class SettingParameterError extends Error {
+    constructor(message) {
+        super(`Error setting parameter to camera: ${message}`);
+        this.name = 'SettingParameterError';
+    }
+}
 export class ApplicationAPIError extends Error {
-    constructor(action, res) {
-        super(`[APP ${action}] Error: ` + res);
+    action;
+    constructor(action, reason) {
+        super(`Error performing application action '${action}': ${reason}`);
+        this.action = action;
         this.name = 'ApplicationAPIError';
     }
 }
 export class SDCardActionError extends Error {
-    constructor(action, res) {
-        super(`[SD_CARD ${action}] Error: ` + res);
+    action;
+    constructor(action, reason) {
+        super(`Error performing SD card action '${action}': ${reason}`);
+        this.action = action;
         this.name = 'SDCardActionError';
     }
 }
 export class SDCardJobError extends Error {
-    constructor() {
-        super('Error while fetching SD card job progress');
+    constructor(reason) {
+        super(`Error while fetching SD card job progress: ${reason}`);
         this.name = 'SDCardJobError';
     }
 }
@@ -70,3 +100,89 @@ export class PtzNotSupportedError extends Error {
         this.name = 'PtzNotSupportedError';
     }
 }
+export class StorageDataFetchError extends Error {
+    constructor(err) {
+        super('Error fetching storage data: ' + err);
+        this.name = 'StorageDataFetchError';
+    }
+}
+export class WsAuthorizationError extends Error {
+    constructor(message) {
+        super('Server error on ws authorization: ' + message);
+        this.name = 'WsAuthorizationError';
+    }
+}
+export class UtcTimeFetchError extends Error {
+    constructor(message) {
+        super('Server error on get UTC time: ' + message);
+        this.name = 'UtcTimeFetchError';
+    }
+}
+export class TimezoneNotSetupError extends Error {
+    constructor() {
+        super('Time zone not setup on the device');
+        this.name = 'TimezoneNotSetupError';
+    }
+}
+export class TimezoneFetchError extends Error {
+    constructor(err) {
+        super('Error fetching time zone information: ' + err);
+        this.name = 'TimezoneFetchError';
+    }
+}
+export class ResetCalibrationError extends ErrorWithResponse {
+    type;
+    constructor(type, res) {
+        super(res);
+        this.type = type;
+        this.name = 'ResetCalibrationError';
+    }
+}
+export class ImportSettingsError extends ErrorWithResponse {
+    constructor(res) {
+        super(res);
+        this.name = 'ImportSettingsError';
+    }
+}
+export class CannotSetCoordsInAutoModeError extends Error {
+    constructor() {
+        super("The automatic mode doesn't allow control of the camera.");
+        this.name = 'CannotSetCoordsInAutoModeError';
+    }
+}
+export class InvalidLatLngError extends Error {
+    constructor() {
+        super('The provided latitude or longitude parameters are invalid.');
+        this.name = 'InvalidLatLngError';
+    }
+}
+export class InvalidAltitudeError extends Error {
+    constructor() {
+        super('The provided altitude parameter is invalid.');
+        this.name = 'InvalidAltitudeError';
+    }
+}
+export class ServerError extends Error {
+    constructor() {
+        super('An internal server error occurred.');
+        this.name = 'ServerError';
+    }
+}
+export class BadRequestError extends ErrorWithResponse {
+    constructor(res) {
+        super(res);
+        this.name = 'BadRequestError';
+    }
+}
+export class MigrationError extends Error {
+    valid;
+    old;
+    invalid;
+    constructor(valid, old, invalid = []) {
+        super('Migration to newer version is needed: some stream entries failed to parse.');
+        this.name = 'MigrationError';
+        this.valid = valid;
+        this.old = old;
+        this.invalid = invalid;
+    }
+}

package/esm/index.js

@@ -1,14 +1,28 @@
+export * from './errors/errors';
 export * from './internal/types';
 export * from './internal/constants';
+export * from './internal/convertors';
 export * from './internal/utils';
 export * from './internal/versionCompare';
+export * from './internal/ProxyClient';
 export * from './types/common';
-export { CamSwitcherAPI } from './CamSwitcherAPI';
-export { CamSwitcherEvents } from './CamSwitcherEvents';
-export { VapixAPI } from './VapixAPI';
+export { CamStreamerAPI } from './CamStreamerAPI';
+export * from './types/CamStreamerAPI';
+export { CamStreamerEvents } from './ws/CamStreamerEvents';
+export * from './types/ws/CamStreamerEvents';
 export { CamOverlayAPI } from './CamOverlayAPI';
-export * from './types/CamSwitcherEvents';
+export * from './types/CamOverlayAPI';
+export { CamOverlayEvents } from './ws/CamOverlayEvents';
+export * from './types/ws/CamOverlayEvents';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
 export * from './types/CamSwitcherAPI';
+export { CamSwitcherEvents } from './ws/CamSwitcherEvents';
+export * from './types/ws/CamSwitcherEvents';
+export { PlaneTrackerAPI } from './PlaneTrackerAPI';
+export * from './types/PlaneTrackerAPI';
+export { PlaneTrackerEvents } from './ws/PlaneTrackerEvents';
+export * from './types/ws/PlaneTrackerEvents';
+export { CamScripterAPI } from './CamScripterAPI';
+export * from './types/CamScripterAPI';
+export { VapixAPI } from './VapixAPI';
 export * from './types/VapixAPI';
-export * from './types/CamOverlayAPI';
-export * from './models/CamOverlayAPI';

package/esm/internal/ProxyClient.js

@@ -1,42 +1,36 @@
 import { addParametersToPath } from './utils';
 export class ProxyClient {
     client;
-    getProxyUrl;
-    constructor(client, getProxyUrl) {
+    proxyParams;
+    constructor(client, proxyParams) {
         this.client = client;
-        this.getProxyUrl = getProxyUrl;
+        this.proxyParams = proxyParams;
     }
-    get = (proxy, ...args) => {
-        const [path, parameters, headers] = args;
-        const url = addParametersToPath(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.get(realUrl, {}, realHeaders);
-    };
-    post = (proxy, ...args) => {
-        const [path, data, parameters, headers] = args;
-        const url = addParametersToPath(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.post(realUrl, data, {}, realHeaders);
-    };
-    getReal = (proxy, url, headers) => {
-        if (proxy !== null) {
-            return {
-                realUrl: this.getProxyUrl(),
-                realHeaders: {
-                    ...(headers ?? {}),
-                    'x-target-camera-protocol': proxy.port === 443 ? 'https' : 'http',
-                    'x-target-camera-path': url,
-                    'x-target-camera-ip': proxy.ip,
-                    'x-target-camera-mdns': proxy.mdnsName,
-                    'x-target-camera-port': String(proxy.port),
-                    'x-target-camera-pass': encodeURIComponent(proxy.pass),
-                    'x-target-camera-user': encodeURIComponent(proxy.user),
-                },
-            };
-        }
+    get(params) {
+        const { path, parameters, headers, timeout } = params;
+        const targetPath = addParametersToPath(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.get({ path: realPath, headers: realHeaders, timeout });
+    }
+    post(params) {
+        const { path, data, parameters, headers, timeout } = params;
+        const targetPath = addParametersToPath(path, parameters);
+        const { realPath, realHeaders } = this.getReal(targetPath, headers);
+        return this.client.post({ path: realPath, data, headers: realHeaders, timeout });
+    }
+    getReal(targetPath, headers) {
         return {
-            realUrl: url,
-            realHeaders: headers,
+            realPath: this.proxyParams.path,
+            realHeaders: {
+                ...(headers ?? {}),
+                'x-target-camera-protocol': this.proxyParams.target.port === 443 ? 'https' : 'http',
+                'x-target-camera-path': targetPath,
+                'x-target-camera-ip': this.proxyParams.target.ip,
+                'x-target-camera-mdns': this.proxyParams.target.mdnsName,
+                'x-target-camera-port': String(this.proxyParams.target.port),
+                'x-target-camera-pass': this.proxyParams.target.pass,
+                'x-target-camera-user': this.proxyParams.target.user,
+            },
         };
-    };
+    }
 }

package/esm/{CamSwitcherEvents.js → internal/WsEvents.js}

@@ -1,20 +1,21 @@
-import { cswEventsSchema, } from './types/CamSwitcherEvents';
-export class CamSwitcherEvents {
-    isDestroyed = false;
-    ws = null;
+export class WsEvents {
+    validate;
+    ws;
+    _isDestroyed = false;
     listeners = {};
-    setWebsocket(ws) {
-        if (this.ws) {
-            this.ws.destroy();
-        }
+    constructor(validate, ws) {
+        this.validate = validate;
         this.ws = ws;
-        this.ws.onmessage = (e) => this.onMessage(e);
+        this.ws.onMessage = (e) => this.onMessage(e);
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
     }
     resendInitData() {
         const request = {
             command: 'sendInitData',
         };
-        this.ws?.send(JSON.stringify(request));
+        this.ws.send(JSON.stringify(request));
     }
     addListener(type, listener, id) {
         const typeList = this.listeners[type];
@@ -28,23 +29,31 @@ export class CamSwitcherEvents {
         const typeList = this.listeners[type];
         if (typeList) {
             delete typeList[id];
+            if (Object.keys(typeList).length === 0) {
+                delete this.listeners[type];
+            }
         }
     }
-    onMessage(evt) {
+    removeAllListenersForId(id) {
+        for (const type in this.listeners) {
+            this.removeListener(type, id);
+        }
+    }
+    onMessage(incomeData) {
         if (this.isDestroyed) {
             return;
         }
         try {
-            const eventData = JSON.parse(evt.data);
-            const data = cswEventsSchema.parse(eventData);
-            if (data.type === 'init') {
+            const eventData = JSON.parse(incomeData.toString());
+            const data = this.validate(eventData);
+            if (isInitEvent(data)) {
                 this.processMessage(data.data, true);
                 return;
             }
             this.processMessage(data, false);
         }
         catch (error) {
-            console.error('Error parsing event data:', evt.data, error);
+            console.error('Error parsing event data:', incomeData.toString(), error);
         }
     }
     processMessage(event, isInit) {
@@ -53,11 +62,13 @@ export class CamSwitcherEvents {
         list.forEach((listener) => listener(event, isInit));
     }
     destroy() {
-        this.isDestroyed = true;
-        if (this.ws) {
-            this.ws.destroy();
-            this.ws = null;
-        }
+        this._isDestroyed = true;
+        this.ws.onMessage = () => { };
+        this.ws.onOpen = () => Promise.reject(new Error('Websocket is destroyed'));
+        this.ws.destroy();
         this.listeners = {};
     }
 }
+const isInitEvent = (event) => {
+    return event.type === 'init';
+};

package/esm/internal/constants.js

@@ -1 +1,2 @@
 export const FIRMWARE_WITH_BITRATE_MODES_SUPPORT = '11.11.73';
+export const FIRMWARE_WITH_OVERLAYS_SUPPORT = '10.7.0';

package/esm/internal/convertors.js

@@ -0,0 +1,108 @@
+import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT, FIRMWARE_WITH_OVERLAYS_SUPPORT } from './constants';
+import { isFirmwareVersionAtLeast } from './versionCompare';
+export const parseBitrateOptionsToVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
+    if (!isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
+        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
+    }
+    if (bitrateMode === undefined) {
+        return '';
+    }
+    const data = {
+        VBR: 'videobitratemode=vbr',
+        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}&videobitratepriority=framerate`,
+        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
+    };
+    return data[bitrateMode];
+};
+export const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
+    const params = {};
+    const searchParams = new URLSearchParams(bitrateVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
+    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
+    if (hasLowerFw) {
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: 'MBR',
+            maximumBitRate: maximumBitRate,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate * 1.1),
+        };
+    }
+    if (bitrateMode === 'ABR') {
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
+        };
+    }
+    else if (bitrateMode === 'MBR') {
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: bitrateMode,
+            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
+        };
+    }
+    return {
+        bitrateMode: bitrateMode,
+        retentionTime: 1,
+        maximumBitRate: 0,
+        bitRateLimit: 0,
+    };
+};
+export const parseVideoOptionsToVapixParams = (firmWareVersion, video) => {
+    const bitrateParams = parseBitrateOptionsToVapixParams(firmWareVersion, video.bitrateMode, {
+        maximumBitRate: video.maximumBitRate,
+        retentionTime: video.retentionTime,
+        bitRateLimit: video.bitRateLimit,
+    });
+    let overlaysParams = '';
+    if (isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_OVERLAYS_SUPPORT)) {
+        overlaysParams = `&overlays=${video.overlays}`;
+    }
+    const nbrOfChannels = video.audio === 1 ? `&nbrOfChannels=${video.nbrOfChannels}` : '';
+    const audioParams = `audio=${video.audio}${nbrOfChannels}`;
+    const videoCodecParams = video.videoCodec === 'h264'
+        ? `videoCodec=${video.videoCodec}&h264Profile=${video.h264Profile}`
+        : `videoCodec=${video.videoCodec}`;
+    const videoParams = `camera=${video.camera}&resolution=${video.resolution}&fps=${video.fps}&compression=${video.compression}&videokeyframeinterval=${video.govLength}&${videoCodecParams}${overlaysParams}`;
+    return [videoParams, bitrateParams, audioParams].join('&');
+};
+export const parseVapixParamsToVideoOptions = (internalVapixParams) => {
+    const bitrateOptions = parseVapixParamsToBitrateOptions(internalVapixParams);
+    const params = {};
+    const searchParams = new URLSearchParams(internalVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    let h264Profile = undefined;
+    if (params['videoCodec'] === 'h264') {
+        h264Profile = (params['h264Profile'] ?? 'high');
+    }
+    let nbrOfChannels = undefined;
+    if (params['audio'] === '1') {
+        nbrOfChannels = parseInt(params['nbrOfChannels'] ?? '1');
+    }
+    return {
+        ...bitrateOptions,
+        camera: params['camera'] ?? '1',
+        resolution: params['resolution'] ?? '',
+        fps: parseInt(params['fps'] ?? '0', 10),
+        compression: parseInt(params['compression'] ?? '0', 10),
+        govLength: parseInt(params['videokeyframeinterval'] ?? '0', 10),
+        videoCodec: (params['videoCodec'] ?? 'h264'),
+        h264Profile,
+        audio: parseInt(params['audio'] ?? '0'),
+        nbrOfChannels,
+        overlays: params['overlays'],
+    };
+};

package/esm/internal/utils.js

@@ -31,15 +31,6 @@ export const isClip = (id) => id?.charAt(0) === 's';
 export const isTracker = (id) => id?.charAt(0) === 't';
 export const isPlaylist = (id) => id?.charAt(0) === 'p';
 export const isLoopPlayType = (playType) => playType.includes('LOOP');
-export function isClient(arg = {}) {
-    return 'get' in arg && 'post' in arg;
-}
-export async function responseStringify(res) {
-    return JSON.stringify({
-        status: res.status,
-        body: await res.text(),
-    });
-}
 export function pad(num, size) {
     const sign = Math.sign(num) === -1 ? '-' : '';
     return (sign +

package/esm/{CamOverlayDrawingAPI.js → node/CamOverlayDrawingAPI.js}

@@ -1,5 +1,5 @@
-import * as EventEmitter from 'events';
-import { WsClient } from './node/WsClient';
+import { EventEmitter } from 'events';
+import { WsClient } from './WsClient';
 export class CamOverlayDrawingAPI extends EventEmitter {
     tls;
     tlsInsecure;
@@ -41,7 +41,7 @@ export class CamOverlayDrawingAPI extends EventEmitter {
         this.startMsgsTimeoutCheck();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
         this.stopMsgsTimeoutCheck();
     }
     isConnected() {
@@ -98,23 +98,23 @@ export class CamOverlayDrawingAPI extends EventEmitter {
             tlsInsecure: this.tlsInsecure,
         };
         this.ws = new WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             console.log('CamOverlay connection opened');
             this.wsConnected = true;
             this.emit('open');
-        });
-        this.ws.on('message', (msgData) => this.incomingWsMessageHandler(msgData));
-        this.ws.on('error', (error) => {
+        };
+        this.ws.onMessage = (data) => this.incomingWsMessageHandler(data.toString());
+        this.ws.onError = (error) => {
             this.reportError(error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             console.log('CamOverlay connection closed');
             this.wsConnected = false;
             this.reportClose();
-        });
+        };
     }
     incomingWsMessageHandler(msgData) {
-        const dataJSON = JSON.parse(msgData.toString());
+        const dataJSON = JSON.parse(msgData);
         let errorResponse;
         if ('error' in dataJSON) {
             errorResponse = dataJSON;
@@ -165,13 +165,21 @@ export class CamOverlayDrawingAPI extends EventEmitter {
                     throw new Error('No CamOverlay connection');
                 }
                 msgJson.call_id = ++this.callId;
-                const jsonBuffer = Buffer.from(JSON.stringify(msgJson));
-                const header = new ArrayBuffer(5);
-                const headerView = new DataView(header);
-                headerView.setInt8(0, 1);
-                headerView.setInt32(1, jsonBuffer.byteLength);
-                const msgBuffer = Buffer.concat([Buffer.from(header), jsonBuffer, data]);
-                this.ws.send(msgBuffer);
+                const jsonString = JSON.stringify(msgJson);
+                const jsonByteLength = Buffer.byteLength(jsonString);
+                const headerLength = 5;
+                const totalLength = headerLength + jsonByteLength + data.byteLength;
+                const arrayBuffer = new ArrayBuffer(totalLength);
+                const view = new DataView(arrayBuffer);
+                view.setInt8(0, 1);
+                view.setInt32(1, jsonByteLength);
+                const jsonBuffer = new Uint8Array(arrayBuffer, 5, jsonByteLength);
+                for (let i = 0; i < jsonString.length; i++) {
+                    jsonBuffer[i] = jsonString.charCodeAt(i);
+                }
+                const dataBuffer = new Uint8Array(arrayBuffer, 5 + jsonByteLength, data.byteLength);
+                data.copy(dataBuffer);
+                this.ws.send(arrayBuffer);
                 this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
             }
             catch (err) {