camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.20

package/{events → cjs/events}/AxisCameraStationEvents.d.ts

@@ -1,9 +1,10 @@
-import { IClient, HttpOptions } from '../internal/common';
+import { IClient, HttpOptions } from '../internal/types';
+import { Response } from 'undici';
 export type AcsEventsOptions = HttpOptions;
 export declare class AxisCameraStationEvents {
     private sourceKey;
     private client;
-    constructor(sourceKey: string, opt?: AcsEventsOptions | IClient);
+    constructor(sourceKey: string, opt?: AcsEventsOptions | IClient<Response>);
     sendEvent(data: Record<string, string>, eventType: string): Promise<void>;
     private getDate;
 }

package/cjs/events/AxisCameraStationEvents.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxisCameraStationEvents = void 0;
+const DefaultClient_1 = require("../node/DefaultClient");
+const utils_1 = require("../internal/utils");
+class AxisCameraStationEvents {
+    sourceKey;
+    client;
+    constructor(sourceKey, opt = {}) {
+        this.sourceKey = sourceKey;
+        if ((0, utils_1.isClient)(opt)) {
+            this.client = opt;
+        }
+        else {
+            this.client = new DefaultClient_1.DefaultClient(opt);
+        }
+    }
+    async sendEvent(data, eventType) {
+        const dateString = this.getDate();
+        const event = {
+            addExternalDataRequest: {
+                occurrenceTime: dateString,
+                source: this.sourceKey,
+                externalDataType: eventType,
+                data: data,
+            },
+        };
+        const eventData = JSON.stringify(event);
+        const res = await this.client.post('/Acs/Api/ExternalDataFacade/AddExternalData', eventData, undefined, {
+            'Content-Type': 'application/json',
+            'Content-Length': eventData.length.toString(),
+        });
+        if (!res.ok) {
+            throw new Error(`ACS status code: ${res.status}`);
+        }
+    }
+    getDate() {
+        const date = new Date();
+        const year = date.getUTCFullYear();
+        const month = (0, utils_1.pad)(date.getUTCMonth() + 1, 2);
+        const day = (0, utils_1.pad)(date.getUTCDate(), 2);
+        const hours = (0, utils_1.pad)(date.getUTCHours(), 2);
+        const minutes = (0, utils_1.pad)(date.getUTCMinutes(), 2);
+        const seconds = (0, utils_1.pad)(date.getUTCSeconds(), 2);
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+    }
+}
+exports.AxisCameraStationEvents = AxisCameraStationEvents;

package/{events → cjs/events}/GenetecAgent.d.ts

