{"version":3,"file":"spectrum-generator.min.js","sources":["../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/2d/gaussian2D/Gaussian2D.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/getShape1D.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/2d/getShape2D.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","../lib-esm/util/addNoise.js","../lib-esm/SpectrumGenerator.js","../lib-esm/util/addBaseline.js","../node_modules/is-any-array/src/index.js","../node_modules/ml-array-max/lib-es6/index.js","../node_modules/ml-array-min/lib-es6/index.js","../lib-esm/Spectrum2DGenerator.js","../lib-esm/util/getMinMax.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//# 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}\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}\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}\nexport const calculateLorentzianHeight = ({ fwhm = 1, area = 1 }) => {\n    return (2 * area) / Math.PI / fwhm;\n};\nexport const lorentzianFct = (x, fwhm) => {\n    return Math.pow(fwhm, 2) / (4 * Math.pow(x, 2) + Math.pow(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 getLorentzianArea = (options) => {\n    const { fwhm = 500, height = 1 } = options;\n    return (height * Math.PI * fwhm) / 2;\n};\nexport const getLorentzianFactor = (area = 0.9999) => {\n    return 2 * Math.tan(Math.PI * (area - 0.5));\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}\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_EXP_FACTOR } from '../../../util/constants';\nimport { getGaussianFactor, gaussianFwhmToWidth, gaussianWidthToFWHM, } from '../../1d/gaussian/Gaussian';\nexport class Gaussian2D {\n    constructor(options = {}) {\n        let { fwhm = 50, sd } = options;\n        fwhm = ensureFWHM2D(fwhm, sd);\n        this.fwhmX = fwhm.x;\n        this.fwhmY = fwhm.y;\n    }\n    fct(x, y) {\n        return gaussian2DFct(x, y, this.fwhmX, this.fwhmY);\n    }\n    getData(options = {}) {\n        return getGaussian2DData({\n            fwhm: { x: this.fwhmX, y: this.fwhmY },\n        }, options);\n    }\n    getFactor(volume = 1) {\n        return getGaussianFactor(volume);\n    }\n    getVolume(height = calculateGaussian2DHeight({\n        fwhm: { x: this.fwhmX, y: this.fwhmY },\n        volume: 1,\n    })) {\n        return getGaussian2DVolume({\n            fwhm: { x: this.fwhmX, y: this.fwhmY },\n            height,\n        });\n    }\n    widthToFWHM(width) {\n        return gaussianWidthToFWHM(width);\n    }\n    fwhmToWidth(fwhm) {\n        return gaussianFwhmToWidth(fwhm);\n    }\n    calculateHeight(volume = 1) {\n        return calculateGaussian2DHeight({\n            volume,\n            fwhm: { x: this.fwhmX, y: this.fwhmY },\n        });\n    }\n    set fwhm(fwhm) {\n        fwhm = ensureXYNumber(fwhm);\n        this.fwhmX = fwhm.x;\n        this.fwhmY = fwhm.y;\n    }\n}\nexport const gaussian2DFct = (x, y, xFWHM, yFWHM) => {\n    return Math.exp(GAUSSIAN_EXP_FACTOR * (Math.pow(x / xFWHM, 2) + Math.pow(y / yFWHM, 2)));\n};\nexport const getGaussian2DData = (shape, options = {}) => {\n    let { fwhm = 50, sd } = shape;\n    fwhm = ensureFWHM2D(fwhm, sd);\n    let { factor = getGaussianFactor(), length = { x: 0, y: 0 }, height = calculateGaussian2DHeight({ fwhm, volume: 1 }), } = options;\n    factor = ensureXYNumber(factor);\n    length = ensureXYNumber(length);\n    for (const axis of ['x', 'y']) {\n        if (!length[axis]) {\n            length[axis] = Math.min(Math.ceil(fwhm[axis] * factor[axis]), Math.pow(2, 25) - 1);\n            if (length[axis] % 2 === 0)\n                length[axis]++;\n        }\n    }\n    const xCenter = (length.x - 1) / 2;\n    const yCenter = (length.y - 1) / 2;\n    const data = new Array(length.x);\n    for (let i = 0; i < length.x; i++) {\n        data[i] = new Float64Array(length.y);\n    }\n    for (let i = 0; i < length.x; i++) {\n        for (let j = 0; j < length.y; j++) {\n            data[i][j] =\n                gaussian2DFct(i - xCenter, j - yCenter, fwhm.x, fwhm.y) * height;\n        }\n    }\n    return data;\n};\nexport const calculateGaussian2DHeight = (options = {}) => {\n    let { volume = 1, fwhm = 50, sd } = options;\n    fwhm = ensureFWHM2D(fwhm, sd);\n    return (volume * Math.LN2 * 4) / (Math.PI * fwhm.y * fwhm.x);\n};\nexport const getGaussian2DVolume = (options = {}) => {\n    let { fwhm = 50, height = 1, sd } = options;\n    fwhm = ensureFWHM2D(fwhm, sd);\n    return (height * Math.PI * fwhm.y * fwhm.x) / Math.LN2 / 4;\n};\nfunction ensureXYNumber(input) {\n    return typeof input !== 'object' ? { x: input, y: input } : { ...input };\n}\nfunction ensureFWHM2D(fwhm, sd) {\n    if (sd !== undefined) {\n        let sdObject = ensureXYNumber(sd);\n        return {\n            x: gaussianWidthToFWHM(2 * sdObject.x),\n            y: gaussianWidthToFWHM(2 * sdObject.y),\n        };\n    }\n    else if (fwhm !== undefined) {\n        return ensureXYNumber(fwhm);\n    }\n    else {\n        throw new Error('ensureFWHM2D must have either fwhm or sd defined');\n    }\n}\n//# sourceMappingURL=Gaussian2D.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","import { Gaussian2D } from './gaussian2D/Gaussian2D';\n/**\n * Generate a instance of a specific kind of shape.\n */\nexport function getShape2D(shape) {\n    const { kind } = shape;\n    switch (kind) {\n        case 'gaussian':\n            return new Gaussian2D(shape);\n        default: {\n            const unHandled = kind;\n            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n            throw Error(`Unknown distribution ${unHandled}`);\n        }\n    }\n}\n//# sourceMappingURL=getShape2D.js.map","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';\nexport default function addNoise(data, percent = 0, options = {}) {\n    const { seed } = options;\n    const distribution = options.distribution || 'uniform';\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            const unHandled = distribution;\n            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n            throw Error(`Unknown distribution ${unHandled}`);\n        }\n    }\n    if (!percent)\n        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}\nfunction getRandom(func, seed, ...args) {\n    return typeof seed === 'number'\n        ? func.source(new XSAdd(seed).random)(...args)\n        : func(...args);\n}\nfunction findMax(array) {\n    let max = Number.MIN_VALUE;\n    for (let item of array) {\n        if (item > max)\n            max = item;\n    }\n    return max;\n}\n//# sourceMappingURL=addNoise.js.map","import { getShape1D } from 'ml-peak-shape-generator';\nimport addBaseline from './util/addBaseline';\nimport addNoise from './util/addNoise';\nexport class SpectrumGenerator {\n    constructor(options = {}) {\n        const { from = 0, to = 1000, nbPoints = 10001, peakWidthFct = () => 5, shape = { kind: 'gaussian' }, } = options;\n        this.from = from;\n        this.to = to;\n        this.nbPoints = nbPoints;\n        this.interval = (this.to - this.from) / (this.nbPoints - 1);\n        this.peakWidthFct = peakWidthFct;\n        this.maxPeakHeight = Number.MIN_SAFE_INTEGER;\n        this.data = {\n            x: new Float64Array(this.nbPoints),\n            y: new Float64Array(this.nbPoints),\n        };\n        let shapeGenerator = getShape1D(shape);\n        this.shape = shapeGenerator;\n        assertNumber(this.from, 'from');\n        assertNumber(this.to, 'to');\n        assertInteger(this.nbPoints, 'nbPoints');\n        if (this.to <= this.from) {\n            throw new RangeError('to option must be larger than from');\n        }\n        if (typeof this.peakWidthFct !== 'function') {\n            throw new TypeError('peakWidthFct option must be a function');\n        }\n        this.reset();\n    }\n    /**\n     * Add a series of peaks to the spectrum.\n     * @param peaks - Peaks to add.\n     */\n    addPeaks(peaks, options) {\n        if (!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            throw new TypeError('peaks must be an array or an object containing x[] and y[]');\n        }\n        if (Array.isArray(peaks)) {\n            for (const peak of peaks) {\n                this.addPeak(peak, options);\n            }\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    /**\n     * Add a single peak to the spectrum.\n     * @param peak\n     * @param options\n     */\n    addPeak(peak, options = {}) {\n        if (Array.isArray(peak) && peak.length < 2) {\n            throw new Error('peak must be an array with two (or three) values or an object with {x,y,width?}');\n        }\n        if (!Array.isArray(peak) &&\n            (peak.x === undefined || peak.y === undefined)) {\n            throw new Error('peak must be an array with two (or three) values or an object with {x,y,width?}');\n        }\n        let xPosition;\n        let intensity;\n        let peakFWHM;\n        let peakShapeOptions;\n        if (Array.isArray(peak)) {\n            [xPosition, intensity, peakFWHM, peakShapeOptions] = peak;\n        }\n        else {\n            xPosition = peak.x;\n            intensity = peak.y;\n            peakFWHM = peak.fwhm || peak.width;\n            peakShapeOptions = peak.shape;\n        }\n        if (intensity > this.maxPeakHeight)\n            this.maxPeakHeight = intensity;\n        let { fwhm = peakFWHM === undefined ? this.peakWidthFct(xPosition) : peakFWHM, widthLeft, widthRight, shape: shapeOptions, } = options;\n        if (peakShapeOptions) {\n            shapeOptions = shapeOptions\n                ? { ...shapeOptions, ...peakShapeOptions }\n                : peakShapeOptions;\n        }\n        if (shapeOptions) {\n            this.shape = getShape1D(shapeOptions);\n        }\n        if (!widthLeft)\n            widthLeft = fwhm;\n        if (!widthRight)\n            widthRight = fwhm;\n        if (!widthLeft || !widthRight) {\n            throw new Error('Width left or right is undefined or zero');\n        }\n        let factor = options.factor === undefined ? this.shape.getFactor() : options.factor;\n        const firstValue = xPosition - (widthLeft / 2) * factor;\n        const lastValue = xPosition + (widthRight / 2) * factor;\n        const firstPoint = Math.max(0, Math.floor((firstValue - this.from) / this.interval));\n        const lastPoint = Math.min(this.nbPoints - 1, Math.ceil((lastValue - this.from) / this.interval));\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        this.shape.fwhm = widthLeft;\n        for (let index = firstPoint; index < Math.max(middlePoint, 0); index++) {\n            this.data.y[index] +=\n                intensity * this.shape.fct(this.data.x[index] - xPosition);\n        }\n        // we calculate the right part of the gaussian\n        this.shape.fwhm = widthRight;\n        for (let index = Math.min(middlePoint, lastPoint); index <= lastPoint; index++) {\n            this.data.y[index] +=\n                intensity * this.shape.fct(this.data.x[index] - xPosition);\n        }\n    }\n    /**\n     * Add a baseline to the spectrum.\n     * @param baselineFct - Mathematical function producing the baseline you want.\n     */\n    addBaseline(baselineFct) {\n        addBaseline(this.data, baselineFct);\n        return this;\n    }\n    /**\n     * Add noise to the spectrum.\n     * @param percent - Noise's amplitude in percents of the spectrum max value. Default: 0.\n     */\n    addNoise(percent, options) {\n        addNoise(this.data, percent, options);\n        return this;\n    }\n    /**\n     * Get the generated spectrum.\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        }\n        else {\n            return this.data;\n        }\n    }\n    /**\n     * Resets the generator with an empty spectrum.\n     */\n    reset() {\n        const spectrum = this.data;\n        for (let i = 0; i < this.nbPoints; i++) {\n            spectrum.x[i] = this.from + i * this.interval;\n        }\n        return this;\n    }\n}\nfunction assertInteger(value, name) {\n    if (!Number.isInteger(value)) {\n        throw new TypeError(`${name} option must be an integer`);\n    }\n}\nfunction assertNumber(value, name) {\n    if (!Number.isFinite(value)) {\n        throw new TypeError(`${name} option must be a number`);\n    }\n}\n/**\n * Generates a spectrum and returns it.\n * @param peaks - List of peaks to put in the spectrum.\n * @param options\n */\nexport function generateSpectrum(peaks, options = {}) {\n    const { generator: generatorOptions, noise, baseline, threshold, peaks: addPeaksOptions, } = options;\n    const generator = new SpectrumGenerator(generatorOptions);\n    generator.addPeaks(peaks, addPeaksOptions);\n    if (baseline)\n        generator.addBaseline(baseline);\n    if (noise) {\n        const { percent, options: addNoiseOptions } = noise;\n        generator.addNoise(percent, addNoiseOptions);\n    }\n    return generator.getSpectrum({\n        threshold,\n    });\n}\n//# sourceMappingURL=SpectrumGenerator.js.map","export default function addBaseline(data, baselineFct) {\n    if (!baselineFct)\n        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//# sourceMappingURL=addBaseline.js.map","const toString = Object.prototype.toString;\n\nexport default function isAnyArray(object) {\n  return toString.call(object).endsWith('Array]');\n}\n","import isArray from 'is-any-array';\n\nfunction max(input) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  if (!isArray(input)) {\n    throw new TypeError('input must be an array');\n  }\n\n  if (input.length === 0) {\n    throw new TypeError('input must not be empty');\n  }\n\n  var _options$fromIndex = options.fromIndex,\n      fromIndex = _options$fromIndex === void 0 ? 0 : _options$fromIndex,\n      _options$toIndex = options.toIndex,\n      toIndex = _options$toIndex === void 0 ? input.length : _options$toIndex;\n\n  if (fromIndex < 0 || fromIndex >= input.length || !Number.isInteger(fromIndex)) {\n    throw new Error('fromIndex must be a positive integer smaller than length');\n  }\n\n  if (toIndex <= fromIndex || toIndex > input.length || !Number.isInteger(toIndex)) {\n    throw new Error('toIndex must be an integer greater than fromIndex and at most equal to length');\n  }\n\n  var maxValue = input[fromIndex];\n\n  for (var i = fromIndex + 1; i < toIndex; i++) {\n    if (input[i] > maxValue) maxValue = input[i];\n  }\n\n  return maxValue;\n}\n\nexport default max;\n","import isArray from 'is-any-array';\n\nfunction min(input) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  if (!isArray(input)) {\n    throw new TypeError('input must be an array');\n  }\n\n  if (input.length === 0) {\n    throw new TypeError('input must not be empty');\n  }\n\n  var _options$fromIndex = options.fromIndex,\n      fromIndex = _options$fromIndex === void 0 ? 0 : _options$fromIndex,\n      _options$toIndex = options.toIndex,\n      toIndex = _options$toIndex === void 0 ? input.length : _options$toIndex;\n\n  if (fromIndex < 0 || fromIndex >= input.length || !Number.isInteger(fromIndex)) {\n    throw new Error('fromIndex must be a positive integer smaller than length');\n  }\n\n  if (toIndex <= fromIndex || toIndex > input.length || !Number.isInteger(toIndex)) {\n    throw new Error('toIndex must be an integer greater than fromIndex and at most equal to length');\n  }\n\n  var minValue = input[fromIndex];\n\n  for (var i = fromIndex + 1; i < toIndex; i++) {\n    if (input[i] < minValue) minValue = input[i];\n  }\n\n  return minValue;\n}\n\nexport default min;\n","import { getShape2D } from 'ml-peak-shape-generator';\nimport { getMinMax } from './util/getMinMax';\nconst axis2D = ['x', 'y'];\nconst peakCoordinates = ['x', 'y', 'z'];\nexport class Spectrum2DGenerator {\n    constructor(options = {}) {\n        let { from = 0, to = 100, nbPoints = 1001, peakWidthFct = () => 5, shape = {\n            kind: 'gaussian',\n        }, } = options;\n        from = ensureXYNumber(from);\n        to = ensureXYNumber(to);\n        nbPoints = ensureXYNumber(nbPoints);\n        for (const axis of axis2D) {\n            assertNumber(from[axis], `from-${axis}`);\n            assertNumber(to[axis], `to-${axis}`);\n            assertInteger(nbPoints[axis], `nbPoints-${axis}`);\n        }\n        this.from = from;\n        this.to = to;\n        this.nbPoints = nbPoints;\n        this.interval = calculeIntervals(from, to, nbPoints);\n        this.peakWidthFct = peakWidthFct;\n        this.maxPeakHeight = Number.MIN_SAFE_INTEGER;\n        let shapeGenerator = getShape2D(shape);\n        this.shape = shapeGenerator;\n        this.data = {\n            x: new Float64Array(nbPoints.x),\n            y: new Float64Array(nbPoints.y),\n            z: createMatrix(this.nbPoints),\n        };\n        for (const axis of axis2D) {\n            if (this.to[axis] <= this.from[axis]) {\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        this.reset();\n    }\n    addPeaks(peaks, options) {\n        if (!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            throw new TypeError('peaks must be an array or an object containing x[] and y[]');\n        }\n        if (Array.isArray(peaks)) {\n            for (const peak of peaks) {\n                this.addPeak(peak, options);\n            }\n        }\n        else {\n            let nbPeaks = peaks.x.length;\n            for (const c of peakCoordinates) {\n                if (peaks[c] && Array.isArray(peaks[c])) {\n                    if (nbPeaks !== peaks[c].length) {\n                        throw new Error('x, y, z should have the same length');\n                    }\n                }\n            }\n            for (let i = 0; i < peaks.x.length; i++) {\n                this.addPeak([peaks.x[i], peaks.y[i], peaks.z[i]], options);\n            }\n        }\n        return this;\n    }\n    addPeak(peak, options = {}) {\n        if (Array.isArray(peak) && peak.length < 3) {\n            throw new Error('peak must be an array with three (or four) values or an object with {x,y,z,width?}');\n        }\n        if (!Array.isArray(peak) &&\n            peakCoordinates.some((e) => peak[e] === undefined)) {\n            throw new Error('peak must be an array with three (or four) values or an object with {x,y,z,width?}');\n        }\n        let xPosition;\n        let yPosition;\n        let intensity;\n        let peakFWHM;\n        let peakShapeOptions;\n        if (Array.isArray(peak)) {\n            [xPosition, yPosition, intensity, peakFWHM, peakShapeOptions] = peak;\n        }\n        else {\n            xPosition = peak.x;\n            yPosition = peak.y;\n            intensity = peak.z;\n            peakFWHM = peak.fwhm || peak.width;\n            peakShapeOptions = peak.shape;\n        }\n        const position = { x: xPosition, y: yPosition };\n        if (intensity > this.maxPeakHeight)\n            this.maxPeakHeight = intensity;\n        let { fwhm = peakFWHM === undefined\n            ? this.peakWidthFct(xPosition, yPosition)\n            : peakFWHM, shape: shapeOptions, } = options;\n        if (peakShapeOptions) {\n            shapeOptions = shapeOptions\n                ? { ...shapeOptions, ...peakShapeOptions }\n                : peakShapeOptions;\n        }\n        if (shapeOptions) {\n            this.shape = getShape2D(shapeOptions);\n        }\n        fwhm = ensureXYNumber(fwhm);\n        let factor = options.factor === undefined ? this.shape.getFactor() : options.factor;\n        factor = ensureXYNumber(factor);\n        const firstPoint = { x: 0, y: 0 };\n        const lastPoint = { x: 0, y: 0 };\n        for (const axis of axis2D) {\n            const first = position[axis] - (fwhm[axis] / 2) * factor[axis];\n            const last = position[axis] + (fwhm[axis] / 2) * factor[axis];\n            firstPoint[axis] = Math.max(0, Math.floor((first - this.from[axis]) / this.interval[axis]));\n            lastPoint[axis] = Math.min(this.nbPoints[axis], Math.ceil((last - this.from[axis]) / this.interval[axis]));\n        }\n        this.shape.fwhm = fwhm;\n        for (let xIndex = firstPoint.x; xIndex < lastPoint.x; xIndex++) {\n            for (let yIndex = firstPoint.y; yIndex < lastPoint.y; yIndex++) {\n                this.data.z[yIndex][xIndex] +=\n                    intensity *\n                        this.shape.fct(this.data.x[xIndex] - position.x, this.data.y[yIndex] - position.y);\n            }\n        }\n        return this;\n    }\n    getSpectrum(options = {}) {\n        if (typeof options === 'boolean') {\n            options = { copy: options };\n        }\n        const { copy = true } = options;\n        let minMaxZ = getMinMax(this.data.z);\n        return {\n            minX: this.from.x,\n            maxX: this.to.x,\n            maxY: this.to.y,\n            minY: this.from.y,\n            minZ: minMaxZ.min,\n            maxZ: minMaxZ.max,\n            z: copy ? this.data.z.slice() : this.data.z,\n        };\n    }\n    reset() {\n        const spectrum = this.data;\n        for (const axis of axis2D) {\n            for (let i = 0; i < this.nbPoints[axis]; i++) {\n                spectrum[axis][i] = this.from[axis] + i * this.interval[axis];\n            }\n        }\n        for (let row of spectrum.z) {\n            for (let j = 0; j < row.length; j++) {\n                row[j] = 0;\n            }\n        }\n        return this;\n    }\n}\nexport function generateSpectrum2D(peaks, options = {}) {\n    const { generator: generatorOptions, peaks: addPeaksOptions } = options;\n    const generator = new Spectrum2DGenerator(generatorOptions);\n    generator.addPeaks(peaks, addPeaksOptions);\n    return generator.getSpectrum();\n}\nfunction ensureXYNumber(input) {\n    let result = typeof input !== 'object' ? { x: input, y: input } : input;\n    return result;\n}\nfunction calculeIntervals(from, to, nbPoints) {\n    return {\n        x: (to.x - from.x) / (nbPoints.x - 1),\n        y: (to.y - from.y) / (nbPoints.y - 1),\n    };\n}\nfunction assertInteger(value, name) {\n    if (!Number.isInteger(value)) {\n        throw new TypeError(`${name} option must be an integer`);\n    }\n}\nfunction assertNumber(value, name) {\n    if (!Number.isFinite(value)) {\n        throw new TypeError(`${name} option must be a number`);\n    }\n}\nfunction createMatrix(nbPoints) {\n    const zMatrix = new Array(nbPoints.y);\n    for (let i = 0; i < nbPoints.y; i++) {\n        zMatrix[i] = new Float64Array(nbPoints.x);\n    }\n    return zMatrix;\n}\n//# sourceMappingURL=Spectrum2DGenerator.js.map","import maxArray from 'ml-array-max';\nimport minArray from 'ml-array-min';\nexport function getMinMax(data) {\n    let min = Number.MAX_SAFE_INTEGER;\n    let max = Number.MIN_SAFE_INTEGER;\n    for (let row of data) {\n        let rowMin = minArray(row);\n        let rowMax = maxArray(row);\n        if (min > rowMin)\n            min = rowMin;\n        if (max < rowMax)\n            max = rowMax;\n    }\n    return { min, max };\n}\n//# sourceMappingURL=getMinMax.js.map"],"names":["GAUSSIAN_EXP_FACTOR","Math","LN2","ROOT_PI_OVER_LN2","sqrt","PI","ROOT_THREE","ROOT_2LN2","ROOT_2LN2_MINUS_ONE","erfinv","x","ln1MinusXSqrd","log","lnEtcBy2Plus2","firstSqrt","Gaussian","constructor","options","fwhm","sd","gaussianWidthToFWHM","fwhmToWidth","gaussianFwhmToWidth","this","widthToFWHM","width","fct","gaussianFct","getArea","height","calculateGaussianHeight","getGaussianArea","getFactor","area","getGaussianFactor","getData","shape","length","factor","min","ceil","pow","center","data","Float64Array","i","getGaussianData","calculateHeight","exp","Lorentzian","lorentzianFwhmToWidth","lorentzianWidthToFWHM","lorentzianFct","getLorentzianArea","getLorentzianFactor","getLorentzianData","calculateLorentzianHeight","_ref","tan","PseudoVoigt","mu","pseudoVoigtFwhmToWidth","pseudoVoigtWidthToFWHM","pseudoVoigtFct","getPseudoVoigtArea","getPseudoVoigtFactor","calculatePseudoVoigtHeight","getPseudoVoigtData","Gaussian2D","ensureFWHM2D","fwhmX","fwhmY","y","gaussian2DFct","getGaussian2DData","getVolume","calculateGaussian2DHeight","volume","getGaussian2DVolume","ensureXYNumber","xFWHM","yFWHM","axis","xCenter","yCenter","Array","j","input","undefined","sdObject","Error","getShape1D","kind","getShape2D","random","sourceRandomUniform","source","randomUniform","max","arguments","defaultSource","sourceRandomNormal","randomNormal","sigma","r","multiply_uint32","n","m","nlo","XSadd","seed","Date","now","state","Uint32Array","init","getFloat","bind","getUint32","nextState","Number","isInteger","TypeError","periodCertification","t","getRandom","func","args","XSAdd","findMax","array","MIN_VALUE","item","SpectrumGenerator","from","to","nbPoints","peakWidthFct","interval","maxPeakHeight","MIN_SAFE_INTEGER","shapeGenerator","assertNumber","value","name","assertInteger","RangeError","reset","addPeaks","peaks","isArray","peak","addPeak","xPosition","intensity","peakFWHM","peakShapeOptions","widthLeft","widthRight","shapeOptions","firstValue","lastValue","firstPoint","floor","lastPoint","middlePoint","round","index","addBaseline","baselineFct","xs","ys","addNoise","percent","distribution","generateRandomNumber","getSpectrum","copy","threshold","minPeakHeight","push","slice","spectrum","isFinite","toString","Object","prototype","isAnyArray","object","call","endsWith","_options$fromIndex","fromIndex","_options$toIndex","toIndex","maxValue","minValue","axis2D","peakCoordinates","Spectrum2DGenerator","calculeIntervals","z","createMatrix","nbPeaks","c","yPosition","some","e","position","first","last","xIndex","yIndex","minMaxZ","MAX_SAFE_INTEGER","row","rowMin","minArray","rowMax","maxArray","getMinMax","minX","maxX","maxY","minY","minZ","maxZ","zMatrix","generator","generatorOptions","noise","baseline","addPeaksOptions","addNoiseOptions"],"mappings":"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"}