@lakutata/monitor 3.0.0-beta.0

package/dist/cjs/monitor/MemoryMonitor.d.ts

@@ -0,0 +1,61 @@
+import { Component } from '@lakutata/core';
+import { IMonitor } from './interfaces/IMonitor.js';
+import { IMemoryMonitorStatistics } from './interfaces/IMemoryMonitorStatistics.js';
+/**
+ * The memory monitor: measures the memory of the process, in bytes, with `process.memoryUsage()`: its resident set
+ * (the physical memory it occupies, `rss`), its V8 heap (`heapTotal` reserved, `heapUsed` occupied by the JavaScript
+ * objects) and its external memory (the C++ objects bound to JavaScript ones, the `Buffer`s included). It takes a
+ * sample when it is created then every second, and keeps the statistics of every sample since it was created or last
+ * {@link MemoryMonitor.reset}: the minimum, the maximum, the mean and percentiles, in constant memory.
+ *
+ * Declare it in the `components` of the application (`{class: MemoryMonitor}`) and get it with `@Inject` or
+ * `getObject()`; it is a singleton. It starts sampling when it is created: list it in `bootstrap` to measure from the
+ * launch. Its timer does not keep the process alive, and stops when the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {MemoryMonitor, type IMemoryMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'memory.app',
+ *         name: 'Memory',
+ *         components: {
+ *             memory: {class: MemoryMonitor}
+ *         },
+ *         bootstrap: ['memory']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const memory: MemoryMonitor = await app.getObject('memory')
+ *         setInterval((): void => {
+ *             const statistics: IMemoryMonitorStatistics = memory.statistics
+ *             const megabytes = (bytes: number): string => (bytes / 1048576).toFixed(1)
+ *             console.log(`RSS ${megabytes(statistics.physicalUsed)} MB (${statistics.physicalUsage}% of the host), heap ${statistics.heapUsage}% used`)
+ *         }, 60000)
+ *     })
+ * ```
+ */
+export declare class MemoryMonitor extends Component implements IMonitor<IMemoryMonitorStatistics> {
+    #private;
+    /**
+     * The memory statistics, computed at each read: the latest sample (`physicalUsed`, `heapTotal`, `heapUsed`,
+     * `externalUsed`, in bytes, and the percentages `physicalUsage` and `heapUsage`, rounded to 2 decimals), the host's
+     * total memory, and the minimum, maximum, mean (rounded to 2 decimals) and percentiles of the samples since the
+     * monitor was created or reset. The percentiles are approximate (3 significant digits). The statistics of the
+     * samples are 0 after a reset until the next sample.
+     */
+    get statistics(): IMemoryMonitorStatistics;
+    /**
+     * Take a sample of the memory of the process: it becomes the latest usage and is added to the statistics. Called
+     * when the monitor is created, then every second.
+     * @protected
+     */
+    protected sampleMemoryUsage(): void;
+    protected init(): Promise<void>;
+    protected destroy(): Promise<void>;
+    /**
+     * Forget the samples: the minimum, maximum, mean and percentiles are 0 until the next sample, then cover the samples
+     * taken since. The latest usage is kept.
+     */
+    reset(): void;
+}

package/dist/cjs/monitor/MemoryMonitor.js

