{"version":3,"file":"ml-airpls.esm.min.js","sources":["../node_modules/is-any-array/lib-esm/index.js","../node_modules/ml-spectra-processing/lib/x/xCheck.js","../node_modules/ml-spectra-processing/lib/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib/x/xAbsoluteSum.js","../node_modules/ml-spectra-processing/lib/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib/x/xMultiply.js","../node_modules/ml-spectra-processing/lib/x/getOutputArray.js","../node_modules/fft.js/lib/fft.js","../node_modules/ml-spectra-processing/lib/x/utils/erfcinv.js","../node_modules/ml-spectra-processing/lib/x/utils/simpleNormInv.js","../node_modules/ml-spectra-processing/lib/x/xNoiseSanPlot.js","../node_modules/ml-spectra-processing/lib/x/xEnsureFloat64.js","../node_modules/ml-spectra-processing/lib/utils/createFromToArray.js","../lib/choleskySolver.js","../node_modules/cuthill-mckee/cuthill-mckee.js","../lib/utils.js","../lib/index.js"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/unbound-method\nconst toString = Object.prototype.toString;\n/**\n * Checks if an object is an instance of an Array (array or typed array, except those that contain bigint values).\n *\n * @param value - Object to check.\n * @returns True if the object is an array or a typed array.\n */\nexport function isAnyArray(value) {\n    const tag = toString.call(value);\n    return tag.endsWith('Array]') && !tag.includes('Big');\n}\n//# sourceMappingURL=index.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * Checks if the input is a non-empty array of numbers.\n * Only checks the first element.\n * @param input - Array to check.\n * @param options - Additional checks.\n */\nexport function xCheck(input, options = {}) {\n    const { minLength } = options;\n    if (!isAnyArray(input)) {\n        throw new TypeError('input must be an array');\n    }\n    if (input.length === 0) {\n        throw new TypeError('input must not be empty');\n    }\n    if (typeof input[0] !== 'number') {\n        throw new TypeError('input must contain numbers');\n    }\n    if (minLength && input.length < minLength) {\n        throw new Error(`input must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xCheck.js.map","/**\n * Returns the closest index of a `target`\n * @param array - array of numbers\n * @param target - target\n * @param options\n * @returns - closest index\n */\nexport function xFindClosestIndex(array, target, options = {}) {\n    const { sorted = true } = options;\n    if (sorted) {\n        let low = 0;\n        let high = array.length - 1;\n        let middle = 0;\n        while (high - low > 1) {\n            middle = low + ((high - low) >> 1);\n            if (array[middle] < target) {\n                low = middle;\n            }\n            else if (array[middle] > target) {\n                high = middle;\n            }\n            else {\n                return middle;\n            }\n        }\n        if (low < array.length - 1) {\n            if (Math.abs(target - array[low]) < Math.abs(array[low + 1] - target)) {\n                return low;\n            }\n            else {\n                return low + 1;\n            }\n        }\n        else {\n            return low;\n        }\n    }\n    else {\n        let index = 0;\n        let diff = Number.POSITIVE_INFINITY;\n        for (let i = 0; i < array.length; i++) {\n            const currentDiff = Math.abs(array[i] - target);\n            if (currentDiff < diff) {\n                diff = currentDiff;\n                index = i;\n            }\n        }\n        return index;\n    }\n}\n//# sourceMappingURL=xFindClosestIndex.js.map","import { xCheck } from \"./xCheck.js\";\nimport { xGetFromToIndex } from \"./xGetFromToIndex.js\";\nexport function xAbsoluteSum(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let sum = 0;\n    for (let i = fromIndex; i <= toIndex; i++) {\n        sum += Math.abs(array[i]);\n    }\n    return sum;\n}\n//# sourceMappingURL=xAbsoluteSum.js.map","import { xFindClosestIndex } from \"./xFindClosestIndex.js\";\n/**\n * Returns an object with {fromIndex, toIndex} for a specific from / to\n * @param x - array of numbers\n * @param options - Options\n */\nexport function xGetFromToIndex(x, options = {}) {\n    let { fromIndex, toIndex } = options;\n    const { from, to } = options;\n    if (fromIndex === undefined) {\n        if (from !== undefined) {\n            fromIndex = xFindClosestIndex(x, from);\n        }\n        else {\n            fromIndex = 0;\n        }\n    }\n    if (toIndex === undefined) {\n        if (to !== undefined) {\n            toIndex = xFindClosestIndex(x, to);\n        }\n        else {\n            toIndex = x.length - 1;\n        }\n    }\n    if (fromIndex < 0)\n        fromIndex = 0;\n    if (toIndex < 0)\n        toIndex = 0;\n    if (fromIndex >= x.length)\n        fromIndex = x.length - 1;\n    if (toIndex >= x.length)\n        toIndex = x.length - 1;\n    if (fromIndex > toIndex)\n        [fromIndex, toIndex] = [toIndex, fromIndex];\n    return { fromIndex, toIndex };\n}\n//# sourceMappingURL=xGetFromToIndex.js.map","import { isAnyArray } from 'is-any-array';\nimport { getOutputArray } from \"./getOutputArray.js\";\n/**\n * This function xMultiply the first array by the second array or a constant value to each element of the first array\n * @param array1 - first array\n * @param array2 - second array\n * @param options - options\n */\nexport function xMultiply(array1, array2, options = {}) {\n    let isConstant = false;\n    let constant = 0;\n    if (isAnyArray(array2)) {\n        if (array1.length !== array2.length) {\n            throw new Error('size of array1 and array2 must be identical');\n        }\n    }\n    else {\n        isConstant = true;\n        constant = array2;\n    }\n    const array3 = getOutputArray(options.output, array1.length);\n    if (isConstant) {\n        for (let i = 0; i < array1.length; i++) {\n            array3[i] = array1[i] * constant;\n        }\n    }\n    else {\n        for (let i = 0; i < array1.length; i++) {\n            array3[i] = array1[i] * array2[i];\n        }\n    }\n    return array3;\n}\n//# sourceMappingURL=xMultiply.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * This function\n * @param output - undefined or a new array\n * @param length - length of the output array\n * @returns\n */\nexport function getOutputArray(output, length) {\n    if (output !== undefined) {\n        if (!isAnyArray(output)) {\n            throw new TypeError('output option must be an array if specified');\n        }\n        if (output.length !== length) {\n            throw new TypeError('the output array does not have the correct length');\n        }\n        return output;\n    }\n    else {\n        return new Float64Array(length);\n    }\n}\n//# sourceMappingURL=getOutputArray.js.map","'use strict';\n\nfunction FFT(size) {\n  this.size = size | 0;\n  if (this.size <= 1 || (this.size & (this.size - 1)) !== 0)\n    throw new Error('FFT size must be a power of two and bigger than 1');\n\n  this._csize = size << 1;\n\n  // NOTE: Use of `var` is intentional for old V8 versions\n  var table = new Array(this.size * 2);\n  for (var i = 0; i < table.length; i += 2) {\n    const angle = Math.PI * i / this.size;\n    table[i] = Math.cos(angle);\n    table[i + 1] = -Math.sin(angle);\n  }\n  this.table = table;\n\n  // Find size's power of two\n  var power = 0;\n  for (var t = 1; this.size > t; t <<= 1)\n    power++;\n\n  // Calculate initial step's width:\n  //   * If we are full radix-4 - it is 2x smaller to give inital len=8\n  //   * Otherwise it is the same as `power` to give len=4\n  this._width = power % 2 === 0 ? power - 1 : power;\n\n  // Pre-compute bit-reversal patterns\n  this._bitrev = new Array(1 << this._width);\n  for (var j = 0; j < this._bitrev.length; j++) {\n    this._bitrev[j] = 0;\n    for (var shift = 0; shift < this._width; shift += 2) {\n      var revShift = this._width - shift - 2;\n      this._bitrev[j] |= ((j >>> shift) & 3) << revShift;\n    }\n  }\n\n  this._out = null;\n  this._data = null;\n  this._inv = 0;\n}\nmodule.exports = FFT;\n\nFFT.prototype.fromComplexArray = function fromComplexArray(complex, storage) {\n  var res = storage || new Array(complex.length >>> 1);\n  for (var i = 0; i < complex.length; i += 2)\n    res[i >>> 1] = complex[i];\n  return res;\n};\n\nFFT.prototype.createComplexArray = function createComplexArray() {\n  const res = new Array(this._csize);\n  for (var i = 0; i < res.length; i++)\n    res[i] = 0;\n  return res;\n};\n\nFFT.prototype.toComplexArray = function toComplexArray(input, storage) {\n  var res = storage || this.createComplexArray();\n  for (var i = 0; i < res.length; i += 2) {\n    res[i] = input[i >>> 1];\n    res[i + 1] = 0;\n  }\n  return res;\n};\n\nFFT.prototype.completeSpectrum = function completeSpectrum(spectrum) {\n  var size = this._csize;\n  var half = size >>> 1;\n  for (var i = 2; i < half; i += 2) {\n    spectrum[size - i] = spectrum[i];\n    spectrum[size - i + 1] = -spectrum[i + 1];\n  }\n};\n\nFFT.prototype.transform = function transform(out, data) {\n  if (out === data)\n    throw new Error('Input and output buffers must be different');\n\n  this._out = out;\n  this._data = data;\n  this._inv = 0;\n  this._transform4();\n  this._out = null;\n  this._data = null;\n};\n\nFFT.prototype.realTransform = function realTransform(out, data) {\n  if (out === data)\n    throw new Error('Input and output buffers must be different');\n\n  this._out = out;\n  this._data = data;\n  this._inv = 0;\n  this._realTransform4();\n  this._out = null;\n  this._data = null;\n};\n\nFFT.prototype.inverseTransform = function inverseTransform(out, data) {\n  if (out === data)\n    throw new Error('Input and output buffers must be different');\n\n  this._out = out;\n  this._data = data;\n  this._inv = 1;\n  this._transform4();\n  for (var i = 0; i < out.length; i++)\n    out[i] /= this.size;\n  this._out = null;\n  this._data = null;\n};\n\n// radix-4 implementation\n//\n// NOTE: Uses of `var` are intentional for older V8 version that do not\n// support both `let compound assignments` and `const phi`\nFFT.prototype._transform4 = function _transform4() {\n  var out = this._out;\n  var size = this._csize;\n\n  // Initial step (permute and transform)\n  var width = this._width;\n  var step = 1 << width;\n  var len = (size / step) << 1;\n\n  var outOff;\n  var t;\n  var bitrev = this._bitrev;\n  if (len === 4) {\n    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {\n      const off = bitrev[t];\n      this._singleTransform2(outOff, off, step);\n    }\n  } else {\n    // len === 8\n    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {\n      const off = bitrev[t];\n      this._singleTransform4(outOff, off, step);\n    }\n  }\n\n  // Loop through steps in decreasing order\n  var inv = this._inv ? -1 : 1;\n  var table = this.table;\n  for (step >>= 2; step >= 2; step >>= 2) {\n    len = (size / step) << 1;\n    var quarterLen = len >>> 2;\n\n    // Loop through offsets in the data\n    for (outOff = 0; outOff < size; outOff += len) {\n      // Full case\n      var limit = outOff + quarterLen;\n      for (var i = outOff, k = 0; i < limit; i += 2, k += step) {\n        const A = i;\n        const B = A + quarterLen;\n        const C = B + quarterLen;\n        const D = C + quarterLen;\n\n        // Original values\n        const Ar = out[A];\n        const Ai = out[A + 1];\n        const Br = out[B];\n        const Bi = out[B + 1];\n        const Cr = out[C];\n        const Ci = out[C + 1];\n        const Dr = out[D];\n        const Di = out[D + 1];\n\n        // Middle values\n        const MAr = Ar;\n        const MAi = Ai;\n\n        const tableBr = table[k];\n        const tableBi = inv * table[k + 1];\n        const MBr = Br * tableBr - Bi * tableBi;\n        const MBi = Br * tableBi + Bi * tableBr;\n\n        const tableCr = table[2 * k];\n        const tableCi = inv * table[2 * k + 1];\n        const MCr = Cr * tableCr - Ci * tableCi;\n        const MCi = Cr * tableCi + Ci * tableCr;\n\n        const tableDr = table[3 * k];\n        const tableDi = inv * table[3 * k + 1];\n        const MDr = Dr * tableDr - Di * tableDi;\n        const MDi = Dr * tableDi + Di * tableDr;\n\n        // Pre-Final values\n        const T0r = MAr + MCr;\n        const T0i = MAi + MCi;\n        const T1r = MAr - MCr;\n        const T1i = MAi - MCi;\n        const T2r = MBr + MDr;\n        const T2i = MBi + MDi;\n        const T3r = inv * (MBr - MDr);\n        const T3i = inv * (MBi - MDi);\n\n        // Final values\n        const FAr = T0r + T2r;\n        const FAi = T0i + T2i;\n\n        const FCr = T0r - T2r;\n        const FCi = T0i - T2i;\n\n        const FBr = T1r + T3i;\n        const FBi = T1i - T3r;\n\n        const FDr = T1r - T3i;\n        const FDi = T1i + T3r;\n\n        out[A] = FAr;\n        out[A + 1] = FAi;\n        out[B] = FBr;\n        out[B + 1] = FBi;\n        out[C] = FCr;\n        out[C + 1] = FCi;\n        out[D] = FDr;\n        out[D + 1] = FDi;\n      }\n    }\n  }\n};\n\n// radix-2 implementation\n//\n// NOTE: Only called for len=4\nFFT.prototype._singleTransform2 = function _singleTransform2(outOff, off,\n                                                             step) {\n  const out = this._out;\n  const data = this._data;\n\n  const evenR = data[off];\n  const evenI = data[off + 1];\n  const oddR = data[off + step];\n  const oddI = data[off + step + 1];\n\n  const leftR = evenR + oddR;\n  const leftI = evenI + oddI;\n  const rightR = evenR - oddR;\n  const rightI = evenI - oddI;\n\n  out[outOff] = leftR;\n  out[outOff + 1] = leftI;\n  out[outOff + 2] = rightR;\n  out[outOff + 3] = rightI;\n};\n\n// radix-4\n//\n// NOTE: Only called for len=8\nFFT.prototype._singleTransform4 = function _singleTransform4(outOff, off,\n                                                             step) {\n  const out = this._out;\n  const data = this._data;\n  const inv = this._inv ? -1 : 1;\n  const step2 = step * 2;\n  const step3 = step * 3;\n\n  // Original values\n  const Ar = data[off];\n  const Ai = data[off + 1];\n  const Br = data[off + step];\n  const Bi = data[off + step + 1];\n  const Cr = data[off + step2];\n  const Ci = data[off + step2 + 1];\n  const Dr = data[off + step3];\n  const Di = data[off + step3 + 1];\n\n  // Pre-Final values\n  const T0r = Ar + Cr;\n  const T0i = Ai + Ci;\n  const T1r = Ar - Cr;\n  const T1i = Ai - Ci;\n  const T2r = Br + Dr;\n  const T2i = Bi + Di;\n  const T3r = inv * (Br - Dr);\n  const T3i = inv * (Bi - Di);\n\n  // Final values\n  const FAr = T0r + T2r;\n  const FAi = T0i + T2i;\n\n  const FBr = T1r + T3i;\n  const FBi = T1i - T3r;\n\n  const FCr = T0r - T2r;\n  const FCi = T0i - T2i;\n\n  const FDr = T1r - T3i;\n  const FDi = T1i + T3r;\n\n  out[outOff] = FAr;\n  out[outOff + 1] = FAi;\n  out[outOff + 2] = FBr;\n  out[outOff + 3] = FBi;\n  out[outOff + 4] = FCr;\n  out[outOff + 5] = FCi;\n  out[outOff + 6] = FDr;\n  out[outOff + 7] = FDi;\n};\n\n// Real input radix-4 implementation\nFFT.prototype._realTransform4 = function _realTransform4() {\n  var out = this._out;\n  var size = this._csize;\n\n  // Initial step (permute and transform)\n  var width = this._width;\n  var step = 1 << width;\n  var len = (size / step) << 1;\n\n  var outOff;\n  var t;\n  var bitrev = this._bitrev;\n  if (len === 4) {\n    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {\n      const off = bitrev[t];\n      this._singleRealTransform2(outOff, off >>> 1, step >>> 1);\n    }\n  } else {\n    // len === 8\n    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {\n      const off = bitrev[t];\n      this._singleRealTransform4(outOff, off >>> 1, step >>> 1);\n    }\n  }\n\n  // Loop through steps in decreasing order\n  var inv = this._inv ? -1 : 1;\n  var table = this.table;\n  for (step >>= 2; step >= 2; step >>= 2) {\n    len = (size / step) << 1;\n    var halfLen = len >>> 1;\n    var quarterLen = halfLen >>> 1;\n    var hquarterLen = quarterLen >>> 1;\n\n    // Loop through offsets in the data\n    for (outOff = 0; outOff < size; outOff += len) {\n      for (var i = 0, k = 0; i <= hquarterLen; i += 2, k += step) {\n        var A = outOff + i;\n        var B = A + quarterLen;\n        var C = B + quarterLen;\n        var D = C + quarterLen;\n\n        // Original values\n        var Ar = out[A];\n        var Ai = out[A + 1];\n        var Br = out[B];\n        var Bi = out[B + 1];\n        var Cr = out[C];\n        var Ci = out[C + 1];\n        var Dr = out[D];\n        var Di = out[D + 1];\n\n        // Middle values\n        var MAr = Ar;\n        var MAi = Ai;\n\n        var tableBr = table[k];\n        var tableBi = inv * table[k + 1];\n        var MBr = Br * tableBr - Bi * tableBi;\n        var MBi = Br * tableBi + Bi * tableBr;\n\n        var tableCr = table[2 * k];\n        var tableCi = inv * table[2 * k + 1];\n        var MCr = Cr * tableCr - Ci * tableCi;\n        var MCi = Cr * tableCi + Ci * tableCr;\n\n        var tableDr = table[3 * k];\n        var tableDi = inv * table[3 * k + 1];\n        var MDr = Dr * tableDr - Di * tableDi;\n        var MDi = Dr * tableDi + Di * tableDr;\n\n        // Pre-Final values\n        var T0r = MAr + MCr;\n        var T0i = MAi + MCi;\n        var T1r = MAr - MCr;\n        var T1i = MAi - MCi;\n        var T2r = MBr + MDr;\n        var T2i = MBi + MDi;\n        var T3r = inv * (MBr - MDr);\n        var T3i = inv * (MBi - MDi);\n\n        // Final values\n        var FAr = T0r + T2r;\n        var FAi = T0i + T2i;\n\n        var FBr = T1r + T3i;\n        var FBi = T1i - T3r;\n\n        out[A] = FAr;\n        out[A + 1] = FAi;\n        out[B] = FBr;\n        out[B + 1] = FBi;\n\n        // Output final middle point\n        if (i === 0) {\n          var FCr = T0r - T2r;\n          var FCi = T0i - T2i;\n          out[C] = FCr;\n          out[C + 1] = FCi;\n          continue;\n        }\n\n        // Do not overwrite ourselves\n        if (i === hquarterLen)\n          continue;\n\n        // In the flipped case:\n        // MAi = -MAi\n        // MBr=-MBi, MBi=-MBr\n        // MCr=-MCr\n        // MDr=MDi, MDi=MDr\n        var ST0r = T1r;\n        var ST0i = -T1i;\n        var ST1r = T0r;\n        var ST1i = -T0i;\n        var ST2r = -inv * T3i;\n        var ST2i = -inv * T3r;\n        var ST3r = -inv * T2i;\n        var ST3i = -inv * T2r;\n\n        var SFAr = ST0r + ST2r;\n        var SFAi = ST0i + ST2i;\n\n        var SFBr = ST1r + ST3i;\n        var SFBi = ST1i - ST3r;\n\n        var SA = outOff + quarterLen - i;\n        var SB = outOff + halfLen - i;\n\n        out[SA] = SFAr;\n        out[SA + 1] = SFAi;\n        out[SB] = SFBr;\n        out[SB + 1] = SFBi;\n      }\n    }\n  }\n};\n\n// radix-2 implementation\n//\n// NOTE: Only called for len=4\nFFT.prototype._singleRealTransform2 = function _singleRealTransform2(outOff,\n                                                                     off,\n                                                                     step) {\n  const out = this._out;\n  const data = this._data;\n\n  const evenR = data[off];\n  const oddR = data[off + step];\n\n  const leftR = evenR + oddR;\n  const rightR = evenR - oddR;\n\n  out[outOff] = leftR;\n  out[outOff + 1] = 0;\n  out[outOff + 2] = rightR;\n  out[outOff + 3] = 0;\n};\n\n// radix-4\n//\n// NOTE: Only called for len=8\nFFT.prototype._singleRealTransform4 = function _singleRealTransform4(outOff,\n                                                                     off,\n                                                                     step) {\n  const out = this._out;\n  const data = this._data;\n  const inv = this._inv ? -1 : 1;\n  const step2 = step * 2;\n  const step3 = step * 3;\n\n  // Original values\n  const Ar = data[off];\n  const Br = data[off + step];\n  const Cr = data[off + step2];\n  const Dr = data[off + step3];\n\n  // Pre-Final values\n  const T0r = Ar + Cr;\n  const T1r = Ar - Cr;\n  const T2r = Br + Dr;\n  const T3r = inv * (Br - Dr);\n\n  // Final values\n  const FAr = T0r + T2r;\n\n  const FBr = T1r;\n  const FBi = -T3r;\n\n  const FCr = T0r - T2r;\n\n  const FDr = T1r;\n  const FDi = T3r;\n\n  out[outOff] = FAr;\n  out[outOff + 1] = 0;\n  out[outOff + 2] = FBr;\n  out[outOff + 3] = FBi;\n  out[outOff + 4] = FCr;\n  out[outOff + 5] = 0;\n  out[outOff + 6] = FDr;\n  out[outOff + 7] = FDi;\n};\n","/*\nAdapted from: https://github.com/compute-io/erfcinv/blob/aa116e23883839359e310ad41a7c42f72815fc1e/lib/number.js\n\nThe MIT License (MIT)\n\nCopyright (c) 2014-2015 The Compute.io Authors. All rights reserved.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n\nBoost Software License - Version 1.0 - August 17th, 2003\n\nPermission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the \"Software\") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n/* eslint-disable no-loss-of-precision */\n// Coefficients for erfcinv on [0, 0.5]:\nconst Y1 = 8.91314744949340820313e-2;\nconst P1 = [\n    -5.38772965071242932965e-3, 8.22687874676915743155e-3,\n    2.19878681111168899165e-2, -3.65637971411762664006e-2,\n    -1.26926147662974029034e-2, 3.34806625409744615033e-2,\n    -8.36874819741736770379e-3, -5.08781949658280665617e-4,\n];\nconst Q1 = [\n    8.86216390456424707504e-4, -2.33393759374190016776e-3,\n    7.95283687341571680018e-2, -5.27396382340099713954e-2,\n    -7.1228902341542847553e-1, 6.62328840472002992063e-1, 1.56221558398423026363,\n    -1.56574558234175846809, -9.70005043303290640362e-1, 1,\n];\n// Coefficients for erfcinv for 0.5 > 1-x >= 0:\nconst Y2 = 2.249481201171875;\nconst P2 = [\n    -3.67192254707729348546, 2.11294655448340526258e1, 1.7445385985570866523e1,\n    -4.46382324441786960818e1, -1.88510648058714251895e1,\n    1.76447298408374015486e1, 8.37050328343119927838, 1.05264680699391713268e-1,\n    -2.02433508355938759655e-1,\n];\nconst Q2 = [\n    1.72114765761200282724, -2.26436933413139721736e1, 1.08268667355460159008e1,\n    4.85609213108739935468e1, -2.01432634680485188801e1,\n    -2.86608180499800029974e1, 3.9713437953343869095, 6.24264124854247537712, 1,\n];\n// Coefficients for erfcinv for sqrt( -log(1-x)):\nconst Y3 = 8.07220458984375e-1;\nconst P3 = [\n    -6.81149956853776992068e-10, 2.85225331782217055858e-8,\n    -6.79465575181126350155e-7, 2.14558995388805277169e-3,\n    2.90157910005329060432e-2, 1.42869534408157156766e-1,\n    3.37785538912035898924e-1, 3.87079738972604337464e-1,\n    1.17030156341995252019e-1, -1.63794047193317060787e-1,\n    -1.31102781679951906451e-1,\n];\nconst Q3 = [\n    1.105924229346489121e-2, 1.52264338295331783612e-1, 8.48854343457902036425e-1,\n    2.59301921623620271374, 4.77846592945843778382, 5.38168345707006855425,\n    3.46625407242567245975, 1,\n];\nconst Y4 = 9.3995571136474609375e-1;\nconst P4 = [\n    2.66339227425782031962e-12, -2.30404776911882601748e-10,\n    4.60469890584317994083e-6, 1.57544617424960554631e-4,\n    1.87123492819559223345e-3, 9.50804701325919603619e-3,\n    1.85573306514231072324e-2, -2.22426529213447927281e-3,\n    -3.50353787183177984712e-2,\n];\nconst Q4 = [\n    7.64675292302794483503e-5, 2.63861676657015992959e-3,\n    3.41589143670947727934e-2, 2.20091105764131249824e-1,\n    7.62059164553623404043e-1, 1.3653349817554063097, 1,\n];\nconst Y5 = 9.8362827301025390625e-1;\nconst P5 = [\n    9.9055709973310326855e-17, -2.81128735628831791805e-14,\n    4.62596163522878599135e-9, 4.49696789927706453732e-7,\n    1.49624783758342370182e-5, 2.09386317487588078668e-4,\n    1.05628862152492910091e-3, -1.12951438745580278863e-3,\n    -1.67431005076633737133e-2,\n];\nconst Q5 = [\n    2.82243172016108031869e-7, 2.75335474764726041141e-5,\n    9.64011807005165528527e-4, 1.60746087093676504695e-2,\n    1.38151865749083321638e-1, 5.91429344886417493481e-1, 1,\n];\n/**\n * Polyval.\n * @param c - Array of Number.\n * @param x - Number.\n * @returns Number.\n */\nfunction polyval(c, x) {\n    let p = 0;\n    for (const coef of c) {\n        p = p * x + coef;\n    }\n    return p;\n}\n/**\n * Calculates a rational approximation.\n * @private\n * @param x - Number.\n * @param v - Number.\n * @param P - Array of polynomial coefficients.\n * @param Q - Array of polynomial coefficients.\n * @param Y - Number.\n * @returns Rational approximation.\n */\nfunction calc(x, v, P, Q, Y) {\n    const s = x - v;\n    const r = polyval(P, s) / polyval(Q, s);\n    return Y * x + r * x;\n}\n/**\n * Evaluates the complementary inverse error function for an input value.\n * @private\n * @param x - Input value.\n * @returns Evaluated complementary inverse error function.\n */\nexport default function erfcinv(x) {\n    let sign = false;\n    let val;\n    let q;\n    let g;\n    let r;\n    // [1] Special cases...\n    // NaN:\n    if (Number.isNaN(x)) {\n        return Number.NaN;\n    }\n    // x not on the interval: [0,2]\n    if (x < 0 || x > 2) {\n        throw new RangeError(`erfcinv()::invalid input argument. Value must be on the interval [0,2]. Value: \\`${x}\\`.`);\n    }\n    if (x === 0) {\n        return Number.POSITIVE_INFINITY;\n    }\n    if (x === 2) {\n        return Number.NEGATIVE_INFINITY;\n    }\n    if (x === 1) {\n        return 0;\n    }\n    // [2] Get the sign and make use of `erfc` reflection formula: `erfc(-z)=2 - erfc(z)`...\n    if (x > 1) {\n        q = 2 - x;\n        x = 1 - q;\n        sign = true;\n    }\n    else {\n        q = x;\n        x = 1 - x;\n    }\n    // [3] |x| <= 0.5\n    if (x <= 0.5) {\n        g = x * (x + 10);\n        r = polyval(P1, x) / polyval(Q1, x);\n        val = g * Y1 + g * r;\n        return sign ? -val : val;\n    }\n    // [4] 1-|x| >= 0.25\n    if (q >= 0.25) {\n        g = Math.sqrt(-2 * Math.log(q));\n        q = q - 0.25;\n        r = polyval(P2, q) / polyval(Q2, q);\n        val = g / (Y2 + r);\n        return sign ? -val : val;\n    }\n    q = Math.sqrt(-Math.log(q));\n    // [5] q < 3\n    if (q < 3) {\n        return calc(q, 1.125, P3, Q3, Y3);\n    }\n    // [6] q < 6\n    if (q < 6) {\n        return calc(q, 3, P4, Q4, Y4);\n    }\n    // Note that the smallest number in JavaScript is 5e-324. Math.sqrt( -Math.log( 5e-324 ) ) ~27.2844\n    return calc(q, 6, P5, Q5, Y5);\n    // Note that in the boost library, they are able to go to much smaller values, as 128 bit long doubles support ~1e-5000; something which JavaScript does not natively support.\n}\n//# sourceMappingURL=erfcinv.js.map","import erfcinv from \"./erfcinv.js\";\n/**\n * Applies a simple normalization inverse transformation to the input data.\n * @param data - The input array of numbers to be transformed.\n * @param options - Optional parameters for the transformation.\n * @returns A new Float64Array containing the transformed data.\n */\nexport function simpleNormInv(data, options = {}) {\n    const { magnitudeMode = false } = options;\n    const result = new Float64Array(data.length);\n    if (magnitudeMode) {\n        for (let i = 0; i < result.length; i++) {\n            result[i] = -Math.sqrt(-2 * Math.log(1 - data[i]));\n        }\n    }\n    else {\n        for (let i = 0; i < result.length; i++) {\n            result[i] = -1 * Math.SQRT2 * erfcinv(2 * data[i]);\n        }\n    }\n    return result;\n}\n/**\n * Convenience wrapper for single number processing by simpleNormInv function.\n * @param data - The number to be normalized.\n * @param options - The options for the normalization process.\n * @returns The normalized number.\n */\nexport function simpleNormInvNumber(data, options = {}) {\n    return simpleNormInv([data], options)[0];\n}\n//# sourceMappingURL=simpleNormInv.js.map","import { isAnyArray } from 'is-any-array';\nimport { createFromToArray } from \"../utils/index.js\";\nimport { simpleNormInvNumber } from \"./utils/simpleNormInv.js\";\nimport { xEnsureFloat64 } from \"./xEnsureFloat64.js\";\n/**\n * Determine noise level by san plot methodology (https://doi.org/10.1002/mrc.4882)\n * @param array - real or magnitude spectra data.\n * @param options - options\n * @returns noise level\n */\nexport function xNoiseSanPlot(array, options = {}) {\n    const { mask, cutOff, refine = true, magnitudeMode = false, scaleFactor = 1, factorStd = 5, fixOffset = true, } = options;\n    const input = prepareData(array, { scaleFactor, mask });\n    if (fixOffset && !magnitudeMode) {\n        const medianIndex = Math.floor(input.length / 2);\n        const median = input.length % 2 === 0\n            ? 0.5 * (input[medianIndex - 1] + input[medianIndex])\n            : input[medianIndex];\n        for (let i = 0; i < input.length; i++) {\n            input[i] -= median;\n        }\n    }\n    const firstNegativeValueIndex = input.at(-1) >= 0\n        ? input.length\n        : input.findIndex((e) => e < 0);\n    let lastPositiveValueIndex = firstNegativeValueIndex - 1;\n    for (let i = lastPositiveValueIndex; i >= 0; i--) {\n        if (input[i] > 0) {\n            lastPositiveValueIndex = i;\n            break;\n        }\n    }\n    const signPositive = input.slice(0, lastPositiveValueIndex + 1);\n    const signNegative = input.slice(firstNegativeValueIndex);\n    const cutOffDist = cutOff || determineCutOff(signPositive, { magnitudeMode });\n    const pIndex = Math.floor(signPositive.length * cutOffDist);\n    const initialNoiseLevelPositive = signPositive[pIndex];\n    const skyPoint = signPositive[0];\n    let initialNoiseLevelNegative;\n    if (signNegative.length > 0) {\n        const nIndex = Math.floor(signNegative.length * (1 - cutOffDist));\n        initialNoiseLevelNegative = -1 * signNegative[nIndex];\n    }\n    else {\n        initialNoiseLevelNegative = 0;\n    }\n    let noiseLevelPositive = initialNoiseLevelPositive;\n    let noiseLevelNegative = initialNoiseLevelNegative;\n    let cloneSignPositive = signPositive.slice();\n    let cloneSignNegative = signNegative.slice();\n    let cutOffSignalsIndexPlus = 0;\n    let cutOffSignalsIndexNeg = 2;\n    if (refine) {\n        let cutOffSignals = noiseLevelPositive * factorStd;\n        cutOffSignalsIndexPlus = signPositive.findIndex((e) => e < cutOffSignals);\n        if (cutOffSignalsIndexPlus > -1) {\n            cloneSignPositive = signPositive.slice(cutOffSignalsIndexPlus);\n            noiseLevelPositive =\n                cloneSignPositive[Math.floor(cloneSignPositive.length * cutOffDist)];\n        }\n        cutOffSignals = noiseLevelNegative * factorStd;\n        cutOffSignalsIndexNeg = signNegative.findIndex((e) => e < cutOffSignals);\n        if (cutOffSignalsIndexNeg > -1) {\n            cloneSignNegative = signNegative.slice(cutOffSignalsIndexNeg);\n            noiseLevelNegative =\n                cloneSignPositive[Math.floor(cloneSignNegative.length * (1 - cutOffDist))];\n        }\n    }\n    const correctionFactor = -simpleNormInvNumber(cutOffDist / 2, {\n        magnitudeMode,\n    });\n    let effectiveCutOffDist, refinedCorrectionFactor;\n    if (refine && cutOffSignalsIndexPlus > -1) {\n        effectiveCutOffDist =\n            (cutOffDist * cloneSignPositive.length + cutOffSignalsIndexPlus) /\n                (cloneSignPositive.length + cutOffSignalsIndexPlus);\n        refinedCorrectionFactor =\n            -1 * simpleNormInvNumber(effectiveCutOffDist / 2, { magnitudeMode });\n        noiseLevelPositive /= refinedCorrectionFactor;\n        if (cutOffSignalsIndexNeg > -1) {\n            effectiveCutOffDist =\n                (cutOffDist * cloneSignNegative.length + cutOffSignalsIndexNeg) /\n                    (cloneSignNegative.length + cutOffSignalsIndexNeg);\n            refinedCorrectionFactor =\n                -1 * simpleNormInvNumber(effectiveCutOffDist / 2, { magnitudeMode });\n            if (noiseLevelNegative !== 0) {\n                noiseLevelNegative /= refinedCorrectionFactor;\n            }\n        }\n    }\n    else {\n        noiseLevelPositive /= correctionFactor;\n        noiseLevelNegative /= correctionFactor;\n    }\n    return {\n        positive: noiseLevelPositive,\n        negative: noiseLevelNegative,\n        snr: skyPoint / noiseLevelPositive,\n        sanplot: generateSanPlot(input, {\n            fromTo: {\n                positive: { from: 0, to: lastPositiveValueIndex },\n                negative: { from: firstNegativeValueIndex, to: input.length },\n            },\n        }),\n    };\n}\n/**\n * Determines the optimal cut-off point for a given array of positive numbers.\n * @param signPositive - An array of positive numbers.\n * @param options - Optional parameters to configure the cut-off determination.\n * @param options.magnitudeMode - If true, uses magnitude mode for normalization. Default is false.\n * @param options.considerList - An object specifying the range and step for consideration.\n * @param options.considerList.from - The starting point of the range. Default is 0.5.\n * @param options.considerList.step - The step size for the range. Default is 0.1.\n * @param options.considerList.to - The ending point of the range. Default is 0.9.\n * @returns The optimal cut-off point as a number.\n */\nfunction determineCutOff(signPositive, options = {}) {\n    const { magnitudeMode = false, considerList = { from: 0.5, step: 0.1, to: 0.9 }, } = options;\n    //generate a list of values for\n    const cutOff = [];\n    const indexMax = signPositive.length - 1;\n    for (let i = 0.01; i <= 0.99; i += 0.01) {\n        const index = Math.round(indexMax * i);\n        const value = -signPositive[index] / simpleNormInvNumber(i / 2, { magnitudeMode });\n        cutOff.push([i, value]);\n    }\n    let minKi = Number.MAX_SAFE_INTEGER;\n    const { from, to, step } = considerList;\n    const delta = step / 2;\n    let whereToCutStat = 0.5;\n    for (let i = from; i <= to; i += step) {\n        const floor = i - delta;\n        const top = i + delta;\n        const elementsOfCutOff = cutOff.filter((e) => e[0] < top && e[0] > floor);\n        let averageValue = 0;\n        for (const element of elementsOfCutOff) {\n            averageValue += Math.abs(element[1]);\n        }\n        let kiSqrt = 0;\n        for (const element of elementsOfCutOff) {\n            kiSqrt += (element[1] - averageValue) ** 2;\n        }\n        if (kiSqrt < minKi) {\n            minKi = kiSqrt;\n            whereToCutStat = i;\n        }\n    }\n    return whereToCutStat;\n}\n/**\n * Generates a SAN plot from the given array based on the specified options.\n * @param array - The input array of numbers to be processed.\n * @param options - An optional object containing configuration options.\n * @param options.logBaseY - The logarithmic base for the Y-axis. Defaults to 2.\n * @param options.fromTo - An object specifying the range for each key. Each key maps to an object with `from` and `to` properties.\n * @returns An object where each key maps to a DataXY object containing the processed data.\n */\nfunction generateSanPlot(array, options = {}) {\n    const { fromTo, logBaseY = 2 } = options;\n    const sanplot = {};\n    for (const key in fromTo) {\n        const { from, to } = fromTo[key];\n        sanplot[key] =\n            from !== to\n                ? scale(array.slice(from, to), {\n                    logBaseY,\n                })\n                : { x: [], y: [] };\n        if (key === 'negative') {\n            sanplot[key].y.reverse();\n        }\n    }\n    return sanplot;\n}\n/**\n * Scales the input array based on the provided options.\n * @param array - The input array to be scaled.\n * @param options - An optional object containing scaling options.\n * @param options.logBaseY - If provided, the array values will be scaled using the logarithm of this base.\n * @returns An object containing the scaled x and y arrays.\n */\nfunction scale(array, options = {}) {\n    const { log10, abs } = Math;\n    const { logBaseY } = options;\n    if (logBaseY) {\n        array = array.slice(0);\n        const logOfBase = log10(logBaseY);\n        for (let i = 0; i < array.length; i++) {\n            array[i] = log10(abs(array[i])) / logOfBase;\n        }\n    }\n    const xAxis = createFromToArray({\n        from: 0,\n        to: array.length - 1,\n        length: array.length,\n    });\n    return { x: xAxis, y: array };\n}\n/**\n * Prepares and processes the input data array based on the provided options.\n * @param array - The input array of numbers to be processed.\n * @param options - An object containing the following properties:\n *   - scaleFactor: A number by which to scale each element of the array.\n *   - mask: An optional array of the same length as the input array, where\n *           elements corresponding to `true` values will be excluded from processing.\n * @param options.scaleFactor\n * @param options.mask\n * @returns A new Float64Array containing the processed data, scaled by the\n *          scaleFactor and sorted in descending order.\n */\nfunction prepareData(array, options) {\n    const { scaleFactor, mask } = options;\n    const input = xEnsureFloat64(isAnyArray(mask) && mask.length === array.length\n        ? array.filter((_e, i) => !mask[i])\n        : array);\n    if (scaleFactor > 1) {\n        for (let i = 0; i < input.length; i++) {\n            input[i] *= scaleFactor;\n        }\n    }\n    input.sort();\n    input.reverse();\n    return input;\n}\n//# sourceMappingURL=xNoiseSanPlot.js.map","import { xCheck } from \"./xCheck.js\";\n/**\n * Returns a copy of the data as a Float64Array.\n * @param array - array of numbers\n */\nexport function xEnsureFloat64(array) {\n    xCheck(array);\n    if (array instanceof Float64Array) {\n        return array.slice(0);\n    }\n    return Float64Array.from(array);\n}\n//# sourceMappingURL=xEnsureFloat64.js.map","/**\n * Create an array with numbers between \"from\" and \"to\" of length \"length\"\n * @param options - options\n * @returns - array of distributed numbers between \"from\" and \"to\"\n */\nexport function createFromToArray(options = {}) {\n    const { from = 0, to = 1, length = 1000, includeFrom = true, includeTo = true, distribution = 'uniform', } = options;\n    const array = new Float64Array(length);\n    let div = length;\n    if (includeFrom && includeTo) {\n        div = length - 1;\n    }\n    else if ((!includeFrom && includeTo) || (includeFrom && !includeTo)) {\n        div = length;\n    }\n    else if (!includeFrom && !includeTo) {\n        div = length + 1;\n    }\n    const delta = (to - from) / div;\n    if (distribution === 'uniform') {\n        if (includeFrom) {\n            let index = 0;\n            while (index < length) {\n                array[index] = from + delta * index;\n                index++;\n            }\n        }\n        else {\n            let index = 0;\n            while (index < length) {\n                array[index] = from + delta * (index + 1);\n                index++;\n            }\n        }\n    }\n    else if (distribution === 'log') {\n        const base = (to / from) ** (1 / div);\n        const firstExponent = Math.log(from) / Math.log(base);\n        if (includeFrom) {\n            let index = 0;\n            while (index < length) {\n                array[index] = base ** (firstExponent + index);\n                index++;\n            }\n        }\n        else {\n            let index = 0;\n            while (index < length) {\n                array[index] = base ** (firstExponent + index + 1);\n                index++;\n            }\n        }\n    }\n    else {\n        throw new Error('distribution must be uniform or log');\n    }\n    return array;\n}\n//# sourceMappingURL=createFromToArray.js.map","// Based on https://github.com/scijs/cholesky-solve\nfunction ldlSymbolic(n, Ap, Ai, Lp, Parent, Lnz, Flag) {\n    let i, k, p, kk, p2;\n    for (k = 0; k < n; k++) {\n        /* L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k) */\n        Parent[k] = -1; /* parent of k is not yet known */\n        Flag[k] = k; /* mark node k as visited */\n        Lnz[k] = 0; /* count of nonzeros in column k of L */\n        kk = k; /* kth original, or permuted, column */\n        p2 = Ap[kk + 1];\n        for (p = Ap[kk]; p < p2; p++) {\n            /* A (i,k) is nonzero (original or permuted A) */\n            i = Ai[p];\n            if (i < k) {\n                /* follow path from i to root of etree, stop at flagged node */\n                for (; Flag[i] !== k; i = Parent[i]) {\n                    /* find parent of i if not yet determined */\n                    if (Parent[i] === -1)\n                        Parent[i] = k;\n                    Lnz[i]++; /* L (k,i) is nonzero */\n                    Flag[i] = k; /* mark i as visited */\n                }\n            }\n        }\n    }\n    /* construct Lp index array from Lnz column counts */\n    Lp[0] = 0;\n    for (k = 0; k < n; k++) {\n        Lp[k + 1] = Lp[k] + Lnz[k];\n    }\n}\nfunction ldlNumeric(n, Ap, Ai, Ax, Lp, Parent, Lnz, Li, Lx, D, Y, Pattern, Flag) {\n    let yi, lKi;\n    let i, k, p, kk, p2, len, top;\n    for (k = 0; k < n; k++) {\n        /* compute nonzero Pattern of kth row of L, in topological order */\n        Y[k] = 0; /* Y(0:k) is now all zero */\n        top = n; /* stack for pattern is empty */\n        Flag[k] = k; /* mark node k as visited */\n        Lnz[k] = 0; /* count of nonzeros in column k of L */\n        kk = k; /* kth original, or permuted, column */\n        p2 = Ap[kk + 1];\n        for (p = Ap[kk]; p < p2; p++) {\n            i = Ai[p]; /* get A(i,k) */\n            if (i <= k) {\n                Y[i] += Ax[p]; /* scatter A(i,k) into Y (sum duplicates) */\n                for (len = 0; Flag[i] !== k; i = Parent[i]) {\n                    Pattern[len++] = i; /* L(k,i) is nonzero */\n                    Flag[i] = k; /* mark i as visited */\n                }\n                while (len > 0)\n                    Pattern[--top] = Pattern[--len];\n            }\n        }\n        /* compute numerical values kth row of L (a sparse triangular solve) */\n        D[k] = Y[k]; /* get D(k,k) and clear Y(k) */\n        Y[k] = 0;\n        for (; top < n; top++) {\n            i = Pattern[top]; /* Pattern[top:n-1] is pattern of L(:,k) */\n            yi = Y[i]; /* get and clear Y(i) */\n            Y[i] = 0;\n            p2 = Lp[i] + Lnz[i];\n            for (p = Lp[i]; p < p2; p++) {\n                Y[Li[p]] -= Lx[p] * yi;\n            }\n            lKi = yi / D[i]; /* the nonzero entry L(k,i) */\n            D[k] -= lKi * yi;\n            Li[p] = k; /* store L(k,i) in column form of L */\n            Lx[p] = lKi;\n            Lnz[i]++; /* increment count of nonzeros in col i */\n        }\n        if (D[k] === 0)\n            return k; /* failure, D(k,k) is zero */\n    }\n    return n; /* success, diagonal of D is all nonzero */\n}\nfunction ldlLsolve(n, X, Lp, Li, Lx) {\n    let j, p, p2;\n    for (j = 0; j < n; j++) {\n        p2 = Lp[j + 1];\n        for (p = Lp[j]; p < p2; p++) {\n            X[Li[p]] -= Lx[p] * X[j];\n        }\n    }\n}\nfunction ldlDsolve(n, X, D) {\n    let j;\n    for (j = 0; j < n; j++) {\n        X[j] /= D[j];\n    }\n}\nfunction ldlLTsolve(n, X, Lp, Li, Lx) {\n    let j, p, p2;\n    for (j = n - 1; j >= 0; j--) {\n        p2 = Lp[j + 1];\n        for (p = Lp[j]; p < p2; p++) {\n            X[j] -= Lx[p] * X[Li[p]];\n        }\n    }\n}\nfunction ldlPerm(n, X, B, P) {\n    let j;\n    for (j = 0; j < n; j++) {\n        X[j] = B[P[j]];\n    }\n}\nfunction ldlPermt(n, X, B, P) {\n    let j;\n    for (j = 0; j < n; j++) {\n        X[P[j]] = B[j];\n    }\n}\n/**\n * Prepares a sparse matrix for Cholesky decomposition and returns a solver function.\n * @param M - Sparse matrix in triplet format (array of [row, col, value] entries).\n * @param n - Size of the matrix (n-by-n).\n * @param P - Optional permutation array of size n.\n * @returns A solver function that takes a right-hand side vector and returns the solution, or null if decomposition fails.\n */\nfunction prepare(M, n, P) {\n    // if a permutation was specified, apply it.\n    if (P) {\n        const Pinv = new Array(n);\n        for (let k = 0; k < n; k++) {\n            Pinv[P[k]] = k;\n        }\n        const Mt = []; // scratch memory\n        // Apply permutation. We make M into P*M*P^T\n        for (let a = 0; a < M.length; ++a) {\n            let ar = Pinv[M[a][0]];\n            let ac = Pinv[M[a][1]];\n            // we only store the upper-diagonal elements(since we assume matrix is symmetric, we only need to store these)\n            // if permuted element is below diagonal, we simply transpose it.\n            if (ac < ar) {\n                const t = ac;\n                ac = ar;\n                ar = t;\n            }\n            Mt[a] = [];\n            Mt[a][0] = ar;\n            Mt[a][1] = ac;\n            Mt[a][2] = M[a][2];\n        }\n        M = Mt; // copy scratch memory.\n    }\n    else {\n        // if P argument is null, we just use an identity permutation.\n        P = [];\n        for (let i = 0; i < n; ++i) {\n            P[i] = i;\n        }\n    }\n    // The sparse matrix we are decomposing is A.\n    // Now we shall create A from M.\n    const Ap = new Array(n + 1);\n    const Ai = new Array(M.length);\n    const Ax = new Array(M.length);\n    // count number of non-zero elements in columns.\n    const LNZ = [];\n    for (let i = 0; i < n; ++i) {\n        LNZ[i] = 0;\n    }\n    for (const entry of M) {\n        LNZ[entry[1]]++;\n    }\n    Ap[0] = 0;\n    for (let i = 0; i < n; ++i) {\n        Ap[i + 1] = Ap[i] + LNZ[i];\n    }\n    const coloffset = [];\n    for (let a = 0; a < n; ++a) {\n        coloffset[a] = 0;\n    }\n    // go through all elements in M, and add them to sparse matrix A.\n    for (const e of M) {\n        const col = e[1];\n        const adr = Ap[col] + coloffset[col];\n        Ai[adr] = e[0];\n        Ax[adr] = e[2];\n        coloffset[col]++;\n    }\n    const D = new Array(n);\n    const Y = new Array(n);\n    const Lp = new Array(n + 1);\n    const Parent = new Array(n);\n    const Lnz = new Array(n);\n    const Flag = new Array(n);\n    const Pattern = new Array(n);\n    const bp1 = new Array(n);\n    const x = new Array(n);\n    ldlSymbolic(n, Ap, Ai, Lp, Parent, Lnz, Flag);\n    const Lx = new Array(Lp[n]);\n    const Li = new Array(Lp[n]);\n    const d = ldlNumeric(n, Ap, Ai, Ax, Lp, Parent, Lnz, Li, Lx, D, Y, Pattern, Flag);\n    if (d === n) {\n        return (b) => {\n            ldlPerm(n, bp1, b, P);\n            ldlLsolve(n, bp1, Lp, Li, Lx);\n            ldlDsolve(n, bp1, D);\n            ldlLTsolve(n, bp1, Lp, Li, Lx);\n            ldlPermt(n, x, bp1, P);\n            return x;\n        };\n    }\n    else {\n        return null;\n    }\n}\nexport default prepare;\n//# sourceMappingURL=choleskySolver.js.map","'use strict'\n\nmodule.exports = cuthillMckee\n\nfunction compareNum(a, b) { return a - b }\n\nfunction cuthillMckee(list, n) {\n  var adj = new Array(n)\n  var visited = new Array(n)\n  for(var i=0; i<n; ++i) {\n    adj[i]     = []\n    visited[i] = false\n  }\n\n  for(var i=0; i<list.length; ++i) {\n    var l = list[i]\n    adj[l[0]].push(l[1])\n  }\n\n  var toVisit = new Array(n)\n  var eol = 0\n  var ptr = 0\n  for(var i=0; i<n; ++i) {\n    if(visited[i]) {\n      continue\n    }\n    toVisit[eol++] = i\n    visited[i] = true\n    while(ptr < eol) {\n      var v = toVisit[ptr++]\n      var nbhd = adj[v]\n      nbhd.sort(compareNum)\n      for(var j=0; j<nbhd.length; ++j) {\n        var u = nbhd[j]\n        if(visited[u]) {\n          continue\n        }\n        visited[u] = true\n        toVisit[eol++] = u\n      }\n    }\n  }\n\n  var result = new Array(n)\n  for(var i=0; i<n; ++i) {\n    result[toVisit[i]] = i\n  }\n\n  return result\n}\n","import cuthillMckee from 'cuthill-mckee';\n/**\n * Updates the system matrix with new weights and computes the weighted right-hand side vector.\n * @param matrix - The lower triangular non-zeros matrix in triplet format.\n * @param y - The original data vector.\n * @param weights - The weights vector.\n * @returns A tuple of the updated matrix and the weighted right-hand side vector.\n */\nexport function updateSystem(matrix, y, weights) {\n    const nbPoints = y.length;\n    const l = nbPoints - 1;\n    const newMatrix = new Array(matrix.length);\n    const newVector = new Float64Array(nbPoints);\n    for (let i = 0; i < l; i++) {\n        const w = weights[i];\n        const diag = i * 2;\n        const next = diag + 1;\n        newMatrix[diag] = matrix[diag].slice();\n        newMatrix[next] = matrix[next].slice();\n        if (w === 0) {\n            newVector[i] = 0;\n        }\n        else {\n            newVector[i] = y[i] * w;\n            newMatrix[diag][2] += w;\n        }\n    }\n    newVector[l] = y[l] * weights[l];\n    newMatrix[l * 2] = matrix[l * 2].slice();\n    newMatrix[l * 2][2] += weights[l];\n    return [newMatrix, newVector];\n}\n/**\n * Constructs the delta matrix and applies Cuthill-McKee permutation.\n * @param nbPoints - Number of data points.\n * @param lambda - Smoothing parameter.\n * @returns An object containing the lower triangular non-zeros matrix and the permutation array.\n */\nexport function getDeltaMatrix(nbPoints, lambda) {\n    const matrix = [];\n    const last = nbPoints - 1;\n    for (let i = 0; i < last; i++) {\n        matrix.push([i, i, lambda * 2], [i + 1, i, -1 * lambda]);\n    }\n    matrix[0][2] = lambda;\n    matrix.push([last, last, lambda]);\n    return {\n        lowerTriangularNonZeros: matrix,\n        permutationEncodedArray: cuthillMckee(matrix, nbPoints),\n    };\n}\n//# sourceMappingURL=utils.js.map","import { xAbsoluteSum, xFindClosestIndex, xMultiply, xNoiseSanPlot, } from 'ml-spectra-processing';\nimport cholesky from \"./choleskySolver.js\";\nimport { getDeltaMatrix, updateSystem } from \"./utils.js\";\n/**\n * Fit the baseline drift by iteratively changing weights of sum square error between the fitted baseline and original signals,\n * for further information about the parameters you can get the {@link https://github.com/zmzhang/airPLS/blob/main/airPLS_manuscript.pdf paper of airPLS}.\n * @param x - X axis data useful when control points or zones are submitted.\n * @param y - Original data.\n * @param options - Options object.\n * @returns An object containing the corrected data, baseline, iteration count, and error.\n */\nexport default function airPLS(x, y, options = {}) {\n    const { weights, controlPoints } = getControlPoints(x, y, options);\n    const { maxIterations = 100, lambda = 10, tolerance = 0.001 } = options;\n    let baseline = [];\n    let iteration;\n    let sumNegDifferences = Number.MAX_SAFE_INTEGER;\n    const corrected = Float64Array.from(y);\n    const stopCriterion = getStopCriterion(y, tolerance);\n    const { length } = y;\n    const { lowerTriangularNonZeros, permutationEncodedArray } = getDeltaMatrix(length, lambda);\n    let threshold = 1;\n    const l = length - 1;\n    let prevNegSum = Number.MAX_SAFE_INTEGER;\n    for (iteration = 0; iteration < maxIterations && Math.abs(sumNegDifferences) > stopCriterion; iteration++) {\n        const [leftHandSide, rightHandSide] = updateSystem(lowerTriangularNonZeros, y, weights);\n        const cho = cholesky(leftHandSide, length, permutationEncodedArray);\n        if (cho === null) {\n            throw new Error('Cholesky decomposition failed');\n        }\n        baseline = cho(rightHandSide);\n        sumNegDifferences = applyCorrection(y, baseline, corrected);\n        if (iteration === 1) {\n            const { positive } = xNoiseSanPlot(corrected);\n            threshold = positive;\n        }\n        else {\n            const absChange = Math.abs(prevNegSum / sumNegDifferences);\n            if (absChange < 1.01 && absChange > 0.99) {\n                break;\n            }\n        }\n        prevNegSum = sumNegDifferences + 0;\n        const absoluteSumNegatives = Math.abs(sumNegDifferences);\n        for (let i = 1; i < l; i++) {\n            const absDiff = Math.abs(corrected[i]);\n            const weight = Math.exp((-iteration * absDiff) / absoluteSumNegatives);\n            weights[i] =\n                controlPoints[i] < 1 && absDiff > threshold ? weight / 4 : weight;\n        }\n        weights[0] = 1;\n        weights[l] = 1;\n    }\n    return {\n        corrected,\n        baseline,\n        iteration,\n        error: sumNegDifferences,\n    };\n}\nfunction applyCorrection(y, baseline, corrected) {\n    let sumNegDifferences = 0;\n    for (let i = 0; i < y.length; i++) {\n        const diff = y[i] - baseline[i];\n        if (diff < 0)\n            sumNegDifferences += diff;\n        corrected[i] = diff;\n    }\n    return sumNegDifferences;\n}\nfunction getStopCriterion(y, tolerance) {\n    const sum = xAbsoluteSum(y);\n    return tolerance * sum;\n}\nfunction getControlPoints(x, y, options = {}) {\n    const { length } = x;\n    const { controlPoints = Int8Array.from({ length }).fill(0) } = options;\n    const { zones = [], weights = Float64Array.from({ length }).fill(0.5) } = options;\n    if (x.length !== y.length) {\n        throw new RangeError('Y should match the length with X');\n    }\n    else if (controlPoints.length !== x.length) {\n        throw new RangeError('controlPoints should match the length with X');\n    }\n    else if (weights.length !== x.length) {\n        throw new RangeError('weights should match the length with X');\n    }\n    for (const range of zones) {\n        let indexFrom = xFindClosestIndex(x, range.from);\n        let indexTo = xFindClosestIndex(x, range.to);\n        if (indexFrom > indexTo)\n            [indexFrom, indexTo] = [indexTo, indexFrom];\n        for (let i = indexFrom; i < indexTo; i++) {\n            controlPoints[i] = 1;\n        }\n    }\n    return {\n        weights: 'controlPoints' in options || zones.length > 0\n            ? xMultiply(weights, controlPoints)\n            : weights,\n        controlPoints,\n    };\n}\n//# sourceMappingURL=index.js.map"],"names":["toString","Object","prototype","isAnyArray","value","tag","call","endsWith","includes","xCheck","input","options","minLength","TypeError","length","Error","xFindClosestIndex","array","target","sorted","low","high","middle","Math","abs","index","diff","Number","POSITIVE_INFINITY","i","currentDiff","xAbsoluteSum","fromIndex","toIndex","x","from","to","undefined","xGetFromToIndex","sum","xMultiply","array1","array2","isConstant","constant","array3","output","Float64Array","getOutputArray","FFT","size","this","_csize","table","Array","angle","PI","cos","sin","power","t","_width","_bitrev","j","shift","revShift","_out","_data","_inv","fromComplexArray","complex","storage","res","createComplexArray","toComplexArray","completeSpectrum","spectrum","half","transform","out","data","_transform4","realTransform","_realTransform4","inverseTransform","outOff","step","len","bitrev","off","_singleTransform2","_singleTransform4","inv","quarterLen","limit","k","A","B","C","D","Ar","Ai","Br","Bi","Cr","Ci","Dr","Di","MAr","MAi","tableBr","tableBi","MBr","MBi","tableCr","tableCi","MCr","MCi","tableDr","tableDi","MDr","MDi","T0r","T0i","T1r","T1i","T2r","T2i","T3r","T3i","FAr","FAi","FCr","FCi","FBr","FBi","FDr","FDi","evenR","evenI","oddR","oddI","leftR","leftI","rightR","rightI","step2","step3","_singleRealTransform2","_singleRealTransform4","halfLen","hquarterLen","SFAr","SFAi","SFBr","SFBi","SA","SB","P1","Q1","P2","Q2","P3","Q3","P4","Q4","P5","Q5","polyval","c","p","coef","calc","v","P","Q","Y","s","erfcinv","val","q","g","r","sign","isNaN","NaN","RangeError","NEGATIVE_INFINITY","sqrt","log","simpleNormInvNumber","magnitudeMode","result","SQRT2","simpleNormInv","xNoiseSanPlot","mask","cutOff","refine","scaleFactor","factorStd","fixOffset","slice","xEnsureFloat64","filter","_e","sort","reverse","prepareData","medianIndex","floor","median","firstNegativeValueIndex","at","findIndex","e","lastPositiveValueIndex","signPositive","signNegative","cutOffDist","considerList","indexMax","round","push","minKi","MAX_SAFE_INTEGER","delta","whereToCutStat","top","elementsOfCutOff","averageValue","element","kiSqrt","determineCutOff","initialNoiseLevelPositive","skyPoint","initialNoiseLevelNegative","noiseLevelPositive","noiseLevelNegative","cloneSignPositive","cloneSignNegative","cutOffSignalsIndexPlus","cutOffSignalsIndexNeg","cutOffSignals","correctionFactor","effectiveCutOffDist","refinedCorrectionFactor","positive","negative","snr","sanplot","generateSanPlot","fromTo","logBaseY","key","scale","y","log10","logOfBase","xAxis","includeFrom","includeTo","distribution","div","base","firstExponent","createFromToArray","prepare","M","n","Pinv","Mt","a","ar","ac","Ap","Ax","LNZ","entry","coloffset","col","adr","Lp","Parent","Lnz","Flag","Pattern","bp1","kk","p2","ldlSymbolic","Lx","Li","d","yi","lKi","ldlNumeric","b","X","ldlPerm","ldlLsolve","ldlDsolve","ldlLTsolve","ldlPermt","compareNum","list","adj","visited","l","toVisit","eol","ptr","nbhd","u","updateSystem","matrix","weights","nbPoints","newMatrix","newVector","w","diag","next","airPLS","controlPoints","Int8Array","fill","zones","range","indexFrom","indexTo","getControlPoints","maxIterations","lambda","tolerance","iteration","baseline","sumNegDifferences","corrected","stopCriterion","getStopCriterion","lowerTriangularNonZeros","permutationEncodedArray","last","cuthillMckee","getDeltaMatrix","threshold","prevNegSum","leftHandSide","rightHandSide","cho","cholesky","applyCorrection","absChange","absoluteSumNegatives","absDiff","weight","exp","error"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,14]}