{"version":3,"file":"ml-airpls.esm.js","sources":["../node_modules/is-any-array/lib/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/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib/x/xAbsoluteSum.js","../node_modules/ml-spectra-processing/lib/x/xBinning.js","../node_modules/ml-spectra-processing/lib/x/xEnsureFloat64.js","../node_modules/ml-spectra-processing/lib/utils/createFromToArray.js","../node_modules/ml-spectra-processing/lib/x/xSubtract.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/matrix/matrixCholeskySolver.js","../node_modules/ml-spectra-processing/lib/matrix/matrixCuthillMckee.js","../node_modules/ml-spectra-processing/lib/xy/xyCheck.js","../node_modules/ml-spectra-processing/lib/xy/xyInterpolateLinear.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 * @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 { 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 { 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 { xCheck } from \"./xCheck.js\";\n/**\n * Downsample an array by averaging consecutive non-overlapping points (binning).\n * Either specify a fixed `binSize` or a target `numberOfPoints`.\n * @param array - Input array.\n * @param options - Options.\n * @returns Downsampled array.\n */\nexport function xBinning(array, options = {}) {\n    xCheck(array);\n    const { binSize, numberOfPoints, keepFirstAndLast = true } = options;\n    const { length } = array;\n    if (numberOfPoints !== undefined) {\n        if (binSize !== undefined) {\n            throw new RangeError('binSize and numberOfPoints are mutually exclusive');\n        }\n        if (!Number.isInteger(numberOfPoints) || numberOfPoints <= 0) {\n            throw new RangeError('numberOfPoints must be a positive integer');\n        }\n        if (numberOfPoints > length) {\n            throw new RangeError('numberOfPoints must be <= array.length');\n        }\n        return binByNumberOfPoints(array, numberOfPoints, keepFirstAndLast);\n    }\n    const effectiveBinSize = binSize ?? 10;\n    if (!Number.isInteger(effectiveBinSize) || effectiveBinSize <= 0) {\n        throw new RangeError('binSize must be a positive integer');\n    }\n    if (effectiveBinSize === 1) {\n        return Float64Array.from(array);\n    }\n    if (keepFirstAndLast) {\n        if (length <= 2) {\n            return Float64Array.from(array);\n        }\n        const innerLength = length - 2;\n        const innerBinCount = Math.ceil(innerLength / effectiveBinSize);\n        const output = new Float64Array(innerBinCount + 2);\n        output[0] = array[0];\n        output[output.length - 1] = array[length - 1];\n        for (let i = 0, j = 1; i < innerLength; i += effectiveBinSize, j++) {\n            const start = i + 1;\n            const end = Math.min(start + effectiveBinSize, length - 1);\n            let sum = 0;\n            for (let k = start; k < end; k++) {\n                sum += array[k];\n            }\n            output[j] = sum / (end - start);\n        }\n        return output;\n    }\n    const outputLength = Math.ceil(length / effectiveBinSize);\n    const output = new Float64Array(outputLength);\n    for (let i = 0, j = 0; i < length; i += effectiveBinSize, j++) {\n        const end = Math.min(i + effectiveBinSize, length);\n        let sum = 0;\n        for (let k = i; k < end; k++) {\n            sum += array[k];\n        }\n        output[j] = sum / (end - i);\n    }\n    return output;\n}\nfunction binByNumberOfPoints(array, numberOfPoints, keepFirstAndLast) {\n    const { length } = array;\n    const output = new Float64Array(numberOfPoints);\n    if (keepFirstAndLast) {\n        if (numberOfPoints < 2) {\n            throw new RangeError('numberOfPoints must be >= 2 when keepFirstAndLast is true');\n        }\n        output[0] = array[0];\n        output[numberOfPoints - 1] = array[length - 1];\n        if (numberOfPoints === 2) {\n            return output;\n        }\n        const innerLength = length - 2;\n        const innerBins = numberOfPoints - 2;\n        for (let j = 0; j < innerBins; j++) {\n            const start = 1 + Math.floor((j * innerLength) / innerBins);\n            const end = 1 + Math.floor(((j + 1) * innerLength) / innerBins);\n            let sum = 0;\n            for (let k = start; k < end; k++) {\n                sum += array[k];\n            }\n            output[j + 1] = sum / (end - start);\n        }\n        return output;\n    }\n    for (let j = 0; j < numberOfPoints; j++) {\n        const start = Math.floor((j * length) / numberOfPoints);\n        const end = Math.floor(((j + 1) * length) / numberOfPoints);\n        let sum = 0;\n        for (let k = start; k < end; k++) {\n            sum += array[k];\n        }\n        output[j] = sum / (end - start);\n    }\n    return output;\n}\n//# sourceMappingURL=xBinning.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","import { isAnyArray } from 'is-any-array';\n/**\n * This function xSubtract the first array by the second array or a constant value from each element of the first array\n * @param array1 - the array that will be rotated\n * @param array2 - second array or number\n * @returns array after subtraction\n */\nexport function xSubtract(array1, array2) {\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 = new Float64Array(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=xSubtract.js.map","/*\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","/*\nThe MIT License (MIT)\n\nCopyright (c) 2013 Eric Arnebäck\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\nall copies 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\nTHE SOFTWARE.\n*/\n/**\n * Solves a system of linear equations using the Cholesky decomposition method.\n * It is a direct conversion to TS from {@link https://github.com/scijs/cholesky-solve}\n * @param nonZerosArray - The matrix in triplet form (array of arrays), where each sub-array contains three elements: row index, column index, and value.\n * @param dimension - The order of the matrix (number of rows/columns).\n * @param permutationEncoded - Optional permutation array. If provided, it will be used to permute the matrix.\n * @returns A function that takes a right-hand side vector `b` and returns the solution vector `x`, or `null` if the decomposition fails.\n */\nexport function matrixCholeskySolver(nonZerosArray, dimension, permutationEncoded) {\n    if (permutationEncoded) {\n        const pinv = new Int32Array(dimension);\n        for (let k = 0; k < dimension; k++) {\n            pinv[permutationEncoded[k]] = k;\n        }\n        // Build a permuted copy (kept as plain arrays for compatibility)\n        const mt = new Array(nonZerosArray.length);\n        for (let a = 0; a < nonZerosArray.length; ++a) {\n            const [r, c, value] = nonZerosArray[a];\n            const ar = pinv[r];\n            const ac = pinv[c];\n            mt[a] = ac < ar ? [ac, ar, value] : [ar, ac, value];\n        }\n        nonZerosArray = mt;\n    }\n    else {\n        // use a typed identity permutation\n        const p = new Int32Array(dimension);\n        for (let i = 0; i < dimension; ++i) {\n            p[i] = i;\n        }\n        permutationEncoded = p;\n    }\n    const nnz = nonZerosArray.length;\n    const ap = new Int32Array(dimension + 1);\n    const ai = new Int32Array(nnz);\n    const ax = new Float64Array(nnz);\n    const lnz = new Int32Array(dimension);\n    for (let idx = 0; idx < nnz; idx++) {\n        const col = nonZerosArray[idx][1];\n        lnz[col]++;\n    }\n    ap[0] = 0;\n    for (let i = 0; i < dimension; ++i) {\n        ap[i + 1] = ap[i] + lnz[i];\n    }\n    const colOffset = new Int32Array(dimension);\n    for (let idx = 0; idx < nnz; idx++) {\n        const e = nonZerosArray[idx];\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 Float64Array(dimension);\n    const y = new Float64Array(dimension);\n    const lp = new Int32Array(dimension + 1);\n    const parent = new Int32Array(dimension);\n    const lnzArray = new Int32Array(dimension);\n    const flag = new Int32Array(dimension);\n    const pattern = new Int32Array(dimension);\n    const bp1 = new Float64Array(dimension);\n    const x = new Float64Array(dimension);\n    ldlSymbolic(dimension, ap, ai, lp, parent, lnzArray, flag);\n    const nz = lp[dimension];\n    const lx = new Float64Array(nz);\n    const li = new Int32Array(nz);\n    const result = ldlNumeric(dimension, ap, ai, ax, lp, parent, lnzArray, li, lx, d, y, pattern, flag);\n    if (result === dimension) {\n        return (b) => {\n            ldlPerm(dimension, bp1, b, permutationEncoded);\n            ldlLsolve(dimension, bp1, lp, li, lx);\n            ldlDsolve(dimension, bp1, d);\n            ldlLTsolve(dimension, bp1, lp, li, lx);\n            ldlPermt(dimension, x, bp1, permutationEncoded);\n            return x;\n        };\n    }\n    else {\n        return null;\n    }\n}\nfunction ldlSymbolic(dimension, ap, ai, lp, parent, lnz, flag) {\n    const apLoc = ap;\n    const aiLoc = ai;\n    const parentLoc = parent;\n    const lnzLoc = lnz;\n    const flagLoc = flag;\n    for (let k = 0; k < dimension; k++) {\n        parentLoc[k] = -1;\n        flagLoc[k] = k;\n        lnzLoc[k] = 0;\n        const kk = k;\n        const p2 = apLoc[kk + 1];\n        for (let p = apLoc[kk]; p < p2; p++) {\n            let i = aiLoc[p];\n            if (i < k) {\n                for (; flagLoc[i] !== k; i = parentLoc[i]) {\n                    if (parentLoc[i] === -1)\n                        parentLoc[i] = k;\n                    lnzLoc[i]++;\n                    flagLoc[i] = k;\n                }\n            }\n        }\n    }\n    lp[0] = 0;\n    for (let k = 0; k < dimension; k++) {\n        lp[k + 1] = lp[k] + lnz[k];\n    }\n}\nfunction ldlNumeric(dimension, ap, ai, ax, lp, parent, lnz, li, lx, d, y, pattern, flag) {\n    const apLoc = ap;\n    const aiLoc = ai;\n    const axLoc = ax;\n    const lpLoc = lp;\n    const parentLoc = parent;\n    const lnzLoc = lnz;\n    const liLoc = li;\n    const lxLoc = lx;\n    const dLoc = d;\n    const yLoc = y;\n    const patternLoc = pattern;\n    const flagLoc = flag;\n    let yi, lKi;\n    for (let k = 0; k < dimension; k++) {\n        yLoc[k] = 0;\n        let top = dimension;\n        flagLoc[k] = k;\n        lnzLoc[k] = 0;\n        const kk = k;\n        const p2col = apLoc[kk + 1];\n        for (let p = apLoc[kk]; p < p2col; p++) {\n            let i = aiLoc[p];\n            if (i <= k) {\n                yLoc[i] += axLoc[p];\n                let len = 0;\n                for (; flagLoc[i] !== k; i = parentLoc[i]) {\n                    patternLoc[len++] = i;\n                    flagLoc[i] = k;\n                }\n                while (len > 0)\n                    patternLoc[--top] = patternLoc[--len];\n            }\n        }\n        dLoc[k] = yLoc[k];\n        yLoc[k] = 0;\n        for (; top < dimension; top++) {\n            const i = patternLoc[top];\n            yi = yLoc[i];\n            yLoc[i] = 0;\n            const p2 = lpLoc[i] + lnzLoc[i];\n            let p;\n            for (p = lpLoc[i]; p < p2; p++) {\n                yLoc[liLoc[p]] -= lxLoc[p] * yi;\n            }\n            lKi = yi / dLoc[i];\n            dLoc[k] -= lKi * yi;\n            liLoc[p] = k;\n            lxLoc[p] = lKi;\n            lnzLoc[i]++;\n        }\n        if (dLoc[k] === 0)\n            return k;\n    }\n    return dimension;\n}\nfunction ldlLsolve(dimension, x, lp, li, lx) {\n    const lpLoc = lp;\n    const liLoc = li;\n    const lxLoc = lx;\n    const xLoc = x;\n    for (let j = 0; j < dimension; j++) {\n        const p2 = lpLoc[j + 1];\n        for (let p = lpLoc[j]; p < p2; p++) {\n            xLoc[liLoc[p]] -= lxLoc[p] * xLoc[j];\n        }\n    }\n}\nfunction ldlDsolve(dimension, x, d) {\n    const xLoc = x;\n    const dLoc = d;\n    for (let j = 0; j < dimension; j++) {\n        xLoc[j] /= dLoc[j];\n    }\n}\nfunction ldlLTsolve(dimension, x, lp, li, lx) {\n    const lpLoc = lp;\n    const liLoc = li;\n    const lxLoc = lx;\n    const xLoc = x;\n    for (let j = dimension - 1; j >= 0; j--) {\n        const p2 = lpLoc[j + 1];\n        for (let p = lpLoc[j]; p < p2; p++) {\n            xLoc[j] -= lxLoc[p] * xLoc[liLoc[p]];\n        }\n    }\n}\nfunction ldlPerm(dimension, x, b, permutationEncoded) {\n    const perm = permutationEncoded;\n    const xLoc = x;\n    const bLoc = b;\n    for (let j = 0; j < dimension; j++) {\n        xLoc[j] = bLoc[perm[j]];\n    }\n}\nfunction ldlPermt(dimension, x, b, permutationEncoded) {\n    const perm = permutationEncoded;\n    const xLoc = x;\n    const bLoc = b;\n    for (let j = 0; j < dimension; j++) {\n        xLoc[perm[j]] = bLoc[j];\n    }\n}\n//# sourceMappingURL=matrixCholeskySolver.js.map","/**\n * The MIT License (MIT)\n *\n * Copyright (c) 2013 Mikola Lysenko\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n/**\n * The reverse Cuthill-Mckee method is a fast and effective preconditioner for reducing the bandwidth of sparse linear systems.\n * When solving a positive semidefinite linear system using Cholesky factorization, it greatly reduces fill-in.\n * It is a direct conversion to TS from {@link github.com/mikolalysenko/cuthill-mckee}\n * @param list - lower triangular non zeros from a symmetric sparse matrix.\n * @param dimension - matrix dimension\n * @returns A Float64Array where the value at each index represents the new position of the node\n *          in the bandwidth-reduced ordering.\n */\nexport function matrixCuthillMckee(list, dimension) {\n    const adj = new Array(dimension);\n    const visited = new Array(dimension).fill(false);\n    for (let i = 0; i < dimension; ++i) {\n        adj[i] = [];\n    }\n    for (const l of list) {\n        adj[l[0]].push(l[1]);\n    }\n    const toVisit = new Float64Array(dimension);\n    let eol = 0;\n    let ptr = 0;\n    for (let i = 0; i < dimension; ++i) {\n        if (visited[i]) {\n            continue;\n        }\n        toVisit[eol++] = i;\n        visited[i] = true;\n        while (ptr < eol) {\n            const v = toVisit[ptr++];\n            const nbhd = Float64Array.from(adj[v]);\n            nbhd.sort();\n            for (const u of nbhd) {\n                if (visited[u]) {\n                    continue;\n                }\n                visited[u] = true;\n                toVisit[eol++] = u;\n            }\n        }\n    }\n    const result = new Float64Array(dimension);\n    for (let i = 0; i < dimension; ++i) {\n        result[toVisit[i]] = i;\n    }\n    return result;\n}\n//# sourceMappingURL=matrixCuthillMckee.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * Verify that `data` is an object of x,y arrays.\n * Throws an error if it's not.\n * @param data\n * @param options\n * @param options.minLength\n */\nexport function xyCheck(data, options = {}) {\n    const { minLength } = options;\n    if (data === null ||\n        typeof data !== 'object' ||\n        // @ts-expect-error Typechecking\n        !isAnyArray(data.x) ||\n        // @ts-expect-error Typechecking\n        !isAnyArray(data.y)) {\n        throw new Error('data must be an object of x and y arrays');\n    }\n    // @ts-expect-error Typechecking\n    if (data.x.length !== data.y.length) {\n        throw new Error('the x and y arrays must have the same length');\n    }\n    // @ts-expect-error Typechecking\n    if (minLength && data.x.length < minLength) {\n        throw new Error(`data.x must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xyCheck.js.map","import { xyCheck } from \"./xyCheck.js\";\n/**\n * Interpolate y values at target x positions using linear interpolation.\n * This is useful for upsampling or resampling data to specific x positions.\n * Both the input data and target x values must be sorted in ascending order.\n * Uses a two-pointer approach with O(n + m) complexity.\n * @param data - Object that contains property x (an ordered increasing array) and y (an array)\n * @param xTarget - Target x positions where y values should be interpolated\n * @returns - Interpolated y values at target x positions\n */\nexport function xyInterpolateLinear(data, xTarget) {\n    xyCheck(data);\n    const { x, y } = data;\n    if (x.length === 0) {\n        return new Float64Array(0);\n    }\n    const result = new Float64Array(xTarget.length);\n    let sparseIndex = 0;\n    for (let i = 0; i < xTarget.length; i++) {\n        const targetX = xTarget[i];\n        // Move sparse index forward while we can\n        while (sparseIndex < x.length - 1 && x[sparseIndex + 1] < targetX) {\n            sparseIndex++;\n        }\n        // Handle edge cases\n        if (sparseIndex === 0 && targetX <= x[0]) {\n            // Before first point\n            if (x.length === 1) {\n                result[i] = y[0];\n            }\n            else {\n                // Extrapolate using first two points\n                const t = (targetX - x[0]) / (x[1] - x[0]);\n                result[i] = y[0] * (1 - t) + y[1] * t;\n            }\n        }\n        else if (sparseIndex >= x.length - 1) {\n            // After last point\n            result[i] = y[x.length - 1];\n        }\n        else {\n            // Normal interpolation between two points\n            const leftIdx = sparseIndex;\n            const rightIdx = sparseIndex + 1;\n            const t = (targetX - x[leftIdx]) / (x[rightIdx] - x[leftIdx]);\n            result[i] = y[leftIdx] * (1 - t) + y[rightIdx] * t;\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=xyInterpolateLinear.js.map","import { matrixCuthillMckee } from 'ml-spectra-processing';\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: matrixCuthillMckee(matrix, nbPoints),\n    };\n}\n//# sourceMappingURL=utils.js.map","import { matrixCholeskySolver, xAbsoluteSum, xBinning, xFindClosestIndex, xNoiseSanPlot, xSubtract, xyInterpolateLinear, } from 'ml-spectra-processing';\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 { xWork, yWork, optionsWork, shouldDownsample } = getDownSampleData(x, y, options);\n    const { weights, controlPoints } = getControlPoints(xWork, yWork, optionsWork);\n    const { maxIterations = 100, lambda = 10, tolerance = 0.001 } = optionsWork;\n    let baseline = [];\n    let iteration;\n    let sumNegDifferences = Number.MAX_SAFE_INTEGER;\n    const corrected = Float64Array.from(yWork);\n    const stopCriterion = getStopCriterion(yWork, tolerance);\n    const { length } = yWork;\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, yWork, weights);\n        const cho = matrixCholeskySolver(leftHandSide, length, permutationEncodedArray);\n        if (cho === null) {\n            throw new Error('Cholesky decomposition failed');\n        }\n        baseline = cho(rightHandSide);\n        sumNegDifferences = applyCorrection(yWork, 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        for (let i = 1; i < l; i++) {\n            const diff = Math.abs(corrected[i]);\n            if (controlPoints[i] < 1 && diff > threshold * 2) {\n                weights[i] = 0;\n            }\n            else {\n                weights[i] = Math.exp(-((diff / threshold) ** 2));\n            }\n        }\n        weights[0] = 1;\n        weights[l] = 1;\n    }\n    // Interpolate results back to original resolution if downsampling was applied\n    let finalBaseline = baseline;\n    let finalCorrected = corrected;\n    if (shouldDownsample) {\n        finalBaseline = xyInterpolateLinear({ x: xWork, y: baseline }, x);\n        finalCorrected = xSubtract(y, finalBaseline);\n    }\n    return {\n        corrected: finalCorrected,\n        baseline: finalBaseline,\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 getDownSampleData(x, y, options = {}) {\n    const { autoDownsample = false, maxResolution = 5000, controlPoints, } = options;\n    const shouldDownsample = autoDownsample && y.length > maxResolution;\n    if (!shouldDownsample) {\n        return { xWork: x, yWork: y, optionsWork: options, shouldDownsample };\n    }\n    const binSize = getDownsampleFactor(y.length, maxResolution);\n    const xWork = xBinning(x, {\n        binSize,\n        keepFirstAndLast: true,\n    });\n    const yWork = xBinning(y, {\n        binSize,\n        keepFirstAndLast: true,\n    });\n    let optionsWork = options;\n    // Downsample controlPoints if provided, to match downsampled x and y\n    if (controlPoints) {\n        const downsampledControlPoints = new Int8Array(xWork.length);\n        for (let i = 0; i < x.length; i++) {\n            if (controlPoints[i] > 0) {\n                const closestIndex = xFindClosestIndex(xWork, x[i]);\n                downsampledControlPoints[closestIndex] = 1;\n            }\n        }\n        optionsWork = {\n            ...options,\n            controlPoints: downsampledControlPoints,\n        };\n    }\n    return { xWork, yWork, optionsWork, shouldDownsample };\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(1) } = 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,\n        controlPoints,\n    };\n}\n/**\n * Calculate the downsampling factor to reduce data to target resolution.\n * @param originalLength - Original data length.\n * @param targetResolution - Target number of points.\n * @returns Downsampling factor.\n */\nfunction getDownsampleFactor(originalLength, targetResolution) {\n    return Math.max(1, Math.ceil(originalLength / targetResolution));\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","xGetFromToIndex","x","fromIndex","toIndex","from","to","undefined","xAbsoluteSum","sum","xBinning","binSize","numberOfPoints","keepFirstAndLast","RangeError","isInteger","binByNumberOfPoints","effectiveBinSize","Float64Array","innerLength","innerBinCount","ceil","output","j","start","end","min","k","outputLength","innerBins","floor","xEnsureFloat64","slice","createFromToArray","includeFrom","includeTo","distribution","div","delta","base","firstExponent","log","xSubtract","array1","array2","isConstant","constant","array3","Y1","P1","Q1","Y2","P2","Q2","Y3","P3","Q3","Y4","P4","Q4","Y5","P5","Q5","polyval","c","p","coef","calc","v","P","Q","Y","s","r","erfcinv","sign","val","q","g","isNaN","NaN","NEGATIVE_INFINITY","sqrt","simpleNormInv","data","magnitudeMode","result","SQRT2","simpleNormInvNumber","xNoiseSanPlot","mask","cutOff","refine","scaleFactor","factorStd","fixOffset","prepareData","medianIndex","median","firstNegativeValueIndex","at","findIndex","e","lastPositiveValueIndex","signPositive","signNegative","cutOffDist","determineCutOff","pIndex","initialNoiseLevelPositive","skyPoint","initialNoiseLevelNegative","nIndex","noiseLevelPositive","noiseLevelNegative","cloneSignPositive","cloneSignNegative","cutOffSignalsIndexPlus","cutOffSignalsIndexNeg","cutOffSignals","correctionFactor","effectiveCutOffDist","refinedCorrectionFactor","positive","negative","snr","sanplot","generateSanPlot","fromTo","considerList","step","indexMax","round","push","minKi","MAX_SAFE_INTEGER","whereToCutStat","top","elementsOfCutOff","filter","averageValue","element","kiSqrt","logBaseY","key","scale","y","reverse","log10","logOfBase","xAxis","_e","sort","matrixCholeskySolver","nonZerosArray","dimension","permutationEncoded","pinv","Int32Array","mt","Array","a","ar","ac","nnz","ap","ai","ax","lnz","idx","col","colOffset","adr","d","lp","parent","lnzArray","flag","pattern","bp1","ldlSymbolic","nz","lx","li","ldlNumeric","b","ldlPerm","ldlLsolve","ldlDsolve","ldlLTsolve","ldlPermt","apLoc","aiLoc","parentLoc","lnzLoc","flagLoc","kk","p2","axLoc","lpLoc","liLoc","lxLoc","dLoc","yLoc","patternLoc","yi","lKi","p2col","len","xLoc","perm","bLoc","matrixCuthillMckee","list","adj","visited","fill","l","toVisit","eol","ptr","nbhd","u","xyCheck","xyInterpolateLinear","xTarget","sparseIndex","targetX","t","leftIdx","rightIdx","updateSystem","matrix","weights","nbPoints","newMatrix","newVector","w","diag","next","getDeltaMatrix","lambda","last","lowerTriangularNonZeros","permutationEncodedArray","airPLS","xWork","yWork","optionsWork","shouldDownsample","getDownSampleData","controlPoints","getControlPoints","maxIterations","tolerance","baseline","iteration","sumNegDifferences","corrected","stopCriterion","getStopCriterion","threshold","prevNegSum","leftHandSide","rightHandSide","cho","applyCorrection","absChange","exp","finalBaseline","finalCorrected","error","autoDownsample","maxResolution","getDownsampleFactor","downsampledControlPoints","Int8Array","closestIndex","zones","range","indexFrom","indexTo","originalLength","targetResolution","max"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]}