@@ -0,0 +1,152 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMonitor = void 0;
+const os = __importStar(require("node:os"));
+const core_1 = require("@lakutata/core");
+const Samples_js_1 = require("./lib/Samples.js");
+/**
+ * The memory monitor: measures the memory of the process, in bytes, with `process.memoryUsage()`: its resident set
+ * (the physical memory it occupies, `rss`), its V8 heap (`heapTotal` reserved, `heapUsed` occupied by the JavaScript
+ * objects) and its external memory (the C++ objects bound to JavaScript ones, the `Buffer`s included). It takes a
+ * sample when it is created then every second, and keeps the statistics of every sample since it was created or last
+ * {@link MemoryMonitor.reset}: the minimum, the maximum, the mean and percentiles, in constant memory.
+ *
+ * Declare it in the `components` of the application (`{class: MemoryMonitor}`) and get it with `@Inject` or
+ * `getObject()`; it is a singleton. It starts sampling when it is created: list it in `bootstrap` to measure from the
+ * launch. Its timer does not keep the process alive, and stops when the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {MemoryMonitor, type IMemoryMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'memory.app',
+ *         name: 'Memory',
+ *         components: {
+ *             memory: {class: MemoryMonitor}
+ *         },
+ *         bootstrap: ['memory']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const memory: MemoryMonitor = await app.getObject('memory')
+ *         setInterval((): void => {
+ *             const statistics: IMemoryMonitorStatistics = memory.statistics
+ *             const megabytes = (bytes: number): string => (bytes / 1048576).toFixed(1)
+ *             console.log(`RSS ${megabytes(statistics.physicalUsed)} MB (${statistics.physicalUsage}% of the host), heap ${statistics.heapUsage}% used`)
+ *         }, 60000)
+ *     })
+ * ```
+ */
+class MemoryMonitor extends core_1.Component {
+    #fractionDigits = 2;
+    #intervalDelay = 1000;
+    #totalMemorySize = os.totalmem();
+    #physical = new Samples_js_1.Samples();
+    #heap = new Samples_js_1.Samples();
+    #external = new Samples_js_1.Samples();
+    #latest = process.memoryUsage();
+    #sampleInterval;
+    /**
+     * The memory statistics, computed at each read: the latest sample (`physicalUsed`, `heapTotal`, `heapUsed`,
+     * `externalUsed`, in bytes, and the percentages `physicalUsage` and `heapUsage`, rounded to 2 decimals), the host's
+     * total memory, and the minimum, maximum, mean (rounded to 2 decimals) and percentiles of the samples since the
+     * monitor was created or reset. The percentiles are approximate (3 significant digits). The statistics of the
+     * samples are 0 after a reset until the next sample.
+     */
+    get statistics() {
+        const latest = this.#latest;
+        return {
+            physicalTotal: this.#totalMemorySize,
+            physicalUsed: latest.rss,
+            physicalUsage: (0, Samples_js_1.round)(latest.rss / this.#totalMemorySize * 100, this.#fractionDigits),
+            physicalUsedMin: this.#physical.min,
+            physicalUsedMax: this.#physical.max,
+            physicalUsedAvg: (0, Samples_js_1.round)(this.#physical.mean, this.#fractionDigits),
+            physicalUsedP50: this.#physical.percentile(50),
+            physicalUsedP90: this.#physical.percentile(90),
+            physicalUsedP95: this.#physical.percentile(95),
+            physicalUsedP99: this.#physical.percentile(99),
+            heapTotal: latest.heapTotal,
+            heapUsed: latest.heapUsed,
+            heapUsage: (0, Samples_js_1.round)(latest.heapTotal ? latest.heapUsed / latest.heapTotal * 100 : 0, this.#fractionDigits),
+            heapUsedMin: this.#heap.min,
+            heapUsedMax: this.#heap.max,
+            heapUsedAvg: (0, Samples_js_1.round)(this.#heap.mean, this.#fractionDigits),
+            heapUsedP50: this.#heap.percentile(50),
+            heapUsedP90: this.#heap.percentile(90),
+            heapUsedP95: this.#heap.percentile(95),
+            heapUsedP99: this.#heap.percentile(99),
+            externalUsed: latest.external,
+            externalUsedMin: this.#external.min,
+            externalUsedMax: this.#external.max,
+            externalUsedAvg: (0, Samples_js_1.round)(this.#external.mean, this.#fractionDigits),
+            externalUsedP50: this.#external.percentile(50),
+            externalUsedP90: this.#external.percentile(90),
+            externalUsedP95: this.#external.percentile(95),
+            externalUsedP99: this.#external.percentile(99)
+        };
+    }
+    /**
+     * Take a sample of the memory of the process: it becomes the latest usage and is added to the statistics. Called
+     * when the monitor is created, then every second.
+     * @protected
+     */
+    sampleMemoryUsage() {
+        const usage = process.memoryUsage();
+        this.#latest = usage;
+        this.#physical.record(usage.rss);
+        this.#heap.record(usage.heapUsed);
+        this.#external.record(usage.external);
+    }
+    async init() {
+        this.sampleMemoryUsage();
+        this.#sampleInterval = setInterval(() => this.sampleMemoryUsage(), this.#intervalDelay).unref();
+    }
+    async destroy() {
+        clearInterval(this.#sampleInterval);
+    }
+    /**
+     * Forget the samples: the minimum, maximum, mean and percentiles are 0 until the next sample, then cover the samples
+     * taken since. The latest usage is kept.
+     */
+    reset() {
+        this.#physical.reset();
+        this.#heap.reset();
+        this.#external.reset();
+    }
+}
+exports.MemoryMonitor = MemoryMonitor;

package/dist/cjs/monitor/interfaces/ICpuMonitorStatistics.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The statistics of a {@link CpuMonitor}: the CPU usage of the process in percent of one core (100 is one core fully
+ * busy; above 100 with several cores busy), each sample the average over one second, rounded to 5 decimals. The
+ * minimum, maximum, mean and percentiles cover the samples since the monitor was created or reset; the percentiles are
+ * approximate (3 significant digits). All 0 before the first sample.
+ */
+export interface ICpuMonitorStatistics {
+    /**
+     * The CPU usage over the latest second (the latest sample), in percent of one core.
+     */
+    usage: number;
+    /**
+     * The lowest sample, in percent of one core.
+     */
+    usageMin: number;
+    /**
+     * The highest sample, in percent of one core.
+     */
+    usageMax: number;
+    /**
+     * The mean of the samples, in percent of one core.
+     */
+    usageAvg: number;
+    /**
+     * The median sample (50% of the seconds used less), in percent of one core.
+     */
+    usageP50: number;
+    /**
+     * The 90th percentile of the samples (90% of the seconds used less), in percent of one core.
+     */
+    usageP90: number;
+    /**
+     * The 95th percentile of the samples, in percent of one core.
+     */
+    usageP95: number;
+    /**
+     * The 99th percentile of the samples, in percent of one core.
+     */
+    usageP99: number;
+}

package/dist/cjs/monitor/interfaces/ICpuMonitorStatistics.js

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

package/dist/cjs/monitor/interfaces/IEventLoopMonitorStatistics.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The statistics of an {@link EventLoopMonitor} since it was created or reset: the event loop delays, in milliseconds
+ * (measured by a timer due every millisecond: about 1 ms when the loop is idle, more while synchronous work blocks
+ * it; all 0 before the first measure), and the loop utilization, in percent. The percentiles
+ * come from Node's histogram.
+ */
+export interface IEventLoopMonitorStatistics {
+    /**
+     * The shortest delay, in milliseconds.
+     */
+    min: number;
+    /**
+     * The longest delay, in milliseconds: the longest the loop was blocked.
+     */
+    max: number;
+    /**
+     * The mean delay, in milliseconds.
+     */
+    avg: number;
+    /**
+     * The standard deviation of the delays, in milliseconds.
+     */
+    stdDev: number;
+    /**
+     * The median delay, in milliseconds.
+     */
+    p50: number;
+    /**
+     * The 90th percentile of the delays (90% were shorter), in milliseconds.
+     */
+    p90: number;
+    /**
+     * The 95th percentile of the delays, in milliseconds.
+     */
+    p95: number;
+    /**
+     * The 99th percentile of the delays, in milliseconds: the usual pick for an alert.
+     */
+    p99: number;
+    /**
+     * The share of the time the event loop was busy running code rather than waiting for I/O, in percent (0 to
+     * 100), since the monitor was created or reset. Not rounded.
+     */
+    utilRate: number;
+}

package/dist/cjs/monitor/interfaces/IEventLoopMonitorStatistics.js

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

package/dist/cjs/monitor/interfaces/IHttpRequestMonitorStatistics.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The statistics of an {@link HttpRequestMonitor} since it was created or reset: the number of HTTP requests received
+ * and their durations, from their arrival to the end of their response, in milliseconds rounded to 2 decimals. The
+ * percentiles are approximate (3 significant digits). All 0 before the first request.
+ */
+export interface IHttpRequestMonitorStatistics {
+    /**
+     * The number of requests received whose response ended.
+     */
+    count: number;
+    /**
+     * The shortest request, in milliseconds.
+     */
+    min: number;
+    /**
+     * The longest request, in milliseconds.
+     */
+    max: number;
+    /**
+     * The mean duration, in milliseconds.
+     */
+    avg: number;
+    /**
+     * The standard deviation of the durations, in milliseconds.
+     */
+    stdDev: number;
+    /**
+     * The median duration, in milliseconds.
+     */
+    p50: number;
+    /**
+     * The 90th percentile of the durations (90% of the requests were faster), in milliseconds.
+     */
+    p90: number;
+    /**
+     * The 95th percentile of the durations, in milliseconds.
+     */
+    p95: number;
+    /**
+     * The 99th percentile of the durations, in milliseconds.
+     */
+    p99: number;
+}

package/dist/cjs/monitor/interfaces/IHttpRequestMonitorStatistics.js

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

package/dist/cjs/monitor/interfaces/IMemoryMonitorStatistics.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The statistics of a {@link MemoryMonitor}, in bytes unless stated: the latest sample of the process memory
+ * (`process.memoryUsage()`), and the minimum, maximum, mean and percentiles of the samples taken every second since
+ * the monitor was created or reset (0 after a reset until the next sample). The percentiles are approximate (3
+ * significant digits).
+ */
+export interface IMemoryMonitorStatistics {
+    /**
+     * The total physical memory of the host (`os.totalmem()`), in bytes; under a container, the host's,
+     * not the container's limit.
+     */
+    physicalTotal: number;
+    /**
+     * The resident set size of the process (`rss`) at the latest sample: the physical memory it occupies, in
+     * bytes.
+     */
+    physicalUsed: number;
+    /**
+     * `physicalUsed` as a percentage of `physicalTotal`, rounded to 2 decimals.
+     */
+    physicalUsage: number;
+    /**
+     * The lowest resident set size sampled, in bytes.
+     */
+    physicalUsedMin: number;
+    /**
+     * The highest resident set size sampled, in bytes.
+     */
+    physicalUsedMax: number;
+    /**
+     * The mean resident set size of the samples, in bytes, rounded to 2 decimals.
+     */
+    physicalUsedAvg: number;
+    /**
+     * The median resident set size of the samples, in bytes.
+     */
+    physicalUsedP50: number;
+    /**
+     * The 90th percentile of the resident set size samples, in bytes.
+     */
+    physicalUsedP90: number;
+    /**
+     * The 95th percentile of the resident set size samples, in bytes.
+     */
+    physicalUsedP95: number;
+    /**
+     * The 99th percentile of the resident set size samples, in bytes.
+     */
+    physicalUsedP99: number;
+    /**
+     * The size of the V8 heap reserved by the process at the latest sample, in bytes.
+     */
+    heapTotal: number;
+    /**
+     * The part of the V8 heap occupied by JavaScript objects at the latest sample, in bytes.
+     */
+    heapUsed: number;
+    /**
+     * `heapUsed` as a percentage of `heapTotal`, rounded to 2 decimals. V8 grows the heap as needed, so a
+     * high value alone is not a leak: a leak shows as `heapUsedMin` rising from one reset period to the next.
+     */
+    heapUsage: number;
+    /**
+     * The lowest used heap sampled, in bytes.
+     */
+    heapUsedMin: number;
+    /**
+     * The highest used heap sampled, in bytes.
+     */
+    heapUsedMax: number;
+    /**
+     * The mean used heap of the samples, in bytes, rounded to 2 decimals.
+     */
+    heapUsedAvg: number;
+    /**
+     * The median used heap of the samples, in bytes.
+     */
+    heapUsedP50: number;
+    /**
+     * The 90th percentile of the used heap samples, in bytes.
+     */
+    heapUsedP90: number;
+    /**
+     * The 95th percentile of the used heap samples, in bytes.
+     */
+    heapUsedP95: number;
+    /**
+     * The 99th percentile of the used heap samples, in bytes.
+     */
+    heapUsedP99: number;
+    /**
+     * The memory of the C++ objects bound to JavaScript objects (the `Buffer`s included) at the latest
+     * sample, in bytes.
+     */
+    externalUsed: number;
+    /**
+     * The lowest external memory sampled, in bytes.
+     */
+    externalUsedMin: number;
+    /**
+     * The highest external memory sampled, in bytes.
+     */
+    externalUsedMax: number;
+    /**
+     * The mean external memory of the samples, in bytes, rounded to 2 decimals.
+     */
+    externalUsedAvg: number;
+    /**
+     * The median external memory of the samples, in bytes.
+     */
+    externalUsedP50: number;
+    /**
+     * The 90th percentile of the external memory samples, in bytes.
+     */
+    externalUsedP90: number;
+    /**
+     * The 95th percentile of the external memory samples, in bytes.
+     */
+    externalUsedP95: number;
+    /**
+     * The 99th percentile of the external memory samples, in bytes.
+     */
+    externalUsedP99: number;
+}

package/dist/cjs/monitor/interfaces/IMemoryMonitorStatistics.js

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

package/dist/cjs/monitor/interfaces/IMonitor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A monitor: a component exposing the statistics of what it measures.
+ * @typeParam T The type of its statistics.
+ */
+export interface IMonitor<T> {
+    /**
+     * The statistics of the measures, computed at each read.
+     */
+    statistics: T;
+}

package/dist/cjs/monitor/interfaces/IMonitor.js

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

package/dist/cjs/monitor/lib/Samples.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The statistics of the samples of a measure, in a constant memory: the latest value, the minimum, the maximum, the
+ * mean and the standard deviation are exact, the percentiles come from a histogram (3 significant digits)
+ */
+export declare class Samples {
+    #private;
+    protected readonly scale: number;
+    /**
+     * @param scale the factor of the precision of the percentiles (100 keeps 2 decimals)
+     */
+    constructor(scale?: number);
+    /**
+     * Record a sample (a negative value is recorded as 0)
+     * @param value
+     */
+    record(value: number): void;
+    /**
+     * The number of samples
+     */
+    get count(): number;
+    /**
+     * The latest sample, 0 without sample
+     */
+    get latest(): number;
+    /**
+     * The minimum, 0 without sample
+     */
+    get min(): number;
+    /**
+     * The maximum, 0 without sample
+     */
+    get max(): number;
+    /**
+     * The mean, 0 without sample
+     */
+    get mean(): number;
+    /**
+     * The (population) standard deviation, 0 without sample
+     */
+    get stdDev(): number;
+    /**
+     * A percentile, 0 without sample
+     * @param percentile from 0 to 100
+     */
+    percentile(percentile: number): number;
+    /**
+     * Forget the samples
+     */
+    reset(): void;
+}
+/**
+ * Round a number to a number of decimals
+ * @param value
+ * @param fractionDigits
+ * @constructor
+ */
+export declare function round(value: number, fractionDigits: number): number;

package/dist/cjs/monitor/lib/Samples.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Samples = void 0;
+exports.round = round;
+const node_perf_hooks_1 = require("node:perf_hooks");
+/**
+ * The statistics of the samples of a measure, in a constant memory: the latest value, the minimum, the maximum, the
+ * mean and the standard deviation are exact, the percentiles come from a histogram (3 significant digits)
+ */
+class Samples {
+    /**
+     * The histogram of the percentiles: it records integers from 1, so a value is recorded multiplied by the scale,
+     * plus 1 (a value may be 0)
+     */
+    #histogram = (0, node_perf_hooks_1.createHistogram)();
+    #count = 0;
+    #latest = 0;
+    #min = 0;
+    #max = 0;
+    #mean = 0;
+    //The sum of the squares of the differences from the mean (Welford's algorithm)
+    #m2 = 0;
+    /**
+     * @param scale the factor of the precision of the percentiles (100 keeps 2 decimals)
+     */
+    constructor(scale = 1) {
+        this.scale = scale;
+    }
+    /**
+     * Record a sample (a negative value is recorded as 0)
+     * @param value
+     */
+    record(value) {
+        const sample = Number.isFinite(value) && value > 0 ? value : 0;
+        this.#histogram.record(Math.round(sample * this.scale) + 1);
+        this.#count++;
+        this.#latest = sample;
+        if (this.#count === 1) {
+            this.#min = sample;
+            this.#max = sample;
+        }
+        else {
+            if (sample < this.#min)
+                this.#min = sample;
+            if (sample > this.#max)
+                this.#max = sample;
+        }
+        const delta = sample - this.#mean;
+        this.#mean += delta / this.#count;
+        this.#m2 += delta * (sample - this.#mean);
+    }
+    /**
+     * The number of samples
+     */
+    get count() {
+        return this.#count;
+    }
+    /**
+     * The latest sample, 0 without sample
+     */
+    get latest() {
+        return this.#latest;
+    }
+    /**
+     * The minimum, 0 without sample
+     */
+    get min() {
+        return this.#min;
+    }
+    /**
+     * The maximum, 0 without sample
+     */
+    get max() {
+        return this.#max;
+    }
+    /**
+     * The mean, 0 without sample
+     */
+    get mean() {
+        return this.#mean;
+    }
+    /**
+     * The (population) standard deviation, 0 without sample
+     */
+    get stdDev() {
+        return this.#count ? Math.sqrt(this.#m2 / this.#count) : 0;
+    }
+    /**
+     * A percentile, 0 without sample
+     * @param percentile from 0 to 100
+     */
+    percentile(percentile) {
+        if (!this.#count)
+            return 0;
+        return Math.min(Math.max((this.#histogram.percentile(percentile) - 1) / this.scale, this.#min), this.#max);
+    }
+    /**
+     * Forget the samples
+     */
+    reset() {
+        this.#histogram.reset();
+        this.#count = 0;
+        this.#latest = 0;
+        this.#min = 0;
+        this.#max = 0;
+        this.#mean = 0;
+        this.#m2 = 0;
+    }
+}
+exports.Samples = Samples;
+/**
+ * Round a number to a number of decimals
+ * @param value
+ * @param fractionDigits
+ * @constructor
+ */
+function round(value, fractionDigits) {
+    return parseFloat(value.toFixed(fractionDigits));
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}