{"version":3,"file":"ml-integral-transforms.min.js","sources":["../node_modules/ml-convolution/src/utils.js","../node_modules/fft.js/lib/fft.js","../node_modules/next-power-of-two/index.js","../node_modules/ml-convolution/src/fftConvolution.js","../node_modules/ml-peak-shape-generator/lib-esm/util/constants.js","../node_modules/ml-peak-shape-generator/lib-esm/util/erfinv.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/gaussian/Gaussian.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/lorentzian/Lorentzian.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/pseudoVoigt/PseudoVoigt.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/getShape1D.js","../node_modules/is-any-array/lib-esm/index.js","../node_modules/ml-spectra-processing/lib-esm/x/utils/getOutputArray.js","../node_modules/ml-spectra-processing/lib-esm/x/xCheck.js","../node_modules/ml-spectra-processing/lib-esm/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xMaxValue.js","../node_modules/ml-spectra-processing/lib-esm/x/xSum.js","../node_modules/ml-spectra-processing/lib-esm/x/xNormed.js","../lib-esm/integralTransform.js"],"sourcesContent":["export function checkSize(size) {\n  if (!Number.isInteger(size) || size < 1) {\n    throw new TypeError(`size must be a positive integer. Got ${size}`);\n  }\n}\n\nexport function checkKernel(kernel) {\n  if (kernel.length === 0 || kernel.length % 2 !== 1) {\n    throw new RangeError(\n      `kernel must have an odd positive length. Got ${kernel.length}`\n    );\n  }\n}\n\nexport function checkBorderType(borderType) {\n  if (borderType !== 'CONSTANT' && borderType !== 'CUT') {\n    throw new RangeError(`unexpected border type: ${borderType}`);\n  }\n}\n\nexport function checkInputLength(actual, expected) {\n  if (actual !== expected) {\n    throw new RangeError(\n      `input length (${actual}) does not match setup size (${expected})`\n    );\n  }\n}\n\nexport function createArray(len) {\n  const array = [];\n  for (var i = 0; i < len; i++) {\n    array.push(0);\n  }\n  return array;\n}\n","'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","module.exports = nextPowerOfTwo\n\nfunction nextPowerOfTwo (n) {\n  if (n === 0) return 1\n  n--\n  n |= n >> 1\n  n |= n >> 2\n  n |= n >> 4\n  n |= n >> 8\n  n |= n >> 16\n  return n+1\n}","import FFT from 'fft.js';\nimport nextPOT from 'next-power-of-two';\n\nimport {\n  checkKernel,\n  checkSize,\n  checkBorderType,\n  checkInputLength,\n  createArray\n} from './utils';\n\nexport class FFTConvolution {\n  constructor(size, kernel, borderType = 'CONSTANT') {\n    checkSize(size);\n    checkKernel(kernel);\n    checkBorderType(borderType);\n\n    this.size = size;\n    this.kernelOffset = (kernel.length - 1) / 2;\n    this.doubleOffset = 2 * this.kernelOffset;\n    this.borderType = borderType;\n    const resultLength = size + this.doubleOffset;\n    this.fftLength = nextPOT(Math.max(resultLength, 2));\n    this.fftComplexLength = this.fftLength * 2;\n    this.fft = new FFT(this.fftLength);\n\n    kernel = kernel.slice().reverse();\n    const paddedKernel = createArray(this.fftComplexLength);\n    this.fftKernel = createArray(this.fftComplexLength);\n    pad(kernel, paddedKernel, this.fftComplexLength);\n    this.fft.transform(this.fftKernel, paddedKernel);\n\n    this.paddedInput = createArray(this.fftComplexLength);\n    this.fftInput = createArray(this.fftComplexLength);\n\n    this.ifftOutput = createArray(this.fftComplexLength);\n    this.result = paddedKernel;\n  }\n\n  convolve(input) {\n    checkInputLength(input.length, this.size);\n    pad(input, this.paddedInput, this.fftComplexLength);\n    this.fft.transform(this.fftInput, this.paddedInput);\n\n    for (var i = 0; i < this.fftInput.length; i += 2) {\n      const tmp =\n        this.fftInput[i] * this.fftKernel[i] -\n        this.fftInput[i + 1] * this.fftKernel[i + 1];\n      this.fftInput[i + 1] =\n        this.fftInput[i] * this.fftKernel[i + 1] +\n        this.fftInput[i + 1] * this.fftKernel[i];\n      this.fftInput[i] = tmp;\n    }\n\n    this.fft.inverseTransform(this.ifftOutput, this.fftInput);\n    const r = this.fft.fromComplexArray(this.ifftOutput, this.result);\n    if (this.borderType === 'CONSTANT') {\n      return r.slice(this.kernelOffset, this.kernelOffset + input.length);\n    } else {\n      return r.slice(this.doubleOffset, input.length);\n    }\n  }\n}\n\nexport function fftConvolution(input, kernel, borderType) {\n  return new FFTConvolution(input.length, kernel, borderType).convolve(input);\n}\n\nfunction pad(data, out, len) {\n  let i = 0;\n  for (; i < data.length; i++) {\n    out[i * 2] = data[i];\n    out[i * 2 + 1] = 0;\n  }\n\n  i *= 2;\n  for (; i < len; i += 2) {\n    out[i] = 0;\n    out[i + 1] = 0;\n  }\n}\n","export const GAUSSIAN_EXP_FACTOR = -4 * Math.LN2;\nexport const ROOT_PI_OVER_LN2 = Math.sqrt(Math.PI / Math.LN2);\nexport const ROOT_THREE = Math.sqrt(3);\nexport const ROOT_2LN2 = Math.sqrt(2 * Math.LN2);\nexport const ROOT_2LN2_MINUS_ONE = Math.sqrt(2 * Math.LN2) - 1;\n//# sourceMappingURL=constants.js.map","// https://en.wikipedia.org/wiki/Error_function#Inverse_functions\n// This code yields to a good approximation\n// If needed a better implementation using polynomial can be found on https://en.wikipedia.org/wiki/Error_function#Inverse_functions\nexport default function erfinv(x) {\n    let a = 0.147;\n    if (x === 0)\n        return 0;\n    let ln1MinusXSqrd = Math.log(1 - x * x);\n    let lnEtcBy2Plus2 = ln1MinusXSqrd / 2 + 2 / (Math.PI * a);\n    let firstSqrt = Math.sqrt(lnEtcBy2Plus2 ** 2 - ln1MinusXSqrd / a);\n    let secondSqrt = Math.sqrt(firstSqrt - lnEtcBy2Plus2);\n    return secondSqrt * (x > 0 ? 1 : -1);\n}\n//# sourceMappingURL=erfinv.js.map","import { ROOT_2LN2, GAUSSIAN_EXP_FACTOR, ROOT_PI_OVER_LN2, } from '../../../util/constants';\nimport erfinv from '../../../util/erfinv';\nexport class Gaussian {\n    constructor(options = {}) {\n        const { fwhm = 500, sd } = options;\n        this.fwhm = sd ? gaussianWidthToFWHM(2 * sd) : fwhm;\n    }\n    fwhmToWidth(fwhm = this.fwhm) {\n        return gaussianFwhmToWidth(fwhm);\n    }\n    widthToFWHM(width) {\n        return gaussianWidthToFWHM(width);\n    }\n    fct(x) {\n        return gaussianFct(x, this.fwhm);\n    }\n    getArea(height = calculateGaussianHeight({ fwhm: this.fwhm })) {\n        return getGaussianArea({ fwhm: this.fwhm, height });\n    }\n    getFactor(area) {\n        return getGaussianFactor(area);\n    }\n    getData(options = {}) {\n        return getGaussianData(this, options);\n    }\n    calculateHeight(area = 1) {\n        return calculateGaussianHeight({ fwhm: this.fwhm, area });\n    }\n    getParameters() {\n        return ['fwhm'];\n    }\n}\nexport function calculateGaussianHeight(options) {\n    let { fwhm = 500, area = 1, sd } = options;\n    if (sd)\n        fwhm = gaussianWidthToFWHM(2 * sd);\n    return (2 * area) / ROOT_PI_OVER_LN2 / fwhm;\n}\n/**\n * Calculate the height of the gaussian function of a specific width (fwhm) at a speicifc\n * x position (the gaussian is centered on x=0)\n * @param x\n * @param fwhm\n * @returns y\n */\nexport function gaussianFct(x, fwhm) {\n    return Math.exp(GAUSSIAN_EXP_FACTOR * Math.pow(x / fwhm, 2));\n}\nexport function gaussianWidthToFWHM(width) {\n    return width * ROOT_2LN2;\n}\nexport function gaussianFwhmToWidth(fwhm) {\n    return fwhm / ROOT_2LN2;\n}\nexport function getGaussianArea(options) {\n    let { fwhm = 500, sd, height = 1 } = options;\n    if (sd)\n        fwhm = gaussianWidthToFWHM(2 * sd);\n    return (height * ROOT_PI_OVER_LN2 * fwhm) / 2;\n}\nexport function getGaussianFactor(area = 0.9999) {\n    return Math.sqrt(2) * erfinv(area);\n}\nexport function getGaussianData(shape = {}, options = {}) {\n    let { fwhm = 500, sd } = shape;\n    if (sd)\n        fwhm = gaussianWidthToFWHM(2 * sd);\n    let { length, factor = getGaussianFactor(), height = calculateGaussianHeight({ fwhm }), } = options;\n    if (!length) {\n        length = Math.min(Math.ceil(fwhm * factor), Math.pow(2, 25) - 1);\n        if (length % 2 === 0)\n            length++;\n    }\n    const center = (length - 1) / 2;\n    const data = new Float64Array(length);\n    for (let i = 0; i <= center; i++) {\n        data[i] = gaussianFct(i - center, fwhm) * height;\n        data[length - 1 - i] = data[i];\n    }\n    return data;\n}\n//# sourceMappingURL=Gaussian.js.map","import { ROOT_THREE } from '../../../util/constants';\nexport class Lorentzian {\n    constructor(options = {}) {\n        const { fwhm = 500 } = options;\n        this.fwhm = fwhm;\n    }\n    fwhmToWidth(fwhm = this.fwhm) {\n        return lorentzianFwhmToWidth(fwhm);\n    }\n    widthToFWHM(width) {\n        return lorentzianWidthToFWHM(width);\n    }\n    fct(x) {\n        return lorentzianFct(x, this.fwhm);\n    }\n    getArea(height = 1) {\n        return getLorentzianArea({ fwhm: this.fwhm, height });\n    }\n    getFactor(area) {\n        return getLorentzianFactor(area);\n    }\n    getData(options = {}) {\n        return getLorentzianData(this, options);\n    }\n    calculateHeight(area = 1) {\n        return calculateLorentzianHeight({ fwhm: this.fwhm, area });\n    }\n    getParameters() {\n        return ['fwhm'];\n    }\n}\nexport const calculateLorentzianHeight = ({ fwhm = 1, area = 1 }) => {\n    return (2 * area) / Math.PI / fwhm;\n};\nexport const getLorentzianArea = (options) => {\n    const { fwhm = 500, height = 1 } = options;\n    return (height * Math.PI * fwhm) / 2;\n};\nexport const lorentzianFct = (x, fwhm) => {\n    return fwhm ** 2 / (4 * x ** 2 + fwhm ** 2);\n};\nexport const lorentzianWidthToFWHM = (width) => {\n    return width * ROOT_THREE;\n};\nexport const lorentzianFwhmToWidth = (fwhm) => {\n    return fwhm / ROOT_THREE;\n};\nexport const getLorentzianFactor = (area = 0.9999) => {\n    if (area >= 1) {\n        throw new Error('area should be (0 - 1)');\n    }\n    const halfResidual = (1 - area) * 0.5;\n    const quantileFunction = (p) => Math.tan(Math.PI * (p - 0.5));\n    return ((quantileFunction(1 - halfResidual) - quantileFunction(halfResidual)) / 2);\n};\nexport const getLorentzianData = (shape = {}, options = {}) => {\n    let { fwhm = 500 } = shape;\n    let { length, factor = getLorentzianFactor(), height = calculateLorentzianHeight({ fwhm, area: 1 }), } = options;\n    if (!length) {\n        length = Math.min(Math.ceil(fwhm * factor), Math.pow(2, 25) - 1);\n        if (length % 2 === 0)\n            length++;\n    }\n    const center = (length - 1) / 2;\n    const data = new Float64Array(length);\n    for (let i = 0; i <= center; i++) {\n        data[i] = lorentzianFct(i - center, fwhm) * height;\n        data[length - 1 - i] = data[i];\n    }\n    return data;\n};\n//# sourceMappingURL=Lorentzian.js.map","import { GAUSSIAN_EXP_FACTOR, ROOT_2LN2_MINUS_ONE, ROOT_PI_OVER_LN2, } from '../../../util/constants';\nimport { gaussianFct, getGaussianFactor } from '../gaussian/Gaussian';\nimport { lorentzianFct, getLorentzianFactor } from '../lorentzian/Lorentzian';\nexport class PseudoVoigt {\n    constructor(options = {}) {\n        const { fwhm = 500, mu = 0.5 } = options;\n        this.mu = mu;\n        this.fwhm = fwhm;\n    }\n    fwhmToWidth(fwhm = this.fwhm, mu = this.mu) {\n        return pseudoVoigtFwhmToWidth(fwhm, mu);\n    }\n    widthToFWHM(width, mu = this.mu) {\n        return pseudoVoigtWidthToFWHM(width, mu);\n    }\n    fct(x) {\n        return pseudoVoigtFct(x, this.fwhm, this.mu);\n    }\n    getArea(height = 1) {\n        return getPseudoVoigtArea({ fwhm: this.fwhm, height, mu: this.mu });\n    }\n    getFactor(area) {\n        return getPseudoVoigtFactor(area);\n    }\n    getData(options = {}) {\n        const { length, factor, height = calculatePseudoVoigtHeight({\n            fwhm: this.fwhm,\n            mu: this.mu,\n            area: 1,\n        }), } = options;\n        return getPseudoVoigtData(this, { factor, length, height });\n    }\n    calculateHeight(area = 1) {\n        return calculatePseudoVoigtHeight({ fwhm: this.fwhm, mu: this.mu, area });\n    }\n    getParameters() {\n        return ['fwhm', 'mu'];\n    }\n}\nexport const calculatePseudoVoigtHeight = (options = {}) => {\n    let { fwhm = 1, mu = 0.5, area = 1 } = options;\n    return (2 * area) / (fwhm * (mu * ROOT_PI_OVER_LN2 + (1 - mu) * Math.PI));\n};\nexport const pseudoVoigtFct = (x, fwhm, mu) => {\n    return (1 - mu) * lorentzianFct(x, fwhm) + mu * gaussianFct(x, fwhm);\n};\nexport const pseudoVoigtWidthToFWHM = (width, mu = 0.5) => {\n    return width * (mu * ROOT_2LN2_MINUS_ONE + 1);\n};\nexport const pseudoVoigtFwhmToWidth = (fwhm, mu = 0.5) => {\n    return fwhm / (mu * ROOT_2LN2_MINUS_ONE + 1);\n};\nexport const getPseudoVoigtArea = (options) => {\n    const { fwhm = 500, height = 1, mu = 0.5 } = options;\n    return (fwhm * height * (mu * ROOT_PI_OVER_LN2 + (1 - mu) * Math.PI)) / 2;\n};\nexport const getPseudoVoigtFactor = (area = 0.9999, mu = 0.5) => {\n    return mu < 1 ? getLorentzianFactor(area) : getGaussianFactor(area);\n};\nexport const getPseudoVoigtData = (shape = {}, options = {}) => {\n    let { fwhm = 500, mu = 0.5 } = shape;\n    let { length, factor = getPseudoVoigtFactor(0.999, mu), height = calculatePseudoVoigtHeight({ fwhm, mu, area: 1 }), } = options;\n    if (!height) {\n        height =\n            1 /\n                ((mu / Math.sqrt(-GAUSSIAN_EXP_FACTOR / Math.PI)) * fwhm +\n                    ((1 - mu) * fwhm * Math.PI) / 2);\n    }\n    if (!length) {\n        length = Math.min(Math.ceil(fwhm * factor), Math.pow(2, 25) - 1);\n        if (length % 2 === 0)\n            length++;\n    }\n    const center = (length - 1) / 2;\n    const data = new Float64Array(length);\n    for (let i = 0; i <= center; i++) {\n        data[i] = pseudoVoigtFct(i - center, fwhm, mu) * height;\n        data[length - 1 - i] = data[i];\n    }\n    return data;\n};\n//# sourceMappingURL=PseudoVoigt.js.map","import { Gaussian } from './gaussian/Gaussian';\nimport { Lorentzian } from './lorentzian/Lorentzian';\nimport { PseudoVoigt } from './pseudoVoigt/PseudoVoigt';\n/**\n * Generate a instance of a specific kind of shape.\n */\nexport function getShape1D(shape) {\n    const { kind } = shape;\n    switch (kind) {\n        case 'gaussian':\n            return new Gaussian(shape);\n        case 'lorentzian':\n            return new Lorentzian(shape);\n        case 'pseudoVoigt':\n            return new PseudoVoigt(shape);\n        default: {\n            throw Error(`Unknown distribution ${kind}`);\n        }\n    }\n}\n//# sourceMappingURL=getShape1D.js.map","const toString = Object.prototype.toString;\n/**\n * Checks if an object is an instance of an Array (array or typed array).\n *\n * @param {any} value - Object to check.\n * @returns {boolean} True if the object is an array.\n */\nexport function isAnyArray(value) {\n    return toString.call(value).endsWith('Array]');\n}\n//# sourceMappingURL=index.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","import { isAnyArray } from 'is-any-array';\n/**\n * Checks if input is of type array\n *\n * @param input - input\n */\nexport function xCheck(input) {\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}\n//# sourceMappingURL=xCheck.js.map","/**\n * Returns the closest index of a `target`\n *\n * @param array - array of numbers\n * @param target - target\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';\n/**\n * Returns an object with {fromIndex, toIndex} for a specific from / to\n *\n * @param x - array of numbers\n * @param options - Options\n */\nexport function xGetFromToIndex(x, options = {}) {\n    let { fromIndex, toIndex, 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';\nimport { xGetFromToIndex } from './xGetFromToIndex';\n/**\n * Computes the maximal value of an array of values\n *\n * @param array - array of numbers\n * @param options - options\n */\nexport function xMaxValue(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let maxValue = array[fromIndex];\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n        if (array[i] > maxValue) {\n            maxValue = array[i];\n        }\n    }\n    return maxValue;\n}\n//# sourceMappingURL=xMaxValue.js.map","import { xCheck } from './xCheck';\nimport { xGetFromToIndex } from './xGetFromToIndex';\n/**\n * Calculate the sum of the values\n *\n * @param array - Object that contains property x (an ordered increasing array) and y (an array).\n * @param options - Options.\n * @returns XSum value on the specified range.\n */\nexport function xSum(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let sumValue = array[fromIndex];\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n        sumValue += array[i];\n    }\n    return sumValue;\n}\n//# sourceMappingURL=xSum.js.map","import { getOutputArray } from './utils/getOutputArray';\nimport { xCheck } from './xCheck';\nimport { xMaxValue } from './xMaxValue';\nimport { xSum } from './xSum';\n/**\n * Divides the data with either the sum, the absolute sum or the maximum of the data\n * @param array - Array containing values\n * @param options - options\n * @returns - normalized data\n */\nexport function xNormed(input, options = {}) {\n    const { algorithm = 'absolute', value = 1 } = options;\n    xCheck(input);\n    const output = getOutputArray(options.output, input.length);\n    if (input.length === 0) {\n        throw new Error('input must not be empty');\n    }\n    switch (algorithm.toLowerCase()) {\n        case 'absolute': {\n            let absoluteSumValue = absoluteSum(input) / value;\n            if (absoluteSumValue === 0) {\n                throw new Error('xNormed: trying to divide by 0');\n            }\n            for (let i = 0; i < input.length; i++) {\n                output[i] = input[i] / absoluteSumValue;\n            }\n            return output;\n        }\n        case 'max': {\n            let currentMaxValue = xMaxValue(input);\n            if (currentMaxValue === 0) {\n                throw new Error('xNormed: trying to divide by 0');\n            }\n            const factor = value / currentMaxValue;\n            for (let i = 0; i < input.length; i++) {\n                output[i] = input[i] * factor;\n            }\n            return output;\n        }\n        case 'sum': {\n            let sumFactor = xSum(input) / value;\n            if (sumFactor === 0) {\n                throw new Error('xNormed: trying to divide by 0');\n            }\n            for (let i = 0; i < input.length; i++) {\n                output[i] = input[i] / sumFactor;\n            }\n            return output;\n        }\n        default:\n            throw new Error(`norm: unknown algorithm: ${algorithm}`);\n    }\n}\nfunction absoluteSum(input) {\n    let sumValue = 0;\n    for (let i = 0; i < input.length; i++) {\n        sumValue += Math.abs(input[i]);\n    }\n    return sumValue;\n}\n//# sourceMappingURL=xNormed.js.map","import { fftConvolution } from 'ml-convolution';\nimport { getShape1D } from 'ml-peak-shape-generator';\nimport { xNormed } from 'ml-spectra-processing';\n/**\n * This function returns a broadened spectrum\n * @param array - The original spectrum\n * @param options - options\n * @returns - broadened spectrum\n */\nexport function integralTransform(array, options = {}) {\n    const { shape = { kind: 'gaussian', sd: 1.2 }, kernelWidth = 7, normalized = false, kernelHeight = 1, maxHeight = 1, } = options;\n    const kernelBasis = getShape1D({ ...shape, fwhm: kernelWidth });\n    const kernel = kernelBasis.getData({\n        length: kernelWidth,\n        height: kernelHeight,\n    });\n    const result = fftConvolution(array, kernel, 'CONSTANT');\n    return normalized\n        ? xNormed(result, { algorithm: 'max', value: maxHeight })\n        : result;\n}\n//# sourceMappingURL=integralTransform.js.map"],"names":["createArray","len","array","i","push","FFT","size","this","Error","_csize","table","Array","length","angle","Math","PI","cos","sin","power","t","_width","_bitrev","j","shift","revShift","_out","_data","_inv","fft","prototype","fromComplexArray","complex","storage","res","createComplexArray","toComplexArray","input","completeSpectrum","spectrum","half","transform","out","data","_transform4","realTransform","_realTransform4","inverseTransform","outOff","step","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","n","FFTConvolution","constructor","kernel","borderType","Number","isInteger","TypeError","checkSize","RangeError","checkKernel","checkBorderType","kernelOffset","doubleOffset","resultLength","fftLength","nextPOT","max","fftComplexLength","slice","reverse","paddedKernel","fftKernel","pad","paddedInput","fftInput","ifftOutput","result","convolve","actual","expected","checkInputLength","tmp","r","fftConvolution","GAUSSIAN_EXP_FACTOR","LN2","ROOT_PI_OVER_LN2","sqrt","ROOT_THREE","ROOT_2LN2","ROOT_2LN2_MINUS_ONE","erfinv","x","ln1MinusXSqrd","log","lnEtcBy2Plus2","firstSqrt","Gaussian","options","fwhm","sd","gaussianWidthToFWHM","fwhmToWidth","gaussianFwhmToWidth","arguments","undefined","widthToFWHM","width","fct","gaussianFct","getArea","height","calculateGaussianHeight","getGaussianArea","getFactor","area","getGaussianFactor","getData","shape","factor","min","ceil","pow","center","Float64Array","getGaussianData","calculateHeight","getParameters","exp","Lorentzian","lorentzianFwhmToWidth","lorentzianWidthToFWHM","lorentzianFct","getLorentzianArea","getLorentzianFactor","getLorentzianData","calculateLorentzianHeight","_ref","halfResidual","quantileFunction","p","tan","PseudoVoigt","mu","pseudoVoigtFwhmToWidth","pseudoVoigtWidthToFWHM","pseudoVoigtFct","getPseudoVoigtArea","getPseudoVoigtFactor","calculatePseudoVoigtHeight","getPseudoVoigtData","getShape1D","kind","toString","Object","isAnyArray","value","call","endsWith","getOutputArray","output","xCheck","xFindClosestIndex","target","sorted","low","high","middle","abs","index","diff","POSITIVE_INFINITY","currentDiff","xGetFromToIndex","fromIndex","toIndex","from","to","xMaxValue","maxValue","xSum","sumValue","xNormed","algorithm","toLowerCase","absoluteSumValue","absoluteSum","currentMaxValue","sumFactor","kernelWidth","normalized","kernelHeight","maxHeight","kernelBasis"],"mappings":"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"}