{"version":3,"file":"spectrum-generator.min.js","sources":["../node_modules/ml-peak-shape-generator/src/util/constants.js","../node_modules/ml-peak-shape-generator/src/classes/Gaussian.js","../node_modules/ml-peak-shape-generator/src/util/erfinv.js","../node_modules/ml-peak-shape-generator/src/classes/Lorentzian.js","../node_modules/ml-peak-shape-generator/src/classes/PseudoVoigt.js","../node_modules/ml-peak-shape-generator/src/util/getShapeGenerator.js","../node_modules/d3-random/src/defaultSource.js","../node_modules/d3-random/src/uniform.js","../node_modules/d3-random/src/normal.js","../node_modules/ml-xsadd/lib-es6/xsadd.js","../src/util/addNoise.js","../src/index.js","../src/util/addBaseline.js"],"sourcesContent":["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","import {\n  ROOT_2LN2,\n  GAUSSIAN_EXP_FACTOR,\n  ROOT_PI_OVER_LN2,\n} from '../util/constants';\nimport erfinv from '../util/erfinv';\n\nexport class Gaussian {\n  /**\n   * @param {object} [options = {}]\n   * @param {number} [options.height=x] Define the height of the peak, by default area=1 (normalized)\n   * @param {number} [options.fwhm = 500] - Full Width at Half Maximum in the number of points in FWHM.\n   * @param {number} [options.sd] - Standard deviation, if it's defined options.fwhm will be ignored and the value will be computed sd * Math.sqrt(8 * Math.LN2);\n   */\n  constructor(options = {}) {\n    this.fwhm = options.sd\n      ? Gaussian.widthToFWHM(2 * options.sd)\n      : options.fwhm\n      ? options.fwhm\n      : 500;\n    this.height =\n      options.height === undefined\n        ? Math.sqrt(-GAUSSIAN_EXP_FACTOR / Math.PI) / this.fwhm\n        : options.height;\n  }\n  /**\n   * Calculate a gaussian shape\n   * @param {object} [options = {}]\n   * @param {number} [options.factor = 6] - Number of time to take fwhm to calculate length. Default covers 99.99 % of area.\n   * @param {number} [options.length = fwhm * factor + 1] - total number of points to calculate\n   * @return {Float64Array} y values\n   */\n\n  getData(options = {}) {\n    let { length, factor = this.getFactor() } = options;\n\n    if (!length) {\n      length = Math.min(Math.ceil(this.fwhm * factor), Math.pow(2, 25) - 1);\n      if (length % 2 === 0) length++;\n    }\n\n    const center = (length - 1) / 2;\n    const data = new Float64Array(length);\n    for (let i = 0; i <= center; i++) {\n      data[i] = this.fct(i - center) * this.height;\n      data[length - 1 - i] = data[i];\n    }\n\n    return data;\n  }\n\n  /**\n   * Return a parameterized function of a gaussian shape (see README for equation).\n   * @param {number} x - x value to calculate.\n   * @returns {number} - the y value of gaussian with the current parameters.\n   */\n  fct(x) {\n    return Gaussian.fct(x, this.fwhm);\n  }\n\n  /**\n   * Calculate the number of times FWHM allows to reach a specific area coverage\n   * @param {number} [area=0.9999]\n   * @returns {number}\n   */\n  getFactor(area = 0.9999) {\n    return Gaussian.getFactor(area);\n  }\n\n  /**\n   * Calculate the area of the shape.\n   * @returns {number} - returns the area.\n   */\n\n  getArea() {\n    return Gaussian.getArea(this.fwhm, { height: this.height });\n  }\n\n  /**\n   * Compute the value of Full Width at Half Maximum (FWHM) from the width between the inflection points.\n   * //https://mathworld.wolfram.com/GaussianFunction.html\n   * @param {number} width - Width between the inflection points\n   * @returns {number} fwhm\n   */\n  widthToFWHM(width) {\n    //https://mathworld.wolfram.com/GaussianFunction.html\n    return Gaussian.widthToFWHM(width);\n  }\n\n  /**\n   * Compute the value of width between the inflection points from Full Width at Half Maximum (FWHM).\n   * //https://mathworld.wolfram.com/GaussianFunction.html\n   * @param {number} fwhm - Full Width at Half Maximum.\n   * @returns {number} width\n   */\n  fwhmToWidth(fwhm = this.fwhm) {\n    return Gaussian.fwhmToWidth(fwhm);\n  }\n\n  /**\n   * set a new full width at half maximum\n   * @param {number} fwhm - full width at half maximum\n   */\n  setFWHM(fwhm) {\n    this.fwhm = fwhm;\n  }\n\n  /**\n   * set a new height\n   * @param {number} height - The maximal intensity of the shape.\n   */\n  setHeight(height) {\n    this.height = height;\n  }\n}\n\n/**\n * Return a parameterized function of a gaussian shape (see README for equation).\n * @param {number} x - x value to calculate.\n * @param {number} fwhm - full width half maximum\n * @returns {number} - the y value of gaussian with the current parameters.\n */\nGaussian.fct = function fct(x, fwhm = 500) {\n  return Math.exp(GAUSSIAN_EXP_FACTOR * Math.pow(x / fwhm, 2));\n};\n\n/**\n * Compute the value of Full Width at Half Maximum (FWHM) from the width between the inflection points.\n * //https://mathworld.wolfram.com/GaussianFunction.html\n * @param {number} width - Width between the inflection points\n * @returns {number} fwhm\n */\nGaussian.widthToFWHM = function widthToFWHM(width) {\n  return width * ROOT_2LN2;\n};\n\n/**\n * Compute the value of width between the inflection points from Full Width at Half Maximum (FWHM).\n * //https://mathworld.wolfram.com/GaussianFunction.html\n * @param {number} fwhm - Full Width at Half Maximum.\n * @returns {number} width\n */\nGaussian.fwhmToWidth = function fwhmToWidth(fwhm) {\n  return fwhm / ROOT_2LN2;\n};\n\n/**\n * Calculate the area of a specific shape.\n * @param {number} fwhm - Full width at half maximum.\n * @param {object} [options = {}] - options.\n * @param {number} [options.height = 1] - Maximum y value of the shape.\n * @returns {number} - returns the area of the specific shape and parameters.\n */\n\nGaussian.getArea = function getArea(fwhm, options = {}) {\n  let { height = 1 } = options;\n  return (height * ROOT_PI_OVER_LN2 * fwhm) / 2;\n};\n\n/**\n * Calculate the number of times FWHM allows to reach a specific area coverage.\n * @param {number} [area=0.9999]\n * @returns {number}\n */\nGaussian.getFactor = function getFactor(area = 0.9999) {\n  return Math.sqrt(2) * erfinv(area);\n};\n","// https://en.wikipedia.org/wiki/Error_function#Inverse_functions\n// This code yields to a good approximation\n\n// If needed a better implementation using polynomial can be found on https://en.wikipedia.org/wiki/Error_function#Inverse_functions\n\nexport default function erfinv(x) {\n  let a = 0.147;\n  if (x === 0) 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","import { ROOT_THREE } from '../util/constants';\n\nexport class Lorentzian {\n  /**\n   * @param {object} [options = {}]\n   * @param {number} [options.height=x] Define the height of the peak, by default area=1 (normalized)\n   * @param {number} [options.fwhm = 500] - Full Width at Half Maximum in the number of points in FWHM.\n   * @param {number} [options.sd] - Standard deviation, if it's defined options.fwhm will be ignored and the value will be computed sd * Math.sqrt(8 * Math.LN2);\n   */\n  constructor(options = {}) {\n    this.fwhm = options.fwhm === undefined ? 500 : options.fwhm;\n    this.height =\n      options.height === undefined ? 2 / Math.PI / this.fwhm : options.height;\n  }\n  /**\n   * Calculate a lorentzian shape\n   * @param {object} [options = {}]\n   * @param {number} [options.factor = Math.tan(Math.PI * (0.9999 - 0.5))] - Number of time to take fwhm to calculate length. Default covers 99.99 % of area.\n   * @param {number} [options.length = fwhm * factor + 1] - total number of points to calculate\n   * @return {Float64Array} y values\n   */\n  getData(options = {}) {\n    let { length, factor = this.getFactor() } = options;\n\n    if (!length) {\n      length = Math.min(Math.ceil(this.fwhm * factor), Math.pow(2, 25) - 1);\n      if (length % 2 === 0) length++;\n    }\n\n    const center = (length - 1) / 2;\n    const data = new Float64Array(length);\n    for (let i = 0; i <= center; i++) {\n      data[i] = this.fct(i - center) * this.height;\n      data[length - 1 - i] = data[i];\n    }\n    return data;\n  }\n\n  /**\n   * Return a parameterized function of a lorentzian shape (see README for equation).\n   * @param {number} x - x value to calculate.\n   * @returns {number} - the y value of lorentzian with the current parameters.\n   */\n  fct(x) {\n    return Lorentzian.fct(x, this.fwhm);\n  }\n\n  /**\n   * Calculate the number of times FWHM allows to reach a specific area coverage\n   * @param {number} [area=0.9999]\n   * @returns {number}\n   */\n  getFactor(area = 0.9999) {\n    return Lorentzian.getFactor(area);\n  }\n\n  /**\n   * Calculate the area of the shape.\n   * @returns {number} - returns the area.\n   */\n\n  getArea() {\n    return Lorentzian.getArea(this.fwhm, { height: this.height });\n  }\n\n  /**\n   * Compute the value of width between the inflection points of a specific shape from Full Width at Half Maximum (FWHM).\n   * //https://mathworld.wolfram.com/LorentzianFunction.html\n   * @param {number} [fwhm] - Full Width at Half Maximum.\n   * @returns {number} width between the inflection points\n   */\n  fwhmToWidth(fwhm = this.fwhm) {\n    return Lorentzian.fwhmToWidth(fwhm);\n  }\n\n  /**\n   * Compute the value of Full Width at Half Maximum (FWHM) of a specific shape from the width between the inflection points.\n   * //https://mathworld.wolfram.com/LorentzianFunction.html\n   * @param {number} [width] Width between the inflection points\n   * @returns {number} fwhm\n   */\n  widthToFWHM(width) {\n    return Lorentzian.widthToFWHM(width);\n  }\n  /**\n   * set a new full width at half maximum\n   * @param {number} fwhm - full width at half maximum\n   */\n  setFWHM(fwhm) {\n    this.fwhm = fwhm;\n  }\n\n  /**\n   * set a new height\n   * @param {number} height - The maximal intensity of the shape.\n   */\n  setHeight(height) {\n    this.height = height;\n  }\n}\n\n/**\n * Return a parameterized function of a gaussian shape (see README for equation).\n * @param {number} x - x value to calculate.\n * @param {number} fwhm - full width half maximum\n * @returns {number} - the y value of gaussian with the current parameters.\n */\nLorentzian.fct = function fct(x, fwhm) {\n  const squareFWHM = fwhm * fwhm;\n  return squareFWHM / (4 * Math.pow(x, 2) + squareFWHM);\n};\n\n/**\n * Compute the value of width between the inflection points of a specific shape from Full Width at Half Maximum (FWHM).\n * //https://mathworld.wolfram.com/LorentzianFunction.html\n * @param {number} [fwhm] - Full Width at Half Maximum.\n * @returns {number} width between the inflection points\n */\nLorentzian.fwhmToWidth = function fwhmToWidth(fwhm) {\n  return fwhm / ROOT_THREE;\n};\n\n/**\n * Compute the value of Full Width at Half Maximum (FWHM) of a specific shape from the width between the inflection points.\n * //https://mathworld.wolfram.com/LorentzianFunction.html\n * @param {number} [width] Width between the inflection points\n * @returns {number} fwhm\n */\nLorentzian.widthToFWHM = function widthToFWHM(width) {\n  return width * ROOT_THREE;\n};\n\n/**\n * Calculate the area of a specific shape.\n * @param {number} fwhm - Full width at half maximum.\n * @param {*} [options = {}] - options.\n * @param {number} [options.height = 1] - Maximum y value of the shape.\n * @returns {number} - returns the area of the specific shape and parameters.\n */\nLorentzian.getArea = function getArea(fwhm, options = {}) {\n  let { height = 1 } = options;\n\n  return (height * Math.PI * fwhm) / 2;\n};\n\n/**\n * Calculate the number of times FWHM allows to reach a specific area coverage\n * @param {number} [area=0.9999]\n * @returns {number}\n */\nLorentzian.getFactor = function getFactor(area = 0.9999) {\n  return 2 * Math.tan(Math.PI * (area - 0.5));\n};\n","import {\n  GAUSSIAN_EXP_FACTOR,\n  ROOT_2LN2_MINUS_ONE,\n  ROOT_PI_OVER_LN2,\n} from '../util/constants';\n\nimport { Gaussian } from './Gaussian';\nimport { Lorentzian } from './Lorentzian';\n\nexport class PseudoVoigt {\n  /**\n   * @param {object} [options={}]\n   * @param {number} [options.height=x] Define the height of the peak, by default area=1 (normalized)\n   * @param {number} [options.fwhm=500] - Full Width at Half Maximum in the number of points in FWHM.\n   * @param {number} [options.mu=0.5] - ratio of gaussian contribution.\n   */\n\n  constructor(options = {}) {\n    this.mu = options.mu === undefined ? 0.5 : options.mu;\n    this.fwhm = options.fwhm === undefined ? 500 : options.fwhm;\n    this.height =\n      options.height === undefined\n        ? 1 /\n          ((this.mu / Math.sqrt(-GAUSSIAN_EXP_FACTOR / Math.PI)) * this.fwhm +\n            ((1 - this.mu) * this.fwhm * Math.PI) / 2)\n        : options.height;\n  }\n\n  /**\n   * Calculate a linear combination of gaussian and lorentzian function width an same full width at half maximum\n   * @param { object } [options = {}]\n   * @param { number } [options.factor = 2 * Math.tan(Math.PI * (0.9999 - 0.5))] - Number of time to take fwhm in the calculation of the length.Default covers 99.99 % of area.\n   * @param { number } [options.length = fwhm * factor + 1] - total number of points to calculate\n   * @return { object } - { fwhm, data<Float64Array>} - An with the number of points at half maximum and the array of y values covering the 99.99 % of the area.\n   */\n\n  getData(options = {}) {\n    let { length, factor = this.getFactor() } = options;\n    if (!length) {\n      length = Math.ceil(this.fwhm * factor);\n      if (length % 2 === 0) length++;\n    }\n\n    const center = (length - 1) / 2;\n\n    let data = new Float64Array(length);\n    for (let i = 0; i <= center; i++) {\n      data[i] = this.fct(i - center) * this.height;\n      data[length - 1 - i] = data[i];\n    }\n\n    return data;\n  }\n\n  /**\n   * Return a parameterized function of a linear combination of Gaussian and Lorentzian shapes where the full width at half maximum are the same for both kind of shapes (see README for equation).\n   * @param {number} [x] x value to calculate.\n   * @returns {number} - the y value of a pseudo voigt with the current parameters.\n   */\n\n  fct(x) {\n    return PseudoVoigt.fct(x, this.fwhm, this.mu);\n  }\n\n  /**\n   * Calculate the number of times FWHM allows to reach a specific area coverage\n   * @param {number} [area=0.9999] - required area to be coverage\n   * @param {number} [mu=this.mu] - ratio of gaussian contribution.\n   * @returns {number}\n   */\n  getFactor(area = 0.9999, mu = this.mu) {\n    return PseudoVoigt.getFactor(area, mu);\n  }\n\n  /**\n   * Calculate the area of the shape.\n   * @returns {number} - returns the area.\n   */\n  getArea() {\n    return PseudoVoigt.getArea(this.fwhm, { height: this.height, mu: this.mu });\n  }\n\n  /**\n   * Compute the value of Full Width at Half Maximum (FMHM) from width between the inflection points.\n   * @param {number} width - width between the inflection points\n   * @param {number} [mu = 0.5] - ratio of gaussian contribution.\n   * @returns {number} Full Width at Half Maximum (FMHM).\n   */\n  widthToFWHM(width, mu) {\n    return PseudoVoigt.widthToFWHM(width, mu);\n  }\n  /**\n   * Compute the value of width between the inflection points from Full Width at Half Maximum (FWHM).\n   * @param {number} fwhm - Full Width at Half Maximum.\n   * @param {number} [mu] - ratio of gaussian contribution.\n   * @returns {number} width between the inflection points.\n   */\n  fwhmToWidth(fwhm = this.fwhm, mu = this.mu) {\n    return PseudoVoigt.fwhmToWidth(fwhm, mu);\n  }\n\n  /**\n   * set a new full width at half maximum\n   * @param {number} fwhm - full width at half maximum\n   */\n  setFWHM(fwhm) {\n    this.fwhm = fwhm;\n  }\n\n  /**\n   * set a new height\n   * @param {number} height - The maximal intensity of the shape.\n   */\n  setHeight(height) {\n    this.height = height;\n  }\n\n  /**\n   * set a new mu\n   * @param {number} mu - ratio of gaussian contribution.\n   */\n  setMu(mu) {\n    this.mu = mu;\n  }\n}\n\n/**\n * Return a parameterized function of a gaussian shape (see README for equation).\n * @param {number} x - x value to calculate.\n * @param {number} fwhm - full width half maximum\n * @param {number} [mu=0.5] - ratio of gaussian contribution.\n * @returns {number} - the y value of gaussian with the current parameters.\n */\nPseudoVoigt.fct = function fct(x, fwhm, mu = 0.5) {\n  return (1 - mu) * Lorentzian.fct(x, fwhm) + mu * Gaussian.fct(x, fwhm);\n};\n\n/**\n * Compute the value of Full Width at Half Maximum (FMHM) from width between the inflection points.\n * @param {number} width - width between the inflection points\n * @param {number} [mu = 0.5] - ratio of gaussian contribution.\n * @returns {number} Full Width at Half Maximum (FMHM).\n */\nPseudoVoigt.widthToFWHM = function widthToFWHM(width, mu = 0.5) {\n  return width * (mu * ROOT_2LN2_MINUS_ONE + 1);\n};\n/**\n * Compute the value of width between the inflection points from Full Width at Half Maximum (FWHM).\n * @param {number} fwhm - Full Width at Half Maximum.\n * @param {number} [mu = 0.5] - ratio of gaussian contribution.\n * @returns {number} width between the inflection points.\n */\nPseudoVoigt.fwhmToWidth = function fwhmToWidth(fwhm, mu = 0.5) {\n  return fwhm / (mu * ROOT_2LN2_MINUS_ONE + 1);\n};\n\n/**\n * Calculate the area of a specific shape.\n * @param {number} fwhm - Full width at half maximum.\n * @param {*} [options = {}] - options.\n * @param {number} [options.height = 1] - Maximum y value of the shape.\n * @param {number} [options.mu = 0.5] - ratio of gaussian contribution.\n * @returns {number} - returns the area of the specific shape and parameters.\n */\nPseudoVoigt.getArea = function getArea(fwhm, options = {}) {\n  let { height = 1, mu = 0.5 } = options;\n  return (fwhm * height * (mu * ROOT_PI_OVER_LN2 + (1 - mu) * Math.PI)) / 2;\n};\n\n/**\n * Calculate the number of times FWHM allows to reach a specific area coverage\n * @param {number} [area=0.9999] - required area to be coverage\n * @param {number} [mu=this.mu] - ratio of gaussian contribution.\n * @returns {number}\n */\nPseudoVoigt.getFactor = function getFactor(area = 0.9999, mu = 0.5) {\n  return mu < 1 ? Lorentzian.getFactor(area) : Gaussian.getFactor(area);\n};\n","import { Gaussian } from '../classes/Gaussian';\nimport { Lorentzian } from '../classes/Lorentzian';\nimport { PseudoVoigt } from '../classes/PseudoVoigt';\n\nexport function getShapeGenerator(options) {\n  let { kind = 'Gaussian', options: shapeOptions } = options;\n  switch (kind.toLowerCase().replace(/[^a-z]/g, '')) {\n    case 'gaussian':\n      return new Gaussian(shapeOptions);\n    case 'lorentzian':\n      return new Lorentzian(shapeOptions);\n    case 'pseudovoigt':\n      return new PseudoVoigt(shapeOptions);\n    default:\n      throw new Error(`Unknown kind: ${kind}`);\n  }\n}\n","export default Math.random;\n","import defaultSource from \"./defaultSource.js\";\n\nexport default (function sourceRandomUniform(source) {\n  function randomUniform(min, max) {\n    min = min == null ? 0 : +min;\n    max = max == null ? 1 : +max;\n    if (arguments.length === 1) max = min, min = 0;\n    else max -= min;\n    return function() {\n      return source() * max + min;\n    };\n  }\n\n  randomUniform.source = sourceRandomUniform;\n\n  return randomUniform;\n})(defaultSource);\n","import defaultSource from \"./defaultSource.js\";\n\nexport default (function sourceRandomNormal(source) {\n  function randomNormal(mu, sigma) {\n    var x, r;\n    mu = mu == null ? 0 : +mu;\n    sigma = sigma == null ? 1 : +sigma;\n    return function() {\n      var y;\n\n      // If available, use the second previously-generated uniform random.\n      if (x != null) y = x, x = null;\n\n      // Otherwise, generate a new x and y.\n      else do {\n        x = source() * 2 - 1;\n        y = source() * 2 - 1;\n        r = x * x + y * y;\n      } while (!r || r > 1);\n\n      return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r);\n    };\n  }\n\n  randomNormal.source = sourceRandomNormal;\n\n  return randomNormal;\n})(defaultSource);\n","const LOOP = 8;\nconst FLOAT_MUL = 1 / 16777216;\nconst sh1 = 15;\nconst sh2 = 18;\nconst sh3 = 11;\nfunction multiply_uint32(n, m) {\n    n >>>= 0;\n    m >>>= 0;\n    const nlo = n & 0xffff;\n    const nhi = n - nlo;\n    return (((nhi * m) >>> 0) + nlo * m) >>> 0;\n}\nexport default class XSadd {\n    constructor(seed = Date.now()) {\n        this.state = new Uint32Array(4);\n        this.init(seed);\n        this.random = this.getFloat.bind(this);\n    }\n    /**\n     * Returns a 32-bit integer r (0 <= r < 2^32)\n     */\n    getUint32() {\n        this.nextState();\n        return (this.state[3] + this.state[2]) >>> 0;\n    }\n    /**\n     * Returns a floating point number r (0.0 <= r < 1.0)\n     */\n    getFloat() {\n        return (this.getUint32() >>> 8) * FLOAT_MUL;\n    }\n    init(seed) {\n        if (!Number.isInteger(seed)) {\n            throw new TypeError('seed must be an integer');\n        }\n        this.state[0] = seed;\n        this.state[1] = 0;\n        this.state[2] = 0;\n        this.state[3] = 0;\n        for (let i = 1; i < LOOP; i++) {\n            this.state[i & 3] ^=\n                (i +\n                    multiply_uint32(1812433253, this.state[(i - 1) & 3] ^ ((this.state[(i - 1) & 3] >>> 30) >>> 0))) >>>\n                    0;\n        }\n        this.periodCertification();\n        for (let i = 0; i < LOOP; i++) {\n            this.nextState();\n        }\n    }\n    periodCertification() {\n        if (this.state[0] === 0 &&\n            this.state[1] === 0 &&\n            this.state[2] === 0 &&\n            this.state[3] === 0) {\n            this.state[0] = 88; // X\n            this.state[1] = 83; // S\n            this.state[2] = 65; // A\n            this.state[3] = 68; // D\n        }\n    }\n    nextState() {\n        let t = this.state[0];\n        t ^= t << sh1;\n        t ^= t >>> sh2;\n        t ^= this.state[3] << sh3;\n        this.state[0] = this.state[1];\n        this.state[1] = this.state[2];\n        this.state[2] = this.state[3];\n        this.state[3] = t;\n    }\n}\n","import { randomUniform, randomNormal } from 'd3-random';\nimport XSAdd from 'ml-xsadd';\n\nexport default function addNoise(data, percent = 0, options = {}) {\n  const { distribution = 'uniform', seed } = options;\n\n  let generateRandomNumber;\n  switch (distribution) {\n    case 'uniform': {\n      generateRandomNumber = getRandom(randomUniform, seed, -0.5, 0.5);\n      break;\n    }\n    case 'normal': {\n      generateRandomNumber = getRandom(randomNormal, seed);\n      break;\n    }\n    default:\n      throw new Error(`Unknown distribution ${options.distribution}`);\n  }\n\n  if (!percent) return data;\n  let ys = data.y;\n  let factor = (percent * findMax(ys)) / 100;\n  for (let i = 0; i < ys.length; i++) {\n    ys[i] += generateRandomNumber() * factor;\n  }\n  return data;\n}\n\nfunction getRandom(func, seed, ...args) {\n  return typeof seed === 'number'\n    ? func.source(new XSAdd(seed).random)(...args)\n    : func(...args);\n}\n\nfunction findMax(array) {\n  let max = Number.MIN_VALUE;\n  for (let item of array) {\n    if (item > max) max = item;\n  }\n  return max;\n}\n","import { getShapeGenerator } from 'ml-peak-shape-generator';\n\nimport addBaseline from './util/addBaseline.js';\nimport addNoise from './util/addNoise.js';\n\nexport class SpectrumGenerator {\n  /**\n   *\n   * @param {object} [options={}]\n   * @param {number} [options.from=0]\n   * @param {number} [options.to=0]\n   * @param {function} [options.nbPoints=10001]\n   * @param {number} [options.factor] default value depends of the shape in order to cover 99.99% of the surface\n   * @param {object} [options.shape={kind:'gaussian'}]\n   * @param {string} [options.shape.kind] kind of shape, gaussian, lorentzian or pseudovoigt\n   * @param {object} [options.shape.options] options for the shape (like `mu` for pseudovoigt)\n   */\n  constructor(options = {}) {\n    options = Object.assign(\n      {},\n      {\n        from: 0,\n        to: 1000,\n        nbPoints: 10001,\n        peakWidthFct: () => 5,\n        shape: {\n          kind: 'gaussian',\n        },\n      },\n      options,\n    );\n\n    this.from = options.from;\n    this.to = options.to;\n    this.nbPoints = options.nbPoints;\n    this.interval = (this.to - this.from) / (this.nbPoints - 1);\n    this.peakWidthFct = options.peakWidthFct;\n    this.maxPeakHeight = Number.MIN_SAFE_INTEGER;\n\n    let shapeGenerator = getShapeGenerator(options.shape);\n    this.shape = shapeGenerator;\n\n    assertNumber(this.from, 'from');\n    assertNumber(this.to, 'to');\n    assertInteger(this.nbPoints, 'nbPoints');\n\n    if (this.to <= this.from) {\n      throw new RangeError('to option must be larger than from');\n    }\n\n    if (typeof this.peakWidthFct !== 'function') {\n      throw new TypeError('peakWidthFct option must be a function');\n    }\n\n    this.reset();\n  }\n\n  addPeaks(peaks, options) {\n    if (\n      !Array.isArray(peaks) &&\n      (typeof peaks !== 'object' ||\n        peaks.x === undefined ||\n        peaks.y === undefined ||\n        !Array.isArray(peaks.x) ||\n        !Array.isArray(peaks.y) ||\n        peaks.x.length !== peaks.y.length)\n    ) {\n      throw new TypeError(\n        'peaks must be an array or an object containing x[] and y[]',\n      );\n    }\n    if (Array.isArray(peaks)) {\n      for (const peak of peaks) {\n        this.addPeak(peak, options);\n      }\n    } else {\n      for (let i = 0; i < peaks.x.length; i++) {\n        this.addPeak([peaks.x[i], peaks.y[i]], options);\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   *\n   * @param {[x,y]|[x,y,w]|{x,y,width}} [peak]\n   * @param {*} options\n   */\n  addPeak(peak, options = {}) {\n    if (\n      typeof peak !== 'object' ||\n      (peak.length !== 2 &&\n        peak.length !== 3 &&\n        (peak.x === undefined || peak.y === undefined))\n    ) {\n      throw new Error(\n        'peak must be an array with two (or three) values or an object with {x,y,width?}',\n      );\n    }\n\n    let xPosition;\n    let intensity;\n    let peakWidth;\n    let peakOptions;\n    if (Array.isArray(peak)) {\n      [xPosition, intensity, peakWidth, peakOptions] = peak;\n    } else {\n      xPosition = peak.x;\n      intensity = peak.y;\n      peakWidth = peak.width;\n      peakOptions = peak.options;\n    }\n\n    if (intensity > this.maxPeakHeight) this.maxPeakHeight = intensity;\n\n    let {\n      width = peakWidth === undefined\n        ? this.peakWidthFct(xPosition)\n        : peakWidth,\n      widthLeft,\n      widthRight,\n      shape: shapeOptions,\n    } = options;\n\n    if (peakOptions) {\n      Object.assign(shapeOptions || {}, peakOptions || {});\n    }\n\n    let shapeGenerator = shapeOptions\n      ? getShapeGenerator(shapeOptions)\n      : this.shape;\n\n    if (!widthLeft) widthLeft = width;\n    if (!widthRight) widthRight = width;\n\n    let factor =\n      options.factor === undefined\n        ? shapeGenerator.getFactor()\n        : options.factor;\n\n    const firstValue = xPosition - (widthLeft / 2) * factor;\n    const lastValue = xPosition + (widthRight / 2) * factor;\n\n    const firstPoint = Math.max(\n      0,\n      Math.floor((firstValue - this.from) / this.interval),\n    );\n    const lastPoint = Math.min(\n      this.nbPoints - 1,\n      Math.ceil((lastValue - this.from) / this.interval),\n    );\n    const middlePoint = Math.round((xPosition - this.from) / this.interval);\n    // PEAK SHAPE MAY BE ASYMMETRC (widthLeft and widthRight) !\n    // we calculate the left part of the shape\n\n    shapeGenerator.setFWHM(widthLeft);\n    for (let index = firstPoint; index < Math.max(middlePoint, 0); index++) {\n      this.data.y[index] +=\n        intensity * shapeGenerator.fct(this.data.x[index] - xPosition);\n    }\n\n    // we calculate the right part of the gaussian\n    shapeGenerator.setFWHM(widthRight);\n    for (\n      let index = Math.min(middlePoint, lastPoint);\n      index <= lastPoint;\n      index++\n    ) {\n      this.data.y[index] +=\n        intensity * shapeGenerator.fct(this.data.x[index] - xPosition);\n    }\n\n    return this;\n  }\n\n  addBaseline(baselineFct) {\n    addBaseline(this.data, baselineFct);\n    return this;\n  }\n\n  addNoise(percent, options) {\n    addNoise(this.data, percent, options);\n    return this;\n  }\n\n  getSpectrum(options = {}) {\n    if (typeof options === 'boolean') {\n      options = { copy: options };\n    }\n    const { copy = true, threshold = 0 } = options;\n    if (threshold) {\n      let minPeakHeight = this.maxPeakHeight * threshold;\n      let x = [];\n      let y = [];\n      for (let i = 0; i < this.data.x.length; i++) {\n        if (this.data.y[i] >= minPeakHeight) {\n          x.push(this.data.x[i]);\n          y.push(this.data.y[i]);\n        }\n      }\n      return { x, y };\n    }\n    if (copy) {\n      return {\n        x: this.data.x.slice(),\n        y: this.data.y.slice(),\n      };\n    } else {\n      return this.data;\n    }\n  }\n\n  reset() {\n    const spectrum = (this.data = {\n      x: new Float64Array(this.nbPoints),\n      y: new Float64Array(this.nbPoints),\n    });\n\n    for (let i = 0; i < this.nbPoints; i++) {\n      spectrum.x[i] = this.from + i * this.interval;\n    }\n\n    return this;\n  }\n}\n\nfunction assertInteger(value, name) {\n  if (!Number.isInteger(value)) {\n    throw new TypeError(`${name} option must be an integer`);\n  }\n}\n\nfunction assertNumber(value, name) {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`${name} option must be a number`);\n  }\n}\n\nexport function generateSpectrum(peaks, options = {}) {\n  const generator = new SpectrumGenerator(options);\n\n  generator.addPeaks(peaks, options);\n  if (options.baseline) generator.addBaseline(options.baseline);\n  if (options.noise) generator.addNoise(options.noise.percent, options.noise);\n  return generator.getSpectrum({\n    threshold: options.threshold,\n  });\n}\n","export default function addBaseline(data, baselineFct) {\n  if (!baselineFct) return data;\n  let xs = data.x;\n  let ys = data.y;\n  for (let i = 0; i < xs.length; i++) {\n    ys[i] += baselineFct(xs[i]);\n  }\n  return data;\n}\n"],"names":["GAUSSIAN_EXP_FACTOR","Math","LN2","ROOT_PI_OVER_LN2","sqrt","PI","ROOT_THREE","ROOT_2LN2","ROOT_2LN2_MINUS_ONE","Gaussian","constructor","options","fwhm","sd","widthToFWHM","height","undefined","this","getData","length","factor","getFactor","min","ceil","pow","center","data","Float64Array","i","fct","x","area","getArea","width","fwhmToWidth","setFWHM","setHeight","exp","ln1MinusXSqrd","log","lnEtcBy2Plus2","firstSqrt","erfinv","Lorentzian","squareFWHM","tan","PseudoVoigt","mu","setMu","getShapeGenerator","kind","shapeOptions","toLowerCase","replace","Error","random","sourceRandomUniform","source","randomUniform","max","arguments","defaultSource","sourceRandomNormal","randomNormal","sigma","r","y","multiply_uint32","n","m","nlo","XSadd","seed","Date","now","state","Uint32Array","init","getFloat","bind","getUint32","nextState","Number","isInteger","TypeError","periodCertification","t","addNoise","percent","distribution","generateRandomNumber","getRandom","ys","array","MIN_VALUE","item","findMax","func","args","XSAdd","SpectrumGenerator","Object","assign","from","to","nbPoints","peakWidthFct","shape","interval","maxPeakHeight","MIN_SAFE_INTEGER","shapeGenerator","assertNumber","value","name","assertInteger","RangeError","reset","addPeaks","peaks","Array","isArray","peak","addPeak","xPosition","intensity","peakWidth","peakOptions","widthLeft","widthRight","firstValue","lastValue","firstPoint","floor","lastPoint","middlePoint","round","index","addBaseline","baselineFct","xs","getSpectrum","copy","threshold","minPeakHeight","push","slice","spectrum","isFinite","generator","baseline","noise"],"mappings":"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"}