{"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/shapes/1d/gaussian/Gaussian.js","../node_modules/ml-peak-shape-generator/lib-esm/util/erfinv.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/is-any-array/lib-esm/index.js","../node_modules/ml-spectra-processing/lib-esm/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xMaxValue.js","../node_modules/ml-spectra-processing/lib-esm/x/xCheck.js","../node_modules/ml-spectra-processing/lib-esm/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib-esm/matrix/matrixMinMaxZ.js","../node_modules/ml-spectra-processing/lib-esm/matrix/matrixCheck.js","../node_modules/ml-xsadd/lib-es6/xsadd.js","../node_modules/ml-spectra-processing/lib-esm/utils/createRandomArray.js","../lib-esm/util/addNoise.js","../node_modules/ml-spectra-processing/lib-esm/x/xAdd.js","../lib-esm/SpectrumGenerator.js","../lib-esm/util/addBaseline.js","../lib-esm/Spectrum2DGenerator.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","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","// 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_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_EXP_FACTOR } from '../../../util/constants';\nimport { getGaussianFactor, gaussianFwhmToWidth, gaussianWidthToFWHM, } from '../../1d/gaussian/Gaussian';\nexport class Gaussian2D {\n    constructor(options = {}) {\n        let { fwhm = 20, 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","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","/**\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 { 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 { isAnyArray } from 'is-any-array';\n/**\n * Checks if input is of type array\n *\n * @param input - input\n */\nexport function xCheck(input, options = {}) {\n    const { minLength } = options;\n    if (!isAnyArray(input)) {\n        throw new TypeError('input must be an array');\n    }\n    if (input.length === 0) {\n        throw new TypeError('input must not be empty');\n    }\n    //@ts-expect-error we already checked that input is an array\n    if (minLength && input.length < minLength) {\n        throw new Error(`input must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xCheck.js.map","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 { matrixCheck } from './matrixCheck';\n/**\n * Get min and max Z\n *\n * @param matrix - matrix [rows][cols].\n */\nexport function matrixMinMaxZ(matrix) {\n    matrixCheck(matrix);\n    const nbRows = matrix.length;\n    const nbColumns = matrix[0].length;\n    let min = matrix[0][0];\n    let max = matrix[0][0];\n    for (let column = 0; column < nbColumns; column++) {\n        for (let row = 0; row < nbRows; row++) {\n            if (matrix[row][column] < min)\n                min = matrix[row][column];\n            if (matrix[row][column] > max)\n                max = matrix[row][column];\n        }\n    }\n    return { min, max };\n}\n//# sourceMappingURL=matrixMinMaxZ.js.map","export function matrixCheck(data) {\n    if (data.length === 0 || data[0].length === 0) {\n        throw new RangeError('matrix should contain data');\n    }\n    const firstLength = data[0].length;\n    for (let i = 1; i < data.length; i++) {\n        if (data[i].length !== firstLength) {\n            throw new RangeError('All rows should has the same length');\n        }\n    }\n}\n//# sourceMappingURL=matrixCheck.js.map","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 XSAdd from 'ml-xsadd';\n/**\n * Create a random array of numbers of a specific length\n *\n * @return - array of random floats normally distributed\n */\nlet spare;\nlet hasSpare = false;\nexport function createRandomArray(options = {}) {\n    const { mean = 0, standardDeviation = 1, length = 1000, range = 1, seed, distribution = 'normal', } = options;\n    const generator = new XSAdd(seed);\n    let returnArray = new Float64Array(length);\n    switch (distribution) {\n        case 'normal':\n            for (let i = 0; i < length; i++) {\n                returnArray[i] = generateGaussian(mean, standardDeviation, generator);\n            }\n            break;\n        case 'uniform':\n            for (let i = 0; i < length; i++) {\n                returnArray[i] = (generator.random() - 0.5) * range + mean;\n            }\n            break;\n        default:\n            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n            throw new Error(`unknown distribution: ${distribution}`);\n    }\n    return returnArray;\n}\nfunction generateGaussian(mean, standardDeviation, generator) {\n    let val, u, v, s;\n    if (hasSpare) {\n        hasSpare = false;\n        val = spare * standardDeviation + mean;\n    }\n    else {\n        do {\n            u = generator.random() * 2 - 1;\n            v = generator.random() * 2 - 1;\n            s = u * u + v * v;\n        } while (s >= 1 || s === 0);\n        s = Math.sqrt((-2 * Math.log(s)) / s);\n        spare = v * s;\n        hasSpare = true;\n        val = mean + standardDeviation * u * s;\n    }\n    return val;\n}\n//# sourceMappingURL=createRandomArray.js.map","import { xMaxValue, xAdd, createRandomArray } from 'ml-spectra-processing';\nexport default function addNoise(data, options = {}) {\n    const { seed = 0, distribution = 'normal', percent = 1 } = options;\n    const range = (xMaxValue(data.y) * percent) / 100;\n    const noise = createRandomArray({\n        distribution,\n        seed,\n        mean: 0,\n        standardDeviation: range,\n        range,\n        length: data.x.length,\n    });\n    data.y = xAdd(data.y, noise);\n    return data;\n}\n//# sourceMappingURL=addNoise.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * This function xAdd the first array by the second array or a constant value to each element of the first array\n *\n * @param array1 - the first array\n * @param array2 - the second array or number\n */\nexport function xAdd(array1, array2) {\n    let isConstant = false;\n    let constant = 0;\n    if (isAnyArray(array2)) {\n        if (array1.length !== array2.length) {\n            throw new Error('xAdd: size of array1 and array2 must be identical');\n        }\n    }\n    else {\n        isConstant = true;\n        constant = array2;\n    }\n    let array3 = new Float64Array(array1.length);\n    if (isConstant) {\n        for (let i = 0; i < array1.length; i++) {\n            array3[i] = array1[i] + constant;\n        }\n    }\n    else {\n        for (let i = 0; i < array1.length; i++) {\n            array3[i] = array1[i] + array2[i];\n        }\n    }\n    return array3;\n}\n//# sourceMappingURL=xAdd.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, shape = { kind: 'gaussian', fwhm: 5 }, } = 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 (this.peakWidthFct && 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     * A peak may be either defined as [x,y,fwhm,...] or as {x, y, shape}\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 peakWidth;\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            peakWidth = peak.width;\n            peakShapeOptions = peak.shape;\n        }\n        if (intensity > this.maxPeakHeight)\n            this.maxPeakHeight = intensity;\n        let { shape: shapeOptions } = options;\n        if (peakShapeOptions) {\n            shapeOptions = shapeOptions\n                ? { ...shapeOptions, ...peakShapeOptions }\n                : peakShapeOptions;\n        }\n        const shape = shapeOptions\n            ? getShape1D(shapeOptions)\n            : Object.assign(Object.create(Object.getPrototypeOf(this.shape)), this.shape);\n        let { width, widthLeft, widthRight } = options;\n        /*\n         if we don't force the fwhm we just take the one from the shape\n         however we have many way to force it:\n         - use [x,y,fwhm]\n         - define `width` that will be converted to fwhm\n         - define `widthLeft` and `widthRight` to define asymmetric peaks\n         - have a callback `peakWidthFct`\n         This should evolve in the future because we will not always have `fwhm`\n         */\n        const fwhm = peakFWHM !== undefined\n            ? peakFWHM\n            : peakWidth\n                ? shape.widthToFWHM(peakWidth)\n                : this.peakWidthFct\n                    ? this.peakWidthFct(xPosition)\n                    : width !== undefined\n                        ? width\n                        : shape.fwhm;\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 ? 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        shape.fwhm = widthLeft;\n        for (let index = firstPoint; index < Math.max(middlePoint, 0); index++) {\n            this.data.y[index] +=\n                intensity * shape.fct(this.data.x[index] - xPosition);\n        }\n        // we calculate the right part of the gaussian\n        shape.fwhm = widthRight;\n        for (let index = Math.min(middlePoint, lastPoint); index <= lastPoint; index++) {\n            this.data.y[index] +=\n                intensity * 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     *\n     * @param percent - Noise's amplitude in percents of the spectrum max value. Default: 1.\n     */\n    addNoise(options) {\n        addNoise(this.data, 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, peakOptions, } = options;\n    const generator = new SpectrumGenerator(generatorOptions);\n    generator.addPeaks(peaks, peakOptions);\n    if (baseline)\n        generator.addBaseline(baseline);\n    if (noise) {\n        generator.addNoise(noise);\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","import { getShape2D } from 'ml-peak-shape-generator';\nimport { matrixMinMaxZ } from 'ml-spectra-processing';\nconst axis2D = ['x', 'y'];\nconst peakCoordinates = ['x', 'y', 'z'];\nconst convertWidthToFWHM = (shape, width) => {\n    const widthData = ensureXYNumber(width);\n    for (let key of axis2D) {\n        widthData[key] = shape.widthToFWHM(widthData[key]);\n    }\n    return widthData;\n};\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 peakWidth;\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;\n            peakWidth = 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 { shape: shapeOptions, width } = options;\n        if (peakShapeOptions) {\n            shapeOptions = shapeOptions\n                ? { ...shapeOptions, ...peakShapeOptions }\n                : peakShapeOptions;\n        }\n        const shape = shapeOptions\n            ? getShape2D(shapeOptions)\n            : Object.assign(Object.create(Object.getPrototypeOf(this.shape)), JSON.parse(JSON.stringify(this.shape)));\n        let { fwhm = peakFWHM !== undefined\n            ? peakFWHM\n            : peakWidth\n                ? convertWidthToFWHM(shape, peakWidth)\n                : width\n                    ? convertWidthToFWHM(shape, width)\n                    : this.peakWidthFct(xPosition, yPosition), } = options;\n        fwhm = ensureXYNumber(fwhm);\n        let factor = options.factor === undefined ? 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        shape.fwhm = fwhm;\n        for (let xIndex = firstPoint.x; xIndex < lastPoint.x; xIndex++) {\n            for (let yIndex = firstPoint.y; yIndex < lastPoint.y; yIndex++) {\n                const value = intensity *\n                    shape.fct(this.data.x[xIndex] - position.x, this.data.y[yIndex] - position.y);\n                if (value > 1e-6) {\n                    this.data.z[yIndex][xIndex] += value;\n                }\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 = matrixMinMaxZ(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    return typeof input !== 'object' ? { x: input, y: input } : { ...input };\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"],"names":["GAUSSIAN_EXP_FACTOR","Math","LN2","ROOT_PI_OVER_LN2","sqrt","PI","ROOT_THREE","ROOT_2LN2","ROOT_2LN2_MINUS_ONE","Gaussian","constructor","options","arguments","length","undefined","fwhm","sd","this","gaussianWidthToFWHM","fwhmToWidth","gaussianFwhmToWidth","widthToFWHM","width","fct","x","gaussianFct","getArea","height","calculateGaussianHeight","getGaussianArea","getFactor","area","getGaussianFactor","getData","shape","factor","min","ceil","pow","center","data","Float64Array","i","getGaussianData","calculateHeight","getParameters","exp","ln1MinusXSqrd","log","lnEtcBy2Plus2","firstSqrt","erfinv","Lorentzian","lorentzianFwhmToWidth","lorentzianWidthToFWHM","lorentzianFct","getLorentzianArea","getLorentzianFactor","getLorentzianData","calculateLorentzianHeight","_ref","Error","halfResidual","quantileFunction","p","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","sdObject","getShape1D","kind","getShape2D","toString","Object","prototype","isAnyArray","value","call","endsWith","xFindClosestIndex","array","target","sorted","low","high","middle","abs","index","diff","Number","POSITIVE_INFINITY","currentDiff","xMaxValue","minLength","TypeError","xCheck","fromIndex","toIndex","from","to","xGetFromToIndex","maxValue","matrixMinMaxZ","matrix","RangeError","firstLength","matrixCheck","nbRows","nbColumns","max","column","row","multiply_uint32","n","m","nlo","XSadd","seed","Date","now","state","Uint32Array","init","random","getFloat","bind","getUint32","nextState","isInteger","periodCertification","t","spare","hasSpare","generateGaussian","mean","standardDeviation","generator","val","u","v","s","addNoise","distribution","percent","range","noise","XSAdd","returnArray","createRandomArray","array1","array2","isConstant","constant","array3","xAdd","SpectrumGenerator","nbPoints","peakWidthFct","interval","maxPeakHeight","MIN_SAFE_INTEGER","shapeGenerator","assertNumber","name","assertInteger","reset","addPeaks","peaks","isArray","peak","addPeak","xPosition","intensity","peakFWHM","peakWidth","peakShapeOptions","shapeOptions","assign","create","getPrototypeOf","widthLeft","widthRight","firstValue","lastValue","firstPoint","floor","lastPoint","middlePoint","round","addBaseline","baselineFct","xs","ys","getSpectrum","copy","threshold","minPeakHeight","push","slice","spectrum","isFinite","axis2D","peakCoordinates","convertWidthToFWHM","widthData","key","Spectrum2DGenerator","calculeIntervals","z","createMatrix","nbPeaks","c","yPosition","some","e","position","JSON","parse","stringify","first","last","xIndex","yIndex","minMaxZ","minX","maxX","maxY","minY","minZ","maxZ","zMatrix","generatorOptions","baseline","peakOptions","addPeaksOptions"],"mappings":"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"}