camstreamerlib 4.0.0-beta.7 → 4.0.0-beta.71

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';
     }
 }
@@ -64,3 +94,83 @@ export class AddNewClipError extends Error {
         this.name = 'AddNewClipError';
     }
 }
+export class PtzNotSupportedError extends Error {
+    constructor() {
+        super('Ptz not supported.');
+        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';
+    }
+}

package/esm/index.js

@@ -1,11 +1,27 @@
-export * from './internal/common';
+export * from './errors/errors';
+export * from './internal/types';
 export * from './internal/constants';
 export * from './internal/utils';
 export * from './internal/versionCompare';
+export * from './internal/ProxyClient';
 export * from './types/common';
+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/CamOverlayAPI';
+export { CamOverlayEvents } from './ws/CamOverlayEvents';
+export * from './types/ws/CamOverlayEvents';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
-export { CamSwitcherEvents } from './CamSwitcherEvents';
-export { VapixAPI } from './VapixAPI';
-export * from './types/CamSwitcherEvents';
 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';

package/esm/internal/ProxyClient.js

@@ -1,40 +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, path, parameters, headers = {}) => {
-        const url = addParametersToPath(path, parameters);
-        const { realUrl, realHeaders } = this.getReal(proxy, url, headers);
-        return this.client.get(realUrl, {}, realHeaders);
-    };
-    post = (proxy, path, data, parameters, headers) => {
-        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,26 @@ 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) {
+    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 +57,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/types.js

@@ -0,0 +1 @@
+export {};

package/esm/internal/utils.js

@@ -1,4 +1,3 @@
-import { isNullish } from './common';
 export const addParametersToPath = (path, params) => {
     if (params === undefined || Object.keys(params).length === 0) {
         return path;
@@ -32,3 +31,14 @@ 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 pad(num, size) {
+    const sign = Math.sign(num) === -1 ? '-' : '';
+    return (sign +
+        new Array(size)
+            .concat([Math.abs(num)])
+            .join('0')
+            .slice(-size));
+}
+export function isNullish(value) {
+    return value === null || value === undefined;
+}

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) {

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/Frame.js

@@ -54,6 +54,14 @@ export class Frame extends EventEmitter {
         this.width = width;
         this.height = height;
     }
+    getFrameInfo() {
+        return {
+            x: this.posX,
+            y: this.posY,
+            width: this.width,
+            height: this.height,
+        };
+    }
     setText(text, align, textType = 'TFM_OVERFLOW', fontColor) {
         this.text = text;
         this.align = align;
@@ -73,6 +81,16 @@ export class Frame extends EventEmitter {
         this.fontName = undefined;
         this.font = fontData;
     }
+    getTextInfo() {
+        return {
+            text: this.text,
+            textAlign: this.align,
+            textType: this.textType,
+            fontColor: this.fontColor,
+            font: this.font,
+            fontName: this.fontName,
+        };
+    }
     setBgColor(color) {
         this.bgColor = color;
     }
@@ -89,6 +107,14 @@ export class Frame extends EventEmitter {
     setBgType(type) {
         this.bgType = type;
     }
+    getBgInfo() {
+        return {
+            bgColor: this.bgColor,
+            bgImage: this.bgImage,
+            bgImageName: this.bgImageName,
+            bgType: this.bgType,
+        };
+    }
     setBorderRadius(radius) {
         this.borderRadius = radius;
     }
@@ -98,6 +124,13 @@ export class Frame extends EventEmitter {
     setBorderColor(color) {
         this.borderColor = color;
     }
+    getBorderInfo() {
+        return {
+            borderRadius: this.borderRadius,
+            borderWidth: this.borderWidth,
+            borderColor: this.borderColor,
+        };
+    }
     setCustomDraw(customDraw) {
         this.customDraw = customDraw;
     }

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/Painter.js

@@ -1,17 +1,7 @@
 import { CamOverlayDrawingAPI } from '../CamOverlayDrawingAPI';
-import ResourceManager from './ResourceManager';
+import { ResourceManager } from './ResourceManager';
 import { Frame } from './Frame';
-export const COORD = {
-    top_left: [-1, -1],
-    center_left: [-1, 0],
-    bottom_left: [-1, 1],
-    top_center: [0, -1],
-    center: [0, 0],
-    bottom_center: [0, 1],
-    top_right: [1, -1],
-    center_right: [1, 0],
-    bottom_right: [1, 1],
-};
+import { COORD } from '../../types/CamOverlayPainter';
 export class Painter extends Frame {
     screenWidth;
     screenHeight;
@@ -163,4 +153,3 @@ export class Painter extends Frame {
         }
     }
 }
-export { Frame, ResourceManager };

package/esm/{CamOverlayPainter → node/CamOverlayPainter}/ResourceManager.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs/promises';
-export default class ResourceManager {
+export class ResourceManager {
     co;
     imgFileNames = {};
     fontFileNames = {};
@@ -18,8 +18,9 @@ export default class ResourceManager {
         if (this.images[moniker] !== undefined) {
             return this.images[moniker];
         }
-        if (this.imgFileNames[moniker] !== undefined) {
-            const imgData = await fs.readFile(this.imgFileNames[moniker]);
+        const path = this.imgFileNames[moniker];
+        if (path !== undefined) {
+            const imgData = await fs.readFile(path);
             this.images[moniker] = await this.co.uploadImageData(imgData);
             return this.images[moniker];
         }
@@ -29,8 +30,9 @@ export default class ResourceManager {
         if (this.fonts[moniker] !== undefined) {
             return this.fonts[moniker];
         }
-        if (this.fontFileNames[moniker] !== undefined) {
-            const fontData = await fs.readFile(this.fontFileNames[moniker]);
+        const path = this.fontFileNames[moniker];
+        if (path !== undefined) {
+            const fontData = await fs.readFile(path);
             this.fonts[moniker] = await this.co.uploadFontData(fontData);
             return this.fonts[moniker];
         }

package/esm/{CamScripterAPICameraEventsGenerator.js → node/CamScripterAPICameraEventsGenerator.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 CamScripterAPICameraEventsGenerator extends EventEmitter {
     tls;
     tlsInsecure;
@@ -31,7 +31,7 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
         this.startMsgsTimeoutCheck();
     }
     disconnect() {
-        this.ws.close();
+        this.ws.destroy();
         this.stopMsgsTimeoutCheck();
     }
     declareEvent(eventDeclaration) {
@@ -67,21 +67,21 @@ export class CamScripterAPICameraEventsGenerator extends EventEmitter {
             protocol: 'camera-events',
         };
         this.ws = new WsClient(options);
-        this.ws.on('open', () => {
+        this.ws.onOpen = () => {
             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.reportErr(error);
-        });
-        this.ws.on('close', () => {
+        };
+        this.ws.onClose = () => {
             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;