@@ -148,14 +148,15 @@ export declare const cameraDetailsResponseSchema: z.ZodObject<{
 export type TCameraDetailsResponse = z.infer<typeof cameraDetailsResponseSchema>;
 export type TCameraDetail = z.infer<typeof cameraDetailSchema>;
 export type TParams = Array<'Guid' | 'Name' | 'EntityType'>;
+export type TProtocol = 'http' | 'https' | 'https_insecure';
 export type GenetecAgentOptions = {
-    protocol?: 'http' | 'https' | 'https_insecure';
+    protocol?: TProtocol;
     ip?: string;
     port?: number;
-    base_uri?: string;
+    baseUri?: string;
     user?: string;
     pass?: string;
-    app_id?: string;
+    appId?: string;
 };
 export declare class GenetecAgent {
     private settings;

package/cjs/events/GenetecAgent.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenetecAgent = exports.cameraDetailsResponseSchema = exports.cameraDetailSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../internal/utils");
+const ACTION = 'AddCameraBookmark';
+const GET_CAMERAS_URL = 'report/EntityConfiguration?q=EntityTypes@Camera';
+const GET_CAMERAS_DETAILS_URL = '/entity?q=';
+const cameraGuidsResponseSchema = zod_1.z.object({
+    Rsp: zod_1.z.object({
+        Status: zod_1.z.string(),
+        Result: zod_1.z.array(zod_1.z.object({ Guid: zod_1.z.string() })),
+    }),
+});
+const connectionResponseSchema = zod_1.z.object({
+    Rsp: zod_1.z.object({
+        Status: zod_1.z.string(),
+    }),
+});
+exports.cameraDetailSchema = zod_1.z.object({
+    Guid: zod_1.z.string().optional(),
+    Name: zod_1.z.string().optional(),
+    EntityType: zod_1.z.string().optional(),
+});
+exports.cameraDetailsResponseSchema = zod_1.z.object({
+    Rsp: zod_1.z.object({
+        Status: zod_1.z.string(),
+        Result: zod_1.z.union([zod_1.z.array(exports.cameraDetailSchema), exports.cameraDetailSchema]),
+    }),
+});
+class GenetecAgent {
+    settings;
+    baseUrl;
+    credentials;
+    constructor(options = {}) {
+        this.settings = {
+            protocol: options.protocol ?? 'http',
+            ip: options.ip ?? '127.0.0.1',
+            port: options.port ?? 80,
+            baseUri: options.baseUri ?? 'WebSdk',
+            user: options.user ?? 'root',
+            pass: options.pass ?? '',
+            appId: options.appId ?? '',
+        };
+        this.baseUrl = `${this.settings.protocol}://${this.settings.ip}:${this.settings.port}/${this.settings.baseUri}`;
+        this.credentials = btoa(`${this.settings.user};${this.settings.appId}:${this.settings.pass}`);
+    }
+    async checkConnection() {
+        const requestOptions = this.getRequestOptions('GET');
+        const res = await fetch(`${this.baseUrl}/`, requestOptions);
+        if (!res.ok) {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+        return connectionResponseSchema.parse(await res.json());
+    }
+    async getAllCameraGuids() {
+        const requestOptions = this.getRequestOptions('GET');
+        const res = await fetch(`${this.baseUrl}/${GET_CAMERAS_URL}`, requestOptions);
+        if (!res.ok) {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+        return cameraGuidsResponseSchema.parse(await res.json());
+    }
+    async getCameraDetails(guids, parameters) {
+        const params = parameters.join(',');
+        let camerasGuids = [];
+        const requestOptions = this.getRequestOptions('GET');
+        const allCameras = [];
+        const chunkSize = 10;
+        while (guids.length > 0) {
+            const chunk = guids.slice(0, chunkSize);
+            guids.splice(0, chunkSize);
+            camerasGuids = chunk.map((item) => item.Guid);
+            const camerasDetailsUrl = [];
+            for (const guid of camerasGuids) {
+                camerasDetailsUrl.push(`entity=${guid},${params}`);
+            }
+            const res = await fetch(`${this.baseUrl}/${GET_CAMERAS_DETAILS_URL}${camerasDetailsUrl.join(',')}`, requestOptions);
+            if (!res.ok) {
+                throw new Error(await (0, utils_1.responseStringify)(res));
+            }
+            const data = exports.cameraDetailsResponseSchema.parse(await res.json());
+            const resultArray = Array.isArray(data.Rsp.Result) ? data.Rsp.Result : [data.Rsp.Result];
+            allCameras.push(...resultArray);
+        }
+        return allCameras;
+    }
+    async sendBookmark(guids, bookmarkText) {
+        const cameraEntitiesUrl = [];
+        const timeStamp = this.getTimeStamp();
+        const requestOptions = this.getRequestOptions('POST');
+        for (const guid of guids) {
+            cameraEntitiesUrl.push(`${ACTION}(${guid},${timeStamp},${bookmarkText})`);
+        }
+        const res = await fetch(`${this.baseUrl}/action?q=${cameraEntitiesUrl.join(',')}`, requestOptions);
+        if (!res.ok) {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+        return res;
+    }
+    getRequestOptions(method) {
+        return {
+            method,
+            headers: new Headers({
+                Authorization: `Basic ${this.credentials}`,
+                Accept: 'text/json',
+            }),
+            redirect: 'follow',
+        };
+    }
+    getTimeStamp() {
+        const date = new Date();
+        const year = date.getUTCFullYear();
+        const month = (0, utils_1.pad)(date.getUTCMonth() + 1, 2);
+        const day = (0, utils_1.pad)(date.getUTCDate(), 2);
+        const hours = (0, utils_1.pad)(date.getUTCHours(), 2);
+        const minutes = (0, utils_1.pad)(date.getUTCMinutes(), 2);
+        const seconds = (0, utils_1.pad)(date.getUTCSeconds(), 2);
+        const miliSeconds = (0, utils_1.pad)(date.getUTCMilliseconds(), 2);
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${miliSeconds}Z`;
+    }
+}
+exports.GenetecAgent = GenetecAgent;

package/cjs/index.d.ts

@@ -0,0 +1,18 @@
+export * from './internal/types';
+export * from './internal/constants';
+export * from './internal/utils';
+export * from './internal/versionCompare';
+export * from './types/common';
+export { CamSwitcherAPI } from './CamSwitcherAPI';
+export { CamSwitcherEvents } from './CamSwitcherEvents';
+export { VapixAPI } from './VapixAPI';
+export { CamOverlayAPI } from './CamOverlayAPI';
+export { CamScripterAPI } from './CamScripterAPI';
+export { CamStreamerAPI } from './CamStreamerAPI';
+export { PlaneTrackerAPI } from './PlaneTrackerAPI';
+export * from './types/CamSwitcherEvents';
+export * from './types/CamSwitcherAPI';
+export * from './types/VapixAPI';
+export * from './types/CamOverlayAPI';
+export * from './models/CamOverlayAPI';
+export * from './types/PlaneTrackerAPI';

package/cjs/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaneTrackerAPI = exports.CamStreamerAPI = exports.CamScripterAPI = exports.CamOverlayAPI = exports.VapixAPI = exports.CamSwitcherEvents = exports.CamSwitcherAPI = void 0;
+__exportStar(require("./internal/types"), exports);
+__exportStar(require("./internal/constants"), exports);
+__exportStar(require("./internal/utils"), exports);
+__exportStar(require("./internal/versionCompare"), exports);
+__exportStar(require("./types/common"), exports);
+var CamSwitcherAPI_1 = require("./CamSwitcherAPI");
+Object.defineProperty(exports, "CamSwitcherAPI", { enumerable: true, get: function () { return CamSwitcherAPI_1.CamSwitcherAPI; } });
+var CamSwitcherEvents_1 = require("./CamSwitcherEvents");
+Object.defineProperty(exports, "CamSwitcherEvents", { enumerable: true, get: function () { return CamSwitcherEvents_1.CamSwitcherEvents; } });
+var VapixAPI_1 = require("./VapixAPI");
+Object.defineProperty(exports, "VapixAPI", { enumerable: true, get: function () { return VapixAPI_1.VapixAPI; } });
+var CamOverlayAPI_1 = require("./CamOverlayAPI");
+Object.defineProperty(exports, "CamOverlayAPI", { enumerable: true, get: function () { return CamOverlayAPI_1.CamOverlayAPI; } });
+var CamScripterAPI_1 = require("./CamScripterAPI");
+Object.defineProperty(exports, "CamScripterAPI", { enumerable: true, get: function () { return CamScripterAPI_1.CamScripterAPI; } });
+var CamStreamerAPI_1 = require("./CamStreamerAPI");
+Object.defineProperty(exports, "CamStreamerAPI", { enumerable: true, get: function () { return CamStreamerAPI_1.CamStreamerAPI; } });
+var PlaneTrackerAPI_1 = require("./PlaneTrackerAPI");
+Object.defineProperty(exports, "PlaneTrackerAPI", { enumerable: true, get: function () { return PlaneTrackerAPI_1.PlaneTrackerAPI; } });
+__exportStar(require("./types/CamSwitcherEvents"), exports);
+__exportStar(require("./types/CamSwitcherAPI"), exports);
+__exportStar(require("./types/VapixAPI"), exports);
+__exportStar(require("./types/CamOverlayAPI"), exports);
+__exportStar(require("./models/CamOverlayAPI"), exports);
+__exportStar(require("./types/PlaneTrackerAPI"), exports);

package/cjs/internal/Digest.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Digest = void 0;
+const crypto = require("crypto");
+class Digest {
+    nonceCount = 1;
+    getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {
+        const digestItems = {};
+        const digestArr = wwwAuthenticateHeader.substring(wwwAuthenticateHeader.indexOf('Digest') + 6).split(',');
+        for (const arg of digestArr) {
+            const pos = arg.indexOf('=');
+            const key = arg.substring(0, pos).trim();
+            const value = arg.substring(pos + 1).trim();
+            digestItems[key] = value.replace(/"/g, '');
+        }
+        const HA1 = crypto.createHash('md5').update(`${user}:${digestItems['realm']}:${pass}`).digest('hex');
+        const HA2 = crypto.createHash('md5').update(`${method}:${uri}`).digest('hex');
+        const ncValue = ('00000000' + this.nonceCount.toString(16)).slice(-8);
+        let response;
+        if (digestItems['qop'] !== undefined) {
+            response = crypto
+                .createHash('md5')
+                .update(`${HA1}:${digestItems['nonce']}:${ncValue}:162d50aa594e9648:auth:${HA2}`)
+                .digest('hex');
+        }
+        else {
+            response = crypto.createHash('md5').update(`${HA1}:${digestItems['nonce']}:${HA2}`).digest('hex');
+        }
+        let header = 'Digest ' +
+            `username="${user}",` +
+            `realm="${digestItems['realm']}",` +
+            `nonce="${digestItems['nonce']}",` +
+            `uri="${uri}",` +
+            `response="${response}"`;
+        if (digestItems['qop'] !== undefined) {
+            header += `,qop=auth,nc=${ncValue},cnonce="162d50aa594e9648"`;
+        }
+        this.nonceCount++;
+        return header;
+    }
+}
+exports.Digest = Digest;

package/cjs/internal/ProxyClient.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { IClient, TResponse } from './types';
+import { TProxyParam } from '../types/common';
+export declare class ProxyClient<Client extends IClient<TResponse> = IClient<TResponse>> {
+    client: Client;
+    getProxyUrl: () => string;
+    constructor(client: Client, getProxyUrl: () => string);
+    get: (proxy: TProxyParam, url: string, parameters?: import("./types").TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<TResponse>;
+    post: (proxy: TProxyParam, url: string, data: string | Buffer | FormData, parameters?: import("./types").TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<TResponse>;
+    private getReal;
+}

package/cjs/internal/ProxyClient.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyClient = void 0;
+const utils_1 = require("./utils");
+class ProxyClient {
+    client;
+    getProxyUrl;
+    constructor(client, getProxyUrl) {
+        this.client = client;
+        this.getProxyUrl = getProxyUrl;
+    }
+    get = (proxy, ...args) => {
+        const [path, parameters, headers] = args;
+        const url = (0, utils_1.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 = (0, utils_1.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': proxy.pass,
+                    'x-target-camera-user': proxy.user,
+                },
+            };
+        }
+        return {
+            realUrl: url,
+            realHeaders: headers,
+        };
+    };
+}
+exports.ProxyClient = ProxyClient;

package/cjs/internal/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = void 0;
+exports.FIRMWARE_WITH_BITRATE_MODES_SUPPORT = '11.11.73';

package/cjs/internal/transformers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSnakeCaseDeep = exports.toSnakeCase = exports.toCamelCaseDeep = exports.toCamelCase = void 0;
+const lodash_1 = require("lodash");
+const toCamelCase = (o) => (0, lodash_1.mapKeys)(o, camelCaseKey);
+exports.toCamelCase = toCamelCase;
+const toCamelCaseDeep = (o) => {
+    return mapKeysDeep(o, camelCaseKey);
+};
+exports.toCamelCaseDeep = toCamelCaseDeep;
+const toSnakeCase = (o) => (0, lodash_1.mapKeys)(o, snakeCaseKey);
+exports.toSnakeCase = toSnakeCase;
+const toSnakeCaseDeep = (o) => {
+    return mapKeysDeep(o, snakeCaseKey);
+};
+exports.toSnakeCaseDeep = toSnakeCaseDeep;
+const camelCaseKey = (_, key) => (0, lodash_1.camelCase)(key);
+const snakeCaseKey = (_, key) => (0, lodash_1.snakeCase)(key);
+const mapKeysDeep = (obj, cb) => {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => {
+            return mapKeysDeep(item, cb);
+        });
+    }
+    if (typeof obj !== 'object' || (0, lodash_1.isPlainObject)(obj) === false) {
+        return obj;
+    }
+    const result = (0, lodash_1.mapKeys)(obj, cb);
+    return (0, lodash_1.mapValues)(result, (value) => {
+        return mapKeysDeep(value, cb);
+    });
+};

package/cjs/internal/types.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { Response as UndiciResponse } from 'undici';
+export type Options = {
+    ip?: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+    tlsInsecure?: boolean;
+};
+export type HttpOptions = Options & {
+    keepAlive?: boolean;
+};
+export type WsOptions = Options;
+export type TParameters = Record<string, string | number | boolean | null | undefined>;
+export type TResponse = Response | UndiciResponse;
+export type TGetParams = [url: string, parameters?: TParameters, headers?: Record<string, string>];
+export type TPostParams = [
+    url: string,
+    data: string | Buffer | FormData,
+    parameters?: TParameters,
+    headers?: Record<string, string>
+];
+export interface IClient<TRes extends TResponse> {
+    get: (...params: TGetParams) => Promise<TRes>;
+    post: (...params: TPostParams) => Promise<TRes>;
+}
+export type TBlobResponse<Client extends IClient<TResponse>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
+export interface IWebsocket<Event extends {
+    readonly data: string;
+}> {
+    destroy: () => void;
+    onmessage: null | ((event: Event) => void);
+    send: (data: string) => void;
+}

package/cjs/internal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{internal → cjs/internal}/utils.d.ts

@@ -1,5 +1,5 @@
 import { TPlaylistPlayType } from '../types/CamSwitcherAPI';
-import { TParameters } from './common';
+import { IClient, Options, TParameters, TResponse } from './types';
 export declare const addParametersToPath: (path: string, params?: TParameters) => string;
 export declare const paramToUrl: (params?: TParameters) => string;
 export declare const arrayToUrl: (arr: string | string[]) => string;
@@ -9,3 +9,7 @@ export declare const isClip: (id?: string) => boolean;
 export declare const isTracker: (id?: string) => boolean;
 export declare const isPlaylist: (id?: string) => boolean;
 export declare const isLoopPlayType: (playType: TPlaylistPlayType) => boolean;
+export declare function isClient(arg?: Options | IClient<TResponse>): arg is IClient<TResponse>;
+export declare function responseStringify(res: TResponse): Promise<string>;
+export declare function pad(num: number, size: number): string;
+export declare function isNullish<T>(value: T | undefined | null): value is undefined | null;

package/cjs/internal/utils.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullish = exports.pad = exports.responseStringify = exports.isClient = exports.isLoopPlayType = exports.isPlaylist = exports.isTracker = exports.isClip = exports.isStream = exports.isCamera = exports.arrayToUrl = exports.paramToUrl = exports.addParametersToPath = void 0;
+const addParametersToPath = (path, params) => {
+    if (params === undefined || Object.keys(params).length === 0) {
+        return path;
+    }
+    const joinChar = path.indexOf('?') === -1 ? '?' : '&';
+    return `${path}${joinChar}${(0, exports.paramToUrl)(params)}`;
+};
+exports.addParametersToPath = addParametersToPath;
+const paramToUrl = (params) => {
+    if (params === undefined) {
+        return '';
+    }
+    let output = '';
+    for (const key in params) {
+        const value = params[key];
+        if (isNullish(value)) {
+            continue;
+        }
+        output += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`;
+    }
+    return output.slice(0, output.length - 1);
+};
+exports.paramToUrl = paramToUrl;
+const arrayToUrl = (arr) => {
+    if (Array.isArray(arr)) {
+        return arr.join(',');
+    }
+    return arr;
+};
+exports.arrayToUrl = arrayToUrl;
+const isCamera = (id) => id?.charAt(0) === 'c';
+exports.isCamera = isCamera;
+const isStream = (id) => id?.charAt(0) === 'c' || id?.charAt(0) === 'a';
+exports.isStream = isStream;
+const isClip = (id) => id?.charAt(0) === 's';
+exports.isClip = isClip;
+const isTracker = (id) => id?.charAt(0) === 't';
+exports.isTracker = isTracker;
+const isPlaylist = (id) => id?.charAt(0) === 'p';
+exports.isPlaylist = isPlaylist;
+const isLoopPlayType = (playType) => playType.includes('LOOP');
+exports.isLoopPlayType = isLoopPlayType;
+function isClient(arg = {}) {
+    return 'get' in arg && 'post' in arg;
+}
+exports.isClient = isClient;
+async function responseStringify(res) {
+    return JSON.stringify({
+        status: res.status,
+        body: await res.text(),
+    });
+}
+exports.responseStringify = responseStringify;
+function pad(num, size) {
+    const sign = Math.sign(num) === -1 ? '-' : '';
+    return (sign +
+        new Array(size)
+            .concat([Math.abs(num)])
+            .join('0')
+            .slice(-size));
+}
+exports.pad = pad;
+function isNullish(value) {
+    return value === null || value === undefined;
+}
+exports.isNullish = isNullish;

package/{internal → cjs/internal}/versionCompare.d.ts

@@ -1,6 +1,6 @@
 export declare const assertVersionString: (s: string, msg?: string) => void;
 export declare const isFirmwareVersionAtLeast: (version: string, compareVersion: string) => boolean;
 export declare const isVersionAtLeast: (version: string, compareVersion: string) => boolean;
-export declare const firmwareVersionCompare: (a: string, b: string) => 1 | -1 | 0;
-export declare const versionCompare: (a: string, b: string) => 1 | -1 | 0;
+export declare const firmwareVersionCompare: (a: string, b: string) => 0 | 1 | -1;
+export declare const versionCompare: (a: string, b: string) => 0 | 1 | -1;
 export declare const fixVersionToDots: (version: string) => string;

package/cjs/internal/versionCompare.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixVersionToDots = exports.versionCompare = exports.firmwareVersionCompare = exports.isVersionAtLeast = exports.isFirmwareVersionAtLeast = exports.assertVersionString = void 0;
+const assertVersionString = (s, msg) => {
+    if (!s.match(/^[0-9]+(\.[0-9]+){1,3}$/)) {
+        throw new Error(msg ?? `${s} is not a version`);
+    }
+};
+exports.assertVersionString = assertVersionString;
+const isFirmwareVersionAtLeast = (version, compareVersion) => {
+    return (0, exports.firmwareVersionCompare)(version, compareVersion) >= 0;
+};
+exports.isFirmwareVersionAtLeast = isFirmwareVersionAtLeast;
+const isVersionAtLeast = (version, compareVersion) => {
+    return (0, exports.versionCompare)(version, compareVersion) >= 0;
+};
+exports.isVersionAtLeast = isVersionAtLeast;
+const firmwareVersionCompare = (a, b) => {
+    const versions = [a, b];
+    const matchBetaFirmwareVersion = (x) => /^CVP-/.test(x) || /^[0-9]+.*beta/.test(x);
+    if (versions.every(matchBetaFirmwareVersion)) {
+        return 0;
+    }
+    if (matchBetaFirmwareVersion(a)) {
+        return -1;
+    }
+    if (matchBetaFirmwareVersion(b)) {
+        return 1;
+    }
+    return (0, exports.versionCompare)(a, b);
+};
+exports.firmwareVersionCompare = firmwareVersionCompare;
+const versionCompare = (a, b) => {
+    (0, exports.assertVersionString)(a);
+    (0, exports.assertVersionString)(b);
+    const aSplit = parseVersion(a);
+    const bSplit = parseVersion(b);
+    for (let i = 0; i < aSplit.length; i++) {
+        if (aSplit[i] !== bSplit[i]) {
+            return aSplit[i] < bSplit[i] ? -1 : 1;
+        }
+    }
+    return 0;
+};
+exports.versionCompare = versionCompare;
+const fixVersionToDots = (version) => version.replaceAll('-', '.');
+exports.fixVersionToDots = fixVersionToDots;
+const parseVersion = (version) => {
+    (0, exports.assertVersionString)(version);
+    const parsed = version.split('.').map((s) => parseInt(s));
+    parsed.push(...Array(4 - parsed.length).fill(0));
+    return parsed;
+};