speedandcurrent 1.7.5 → 1.7.7

package/README.md

@@ -104,7 +104,7 @@ Leave a source blank or set to *(any)* to accept values from all sources. If mul
 5. The plugin will always estimate currents when Estimate boat speed is enabled. Even when Assume currents is disabled, as this setting is only used in updating the correction table.
 
 ## Persistence & Data Storage
-Each correction table is saved as a `.json` file in Signal K's plugin data directory (typically `~/.signalk/plugin-config-data/speedandcurrent/`). The active table name is stored in the plugin options and reloaded automatically on restart. While learning is active, the table is written to disk approximately every 5 seconds.
+Each correction table is saved as a `.json` file in Signal K's plugin data directory (typically `~/.signalk/plugin-config-data/speedandcurrent/`). The active table name is stored in the plugin options and reloaded automatically on restart. While learning is active, the table is written to disk approximately every 60 seconds.
 
 Safety & backup:
 - Tables can be copied to a new name with the **Copy** button before experimenting.

package/correctionTable.js

@@ -91,39 +91,6 @@ class CorrectionTable extends Table2D{
     this.lastUpdatedCell = cell;
   }
 
-  getKalmanCorrection(speed, heel) {
-    /**
-   * Return a estimated correction based on interpolation and weighting of correction variance;
-   */
-    if (speed == 0) return { x: 0, y: 0 };
-    const neighbours = this.findNeighbours(speed, heel);
-    let totalWeightX   = 0;
-    let totalWeightY   = 0;
-    let x = 0;
-    let y = 0;
-    for (const neighbour of neighbours) {
-      const { cell:correction, xdist, ydist } = neighbour;
-      if (correction.N > 0) {
-        const weightX = 1 / (xdist + 1e-6) ;
-        const weightY = 1 / (ydist + 1e-6) ;
-        const varianceX = correction.covariance[0][0];
-        const varianceY = correction.covariance[1][1];
-        const N = correction.N;
-        const varWeightX = weightX * N / (varianceX + 1e-6);
-        const varWeightY = weightY * N / (varianceY + 1e-6);
-        x += correction.x * varWeightX;
-        y += correction.y * varWeightY; 
-        totalWeightX += varWeightX;
-        totalWeightY += varWeightY;
-      }
-    }
-    if (totalWeightX == 0 || totalWeightY == 0) return { x: 0, y: 0 };  
-    x = x / totalWeightX;
-    y = y / totalWeightY;
-    return { x:x, y:y };
-
-  }
-
   getCorrection(speed, heel) {
     this.neighbours = this.findClosest(speed, heel, 5);
     if (this.neighbours.length == 0) return { correction: {x: 0, y: 0}, variance: null };
@@ -187,7 +154,6 @@ class CorrectionTable extends Table2D{
               if (cov && Array.isArray(cov) && cov[0] && cov[1] && Number.isFinite(cov[0][0]) && Number.isFinite(cov[1][1])) {
                 const a = cov[0][0];
                 const d = cov[1][1];
-                //trace = Math.sqrt(a*a + d*d);
                 trace = a + d;
               }
             } catch { /* silent */ }
@@ -285,7 +251,7 @@ class CorrectionEstimator {
 
     var groundCov = rotateVariance(groundSpeed.variance);
     var currentCov = rotateVariance(current.variance);
-    var boatCov = [[boatSpeed.variance[0], 0], [0, boatSpeed.variance[1]]];
+    var boatCov = [[boatSpeed.xVariance, 0], [0, boatSpeed.yVariance]];
 
     const observationCovariance = [[
       groundCov[0][0] + currentCov[0][0] + boatCov[0][0],

package/index.js

@@ -41,7 +41,8 @@ module.exports = function (app) {
     smootherTau: 3,
     smootherTimeSpan: 5,
     smootherSteadyState: 0.2,
-    showStatistics: false
+    showStatistics: false,
+    stalenessDetection: true
   };
 
   
@@ -109,7 +110,6 @@ module.exports = function (app) {
   let isRunning = false;
   let pluginStatus = 'Stopped';
   let smoothedHeading = null;
-  let stability = null;
   let smoothedAttitude = null;
   let rawCurrent = null;
   let smoothedCurrent = null;
@@ -120,10 +120,10 @@ module.exports = function (app) {
   let smoothedGroundSpeed = null;
   let speedCorrection = null;
   let residual = null;
+  let smoothedResidual = null;
   let reportFull = null;
   let table = null;
 
-  // add missing declarations
   let rawHeading = null;
   let rawAttitude = null;
   let noCurrent = null;
@@ -313,6 +313,10 @@ module.exports = function (app) {
       SmootherClass,
       smootherOptions
     });
+    // The magnitude handler has a fixed value of 1 and is never subscribed, so its timestamp
+    // stays null forever. Staleness detection on it would always force _stale=true, blocking
+    // processChanges() from setting polar._ready=true on every heading delta.
+    smoothedHeading.polar.magnitudeHandler.stalenessDetection = false;
     rawHeading = smoothedHeading.handler;
 
     //attitude
@@ -359,6 +363,7 @@ module.exports = function (app) {
     });
     noCurrent.xSmoother.reset(0,0);
     noCurrent.ySmoother.reset(0,0);
+    noCurrent.stalenessDetection = false; // noCurrent is a fixed zero-vector, never receives live data
     PolarSmoother.send(app, plugin.id, [noCurrent]);
 
     MessageHandler.setMeta(app, plugin.id, 'navigation.leewayAngle', {
@@ -422,6 +427,8 @@ module.exports = function (app) {
     // residual
     residual = new Polar(app, plugin.id, "residual");
     residual.setMeta({ displayName: "Residual", plane: "Ground" });
+    smoothedResidual = new PolarSmoother(residual, ExponentialSmoother, { tau: 30, timeSpan: 30 }); // id auto-derived: 'residual.smoothed'
+    smoothedResidual.setAngleRange('0to2pi');
 
     //#endregion
 
@@ -438,6 +445,7 @@ module.exports = function (app) {
       reportFull.addPolar(rawGroundSpeed);
       reportFull.addPolar(smoothedCurrent);
       reportFull.addPolar(residual);
+      reportFull.addPolar(smoothedResidual);
     }
     if (options.updateCorrectionTable) {
       reportFull.addDelta(smoothedHeading);
@@ -452,6 +460,18 @@ module.exports = function (app) {
 
     //#endregion
 
+    // Apply staleness detection to all subscribed smoother instances.
+    // noCurrent is intentionally excluded — it is a fixed zero-vector and never receives live data.
+    // Only apply when sd = false: all smoothers already default to stalenessDetection = true.
+    // Explicitly calling the setter with true at startup forces _stale = true on handlers that have
+    // never received data, causing the first sample to be dropped (library side-effect).
+    const sd = options.stalenessDetection ?? true;
+    if (!sd) {
+      for (const s of [smoothedHeading, smoothedAttitude, smoothedBoatSpeed, smoothedGroundSpeed, smoothedCurrent, smoothedResidual]) {
+        if (s) s.stalenessDetection = false;
+      }
+    }
+
     isRunning = true;
     started = new Date();
     setStatus('Running');
@@ -482,7 +502,6 @@ module.exports = function (app) {
     return new Promise((resolve, reject) => {
       try {
         smoothedHeading = smoothedHeading?.terminate();
-        stability = stability?.terminate?.();
         smoothedAttitude = smoothedAttitude?.terminate();
         rawCurrent = rawCurrent?.terminate();
         smoothedCurrent = smoothedCurrent?.terminate?.();
@@ -493,6 +512,7 @@ module.exports = function (app) {
         smoothedGroundSpeed = smoothedGroundSpeed?.terminate();
         speedCorrection = speedCorrection?.terminate();
         residual = residual?.terminate();
+        smoothedResidual = smoothedResidual?.terminate?.();
         reportFull = null;
         table = null;
         rawHeading = null;
@@ -542,41 +562,50 @@ module.exports = function (app) {
         speedCorrection.setVectorValue(correction, variance);
         correctedBoatSpeed.add(speedCorrection);
       }
-      // Current estimation and residual also require heading (to rotate into ground frame)
-      if (rawHeading.ready && rawGroundSpeed.ready) {
+      // Current estimation and residual also require heading (to rotate into ground frame).
+      // Also handle near-zero SOG where COG is unavailable: treat groundspeed as zero vector.
+      const sogHandler = rawGroundSpeed.magnitudeHandler;
+      const nearZeroGroundSpeed = !rawGroundSpeed.ready &&
+        sogHandler.ready &&
+        Number.isFinite(sogHandler.value) &&
+        sogHandler.value < 0.3;
+      if (rawHeading.ready && (rawGroundSpeed.ready || nearZeroGroundSpeed)) {
         boatSpeedRefGround.copyFrom(correctedBoatSpeed);
         boatSpeedRefGround.rotate(rawHeading.value);
         // Current estimation gated by wellUnderway (smoothers need to settle first)
         if (wellUnderway) {
-          rawCurrent.copyFrom(rawGroundSpeed);
+          if (rawGroundSpeed.ready) {
+            rawCurrent.copyFrom(rawGroundSpeed);
+          } else {
+            // COG unavailable but SOG is near-zero: boat is stationary, groundspeed treated as zero
+            rawCurrent.setVectorValue({ x: 0, y: 0 });
+          }
           rawCurrent.substract(boatSpeedRefGround);
           smoothedCurrent.sample();
         }
-        // Residual: how well correctedBoatSpeed + smoothedCurrent explains groundSpeed
-        residual.copyFrom(rawGroundSpeed);
-        residual.substract(boatSpeedRefGround);
-        residual.substract(smoothedCurrent);
+        // Residual requires full groundspeed (both SOG and COG)
+        if (rawGroundSpeed.ready) {
+          residual.copyFrom(rawGroundSpeed);
+          residual.substract(boatSpeedRefGround);
+          residual.substract(smoothedCurrent);
+          smoothedResidual.sample();
+        }
       }
     }
     // Implicit fallback: attitude not ready — correctedBoatSpeed = raw STW, no correction
 
-    PolarSmoother.send(app, plugin.id, [smoothedCurrent]);
+    PolarSmoother.send(app, plugin.id, [smoothedCurrent, smoothedResidual]);
 
     Polar.send(app, plugin.id, [correctedBoatSpeed]);
   }
 
   /**
-   * Updates the correction table and calculates the residual error.
-   *
-   * This function uses the current smoothed attitude, boat speed, and heading to update the correction table
-   * if the boat speed exceeds the specified minimum. It also calculates the residual between the measured ground speed
-   * and the expected ground speed (corrected boat speed plus current). The correction table is periodically saved.
-   *
-   * @param {boolean} [assumeCurrent=false] - If true, uses the smoothed current for correction; otherwise, assumes no current.
-   * @param {number} [minSpeed=0] - The minimum speed threshold (in SI units) required to update the correction table.
+   * Updates the correction table from the current smoothed inputs.
+   * Reads assumeCurrent and minSpeed from module-level options/state;
+   * silently returns if any required input is not yet ready.
    */
   function updateTable() {
-    lrnBoatSpeed.setVectorValue({ x: smoothedBoatSpeed.value, y: 0 });
+    lrnBoatSpeed.setVectorValue({ x: smoothedBoatSpeed.value, y: 0 }, { x: smoothedBoatSpeed.variance ?? 0, y: 0 });
     if (!smoothedAttitude.ready || !smoothedBoatSpeed.ready || !smoothedHeading.ready || !smoothedGroundSpeed.ready || (options.assumeCurrent ? !smoothedCurrent.ready : !noCurrent.ready)) return;
     
     // update correction table
@@ -587,37 +616,12 @@ module.exports = function (app) {
   }
 
   /**
-   * Checks if the correction table in settings matches the expected row and column configuration.
-   *
-   * This function compares the min, max, and step values of the row and column definitions
-   * in the current correction table against the provided row and col objects. Returns true
-   * if all values match, otherwise false. If the table is missing or not properly structured,
-   * returns false.
-   *
-   * @param {Object} row - The expected row configuration ({ min, max, step }).
-   * @param {Object} col - The expected column configuration ({ min, max, step }).
-   * @returns {boolean} True if the table matches the configuration, false otherwise.
-   */
-  function enforceConsistancy(data, row, col) {
-    if (!data) return false;
-    if (!data.row) return false;
-    if (data.row.min != row.min) return false;
-    if (data.row.max != row.max) return false;
-    if (data.row.step != row.step) return false;
-    if (data.col.min != col.min) return false;
-    if (data.col.max != col.max) return false;
-    if (data.col.step != col.step) return false;
-    return true;
-  }
-
-  /**
-   * Loads or creates a correction table based on the provided options.
-   *
-   * This function checks if the correction table in the options matches the expected row and column configuration.
-   * If so, it loads the table from JSON; otherwise, it creates a new correction table with the specified parameters.
-   * The table is labeled and, if newly created, saved to the plugin options.
+   * Loads or creates a correction table from disk.
+   * If the file exists it is deserialized; otherwise a new table is created
+   * with default dimensions and saved to disk.
    *
-   * @param {Object} options - The plugin options containing correction table settings and parameters.
+   * @param {Object} options - Plugin options (stability, tableName, and dimension defaults).
+   * @param {string} filePath - Absolute path of the JSON file to read.
    * @returns {CorrectionTable} The loaded or newly created CorrectionTable instance.
    */
   function loadTable(options, filePath) {
@@ -639,15 +643,10 @@ module.exports = function (app) {
   }
 
   /**
-   * Saves the correction table to the plugin options and logs the save event.
+   * Saves the correction table to disk as JSON.
    *
-   * This function serializes the provided correction table, updates the options object,
-   * and triggers the plugin's save mechanism. It returns the current date/time to indicate
-   * when the save occurred.
-   *
-   * @param {Object} options - The plugin options object to update.
    * @param {CorrectionTable} correctionTable - The correction table instance to save.
-   * @returns {Date} The date and time when the table was saved.
+   * @param {string} filePath - Absolute path of the target JSON file.
    */
   function saveTable(correctionTable, filePath) {
     correctionTable.saveToFile(filePath);
@@ -677,6 +676,12 @@ module.exports = function (app) {
         if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
       } else if (key === 'estimateBoatSpeed' ) {
         if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
+      } else if (key === 'stalenessDetection') {
+        const sdVal = Boolean(value);
+        for (const s of [smoothedHeading, smoothedAttitude, smoothedBoatSpeed, smoothedGroundSpeed, smoothedCurrent, smoothedResidual]) {
+          if (s) s.stalenessDetection = sdVal;
+        }
+        // noCurrent is always excluded from staleness detection
       }
 
       // All other keys (sogFallback, estimateBoatSpeed, updateCorrectionTable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speedandcurrent",
-  "version": "1.7.5",
+  "version": "1.7.7",
   "description": "A plugin that automatically corrects boat speed and calculates current and leeway using sensor fusion.",
   "main": "index.js",
   "scripts": {
@@ -31,12 +31,11 @@
   },
   "dependencies": {
     "kalman-filter": "^2.3.0",
-    "signalkutilities": "^1.11.0"
+    "signalkutilities": "^1.12.0"
   },
   "files": [
     "index.js",
     "correctionTable.js",
-    "leakyExtremes.js",
     "public/"
   ]
 }

package/public/app.js

@@ -118,7 +118,7 @@ async function loadMeta() {
 
 function isStale(item) {
   if (!item) return true;
-  return item.state?.stale === true;
+  return item.state?.isStale === true;
 }
 
 function isNotReady(item) {
@@ -126,6 +126,36 @@ function isNotReady(item) {
   return item.state?.ready !== true;
 }
 
+// Returns a human-readable reason why an item is not ready.
+// Handles three state shapes:
+//   handler-nested  (MessageSmoother, SmoothedAngle):  state.handler.*
+//   magnitude/angle (PolarSmoother):                   state.magnitude.* / state.angle.*
+//   flat top-level  (MessageHandler, Polar):           state.*
+function getNotReadyReason(item) {
+  if (!item) return 'not available';
+  const s = item.state;
+  if (!s) return 'not available';
+
+  let subscribed, pathKnown;
+  if (s.handler !== undefined) {
+    subscribed = s.handler.subscribed;
+    pathKnown  = s.handler.pathKnown;
+  } else if (s.magnitude !== undefined || s.angle !== undefined) {
+    const mag = s.magnitude, ang = s.angle;
+    subscribed = (mag?.subscribed !== false) && (ang?.subscribed !== false);
+    pathKnown  = (mag?.pathKnown  !== false) && (ang?.pathKnown  !== false);
+  } else {
+    subscribed = s.subscribed;
+    pathKnown  = s.pathKnown;
+  }
+
+  if (subscribed === false) return 'not subscribed to Signal K';
+  if (pathKnown  === false) return 'path not found in Signal K';
+  if (!s.hasDelta)          return 'waiting for first data';
+  if (s.isStale)            return 'data is stale';
+  return 'not available';
+}
+
 function getAnyItem(id) {
   return state.polarsById[id] || state.deltasById[id] || state.attitudesById[id] || null;
 }
@@ -143,9 +173,10 @@ function renderWarnings(elId, ids) {
   const ul = document.createElement('ul');
   ul.className = 'list-unstyled text-danger small ps-3';
   notReady.forEach(id => {
+    const item = getAnyItem(id);
     const label = metaById[id]?.displayName ?? id;
     const li = document.createElement('li');
-    li.textContent = `"${label}" — not available`;
+    li.textContent = `"${label}" — ${getNotReadyReason(item)}`;
     ul.appendChild(li);
   });
   el.appendChild(ul);
@@ -273,10 +304,16 @@ const paramMeta = {
     min: 0.01, max: 0.99, step: 0.01, default: 0.2,
     description: 'Steady-state Kalman gain (0 ≈ slow/smooth, 1 ≈ fast/raw). Clamped to 0.01–0.99.'
   },
+  stalenessDetection: {
+    label: 'Staleness detection',
+    type: 'boolean',
+    description: 'Mark inputs as unavailable when no data has been received for a period. '
+  },
 };
 
 // Settings groups for each UI section
 const INPUTS_SOURCE_KEYS      = ['headingSource','boatSpeedSource','SOGSource','attitudeSource'];
+const INPUTS_SETTING_KEYS     = ['stalenessDetection'];
 const ESTIMATION_SETTING_KEYS = ['sogFallback','preventDuplication'];
 const LEARNING_SETTING_KEYS   = ['stability','assumeCurrent','showStatistics'];
 const SMOOTHER_SETTING_KEYS   = [
@@ -441,6 +478,7 @@ function renderSectionToggles() {
 function renderSettingsPanel() {
   if (!config) return;
   renderSettingsRows('inputs-sources-table',      INPUTS_SOURCE_KEYS);
+  renderSettingsRows('inputs-settings-table',     INPUTS_SETTING_KEYS);
   renderSettingsRows('estimation-settings-table', ESTIMATION_SETTING_KEYS);
   renderSettingsRows('smoother-settings-table',   SMOOTHER_SETTING_KEYS);
   renderSettingsRows('learning-settings-table',   LEARNING_SETTING_KEYS);
@@ -545,7 +583,7 @@ function renderLiveSections() {
   );
   // Estimation — intermediates
   renderGroupInto('estimation-intermediates',
-    filterById(state.polarsAll, ['boatSpeedRefGround', 'speedCorrection', 'residual']),
+    filterById(state.polarsAll, ['boatSpeedRefGround', 'speedCorrection', 'residual', 'residual.smoothed']),
     [], []
   );
   // Estimation — outputs

package/public/index.html

@@ -7,16 +7,36 @@
   <title>Speed and Current</title>
   <script>
     (async () => {
+      const appendStylesheet = (href) => {
+        const el = document.createElement('link');
+        el.rel  = 'stylesheet';
+        el.href = href;
+        document.head.appendChild(el);
+      };
+      try {
+        const res = await fetch('/admin/.vite/manifest.json');
+        if (res.ok) {
+          const manifest = await res.json();
+          let found = false;
+          for (const entry of Object.values(manifest)) {
+            if (!entry.isEntry) continue;
+            for (const css of entry.css ?? []) {
+              appendStylesheet('/admin/' + css);
+              found = true;
+            }
+          }
+          if (found) return;
+        }
+      } catch (e) {
+        // fall through to legacy scrape
+      }
       try {
         const res  = await fetch('/');
         const html = await res.text();
         const doc  = new DOMParser().parseFromString(html, 'text/html');
         const link = doc.querySelector('link[rel="stylesheet"]');
         if (link) {
-          const el = document.createElement('link');
-          el.rel  = 'stylesheet';
-          el.href = new URL(link.getAttribute('href'), res.url).href;
-          document.head.appendChild(el);
+          appendStylesheet(new URL(link.getAttribute('href'), res.url).href);
         }
       } catch (e) {
         console.warn('[webapp] Could not load SignalK admin stylesheet:', e);
@@ -76,6 +96,10 @@
               <table class="table table-sm table-borderless mb-0" id="inputs-sources-table">
                 <tbody></tbody>
               </table>
+              <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Settings</h6>
+              <table class="table table-sm table-borderless mb-0" id="inputs-settings-table">
+                <tbody></tbody>
+              </table>
               <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Live Values</h6>
               <div id="inputs-values"></div>
             </div>

package/leakyExtremes.js

@@ -1,98 +0,0 @@
-class LeakyExtremes {
-  /**
-   * @param {Object} opts
-   * @param {number} opts.initialMin
-   * @param {number} opts.initialMax
-   * @param {number} opts.tau - time constant in seconds for exponential decay
-   * @param {number} opts.catchupTau - time constant in seconds for fast catchup
-   * @param {boolean} opts.isAngle - true if data is angular (radians)
-   * @param {number} opts.period - period for angle wrapping (e.g., 2*Math.PI)
-   */
-  constructor({  initialMin=0, initialMax=0, tau = .15, catchupTau=.5, isAngle = false, period = 2 * Math.PI }) {
-    this.min = initialMin;
-    this.max = initialMax;
-    this.tau = tau;
-    this.catchupTau = catchupTau;
-    this.isAngle = isAngle;
-    this.period = period;
-    this.lastUpdate = Date.now();
-  }
-
-  // Helper for angle difference in [-period/2, period/2]
-  angleDiff(a, b) {
-    let d = a - b;
-    while (d > this.period / 2) d -= this.period;
-    while (d < -this.period / 2) d += this.period;
-    return d;
-  }
-
-  // Helper for angle normalization to [0, period)
-  normalizeAngle(a) {
-    while (a < 0) a += this.period;
-    while (a >= this.period) a -= this.period;
-    return a;
-  }
-
-  update(obs) {
-    if (!isFinite(obs) ) return;
-    const now = Date.now();
-    const dt = (now - this.lastUpdate) / 1000;
-    if (dt==0) return; 
-    this.lastUpdate = now;
-
-    if (!this.isAngle) {
-      // Linear data
-      // Update min
-      if (obs < this.min) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.min += (obs - this.min) * alpha;
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.min += (obs - this.min) * alpha;
-      }
-      // Update max
-      if (obs > this.max) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.max += (obs - this.max) * alpha;
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.max += (obs - this.max) * alpha;
-      }
-    } else {
-      // Angular data
-      obs=this.normalizeAngle(obs);
-      let minDiff = this.angleDiff(obs, this.min);
-      let maxDiff = this.angleDiff(obs, this.max);
-
-      // Update min
-      if (minDiff < 0) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.min = this.normalizeAngle(this.min + minDiff * alpha);
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.min = this.normalizeAngle(this.min + minDiff * alpha);
-      }
-      // Update max
-      if (maxDiff > 0) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.max = this.normalizeAngle(this.max + maxDiff * alpha);
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.max = this.normalizeAngle(this.max + maxDiff * alpha);
-      }
-      
-    }
-  }
-
-  // For angles, returns the minimal arc between min and max
-  get range() {
-    if (!this.isAngle) {
-      return this.max - this.min;
-    } else {
-      let diff = this.angleDiff(this.max, this.min);
-      return Math.abs(diff);
-    }
-  }
-}
-
-module.exports = { LeakyExtremes };