{"version":3,"file":"spectrum-generator.esm.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/lorentzianDispersive/LorentzianDispersive.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/pseudoVoigt/PseudoVoigt.js","../node_modules/ml-peak-shape-generator/lib-esm/shapes/1d/generalizedLorentzian/GeneralizedLorentzian.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/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib/utils/createArray.js","../node_modules/ml-xsadd/lib-esm/XSadd.js","../node_modules/ml-spectra-processing/lib/utils/createRandomArray.js","../node_modules/ml-spectra-processing/lib/x/xMaxValue.js","../node_modules/ml-spectra-processing/lib/x/xCheck.js","../node_modules/ml-spectra-processing/lib/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib/matrix/matrixCreateEmpty.js","../node_modules/ml-spectra-processing/lib/matrix/matrixMinMaxZ.js","../node_modules/ml-spectra-processing/lib/matrix/matrixCheck.js","../lib/util/addNoise.js","../node_modules/ml-spectra-processing/lib/x/xAdd.js","../lib/SpectrumGenerator.js","../lib/util/addBaseline.js","../lib/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 { calculateLorentzianHeight, getLorentzianFactor, lorentzianFwhmToWidth, lorentzianWidthToFWHM, } from '../lorentzian/Lorentzian';\nexport class LorentzianDispersive {\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 lorentzianDispersiveFct(x, this.fwhm);\n    }\n    //eslint-disable-next-line\n    getArea(_height) {\n        return 0;\n    }\n    getFactor(area) {\n        return getLorentzianFactor(area);\n    }\n    getData(options = {}) {\n        return getLorentzianDispersiveData(this, options);\n    }\n    calculateHeight(area = 1) {\n        return calculateLorentzianHeight({ fwhm: this.fwhm, area });\n    }\n    getParameters() {\n        return ['fwhm'];\n    }\n}\nexport const lorentzianDispersiveFct = (x, fwhm) => {\n    return (2 * fwhm * x) / (4 * x ** 2 + fwhm ** 2);\n};\nexport const getLorentzianDispersiveData = (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] = lorentzianDispersiveFct(i - center, fwhm) * height;\n        data[length - 1 - i] = -data[i];\n    }\n    return data;\n};\n//# sourceMappingURL=LorentzianDispersive.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 { ROOT_THREE } from '../../../util/constants';\n/**\n * This shape is a linear combination of rational function (n|n+2), for n = 0 (lorentzian function) and n = 2\n * the parameter that combines those two functions is `gamma` and it is called the kurtosis parameter, it is an\n * implementation of generalized lorentzian shape published by Stanislav Sykora in the SMASH 2010. DOI:10.3247/SL3nmr10.006\n * @link http://www.ebyte.it/stan/Talk_ML_UserMeeting_SMASH_2010_GeneralizedLorentzian.html\n */\nexport class GeneralizedLorentzian {\n    constructor(options = {}) {\n        const { fwhm = 500, gamma = 0.5 } = options;\n        this.fwhm = fwhm;\n        this.gamma = gamma;\n    }\n    fwhmToWidth(fwhm = this.fwhm) {\n        return generalizedLorentzianFwhmToWidth(fwhm);\n    }\n    widthToFWHM(width) {\n        return generalizedLorentzianWidthToFWHM(width);\n    }\n    fct(x) {\n        return generalizedLorentzianFct(x, this.fwhm, this.gamma);\n    }\n    getArea(height = 1) {\n        return getGeneralizedLorentzianArea({\n            fwhm: this.fwhm,\n            height,\n            gamma: this.gamma,\n        });\n    }\n    getFactor(area) {\n        return getGeneralizedLorentzianFactor(area);\n    }\n    getData(options = {}) {\n        return getGeneralizedLorentzianData(this, options);\n    }\n    calculateHeight(area = 1) {\n        const { gamma, fwhm } = this;\n        return calculateGeneralizedLorentzianHeight({ fwhm, area, gamma });\n    }\n    getParameters() {\n        return ['fwhm', 'gamma'];\n    }\n}\nexport const calculateGeneralizedLorentzianHeight = ({ fwhm = 1, gamma = 1, area = 1, }) => {\n    return (area / fwhm / (3.14159 - 0.420894 * gamma)) * 2;\n};\n/**\n * expression of integral generated by Mathematica of the function\n */\nexport const getGeneralizedLorentzianArea = (options) => {\n    const { fwhm = 500, height = 1, gamma = 1 } = options;\n    return (height * fwhm * (3.14159 - 0.420894 * gamma)) / 2;\n};\nexport const generalizedLorentzianFct = (x, fwhm, gamma) => {\n    const u = ((2 * x) / fwhm) ** 2;\n    return (1 - gamma) / (1 + u) + (gamma * (1 + u / 2)) / (1 + u + u ** 2);\n};\nexport const generalizedLorentzianWidthToFWHM = (width) => {\n    return width * ROOT_THREE;\n};\nexport const generalizedLorentzianFwhmToWidth = (fwhm) => {\n    return fwhm / ROOT_THREE;\n};\nexport const getGeneralizedLorentzianFactor = (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 getGeneralizedLorentzianData = (shape = {}, options = {}) => {\n    let { fwhm = 500, gamma = 1 } = shape;\n    let { length, factor = getGeneralizedLorentzianFactor(), height = calculateGeneralizedLorentzianHeight({ fwhm, area: 1, gamma }), } = 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] = generalizedLorentzianFct(i - center, fwhm, gamma) * height;\n        data[length - 1 - i] = data[i];\n    }\n    return data;\n};\n//# sourceMappingURL=GeneralizedLorentzian.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 { GeneralizedLorentzian } from './generalizedLorentzian/GeneralizedLorentzian';\nimport { Lorentzian } from './lorentzian/Lorentzian';\nimport { LorentzianDispersive } from './lorentzianDispersive/LorentzianDispersive';\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        case 'lorentzianDispersive':\n            return new LorentzianDispersive(shape);\n        case 'generalizedLorentzian':\n            return new GeneralizedLorentzian(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","// eslint-disable-next-line @typescript-eslint/unbound-method\nconst toString = Object.prototype.toString;\n/**\n * Checks if an object is an instance of an Array (array or typed array, except those that contain bigint values).\n *\n * @param value - Object to check.\n * @returns True if the object is an array or a typed array.\n */\nexport function isAnyArray(value) {\n    const tag = toString.call(value);\n    return tag.endsWith('Array]') && !tag.includes('Big');\n}\n//# sourceMappingURL=index.js.map","/**\n * Returns the closest index of a `target`\n * @param array - array of numbers\n * @param target - target\n * @param options\n * @returns - closest index\n */\nexport function xFindClosestIndex(array, target, options = {}) {\n    const { sorted = true } = options;\n    if (sorted) {\n        let low = 0;\n        let high = array.length - 1;\n        let middle = 0;\n        while (high - low > 1) {\n            middle = low + ((high - low) >> 1);\n            if (array[middle] < target) {\n                low = middle;\n            }\n            else if (array[middle] > target) {\n                high = middle;\n            }\n            else {\n                return middle;\n            }\n        }\n        if (low < array.length - 1) {\n            if (Math.abs(target - array[low]) < Math.abs(array[low + 1] - target)) {\n                return low;\n            }\n            else {\n                return low + 1;\n            }\n        }\n        else {\n            return low;\n        }\n    }\n    else {\n        let index = 0;\n        let diff = Number.POSITIVE_INFINITY;\n        for (let i = 0; i < array.length; i++) {\n            const currentDiff = Math.abs(array[i] - target);\n            if (currentDiff < diff) {\n                diff = currentDiff;\n                index = i;\n            }\n        }\n        return index;\n    }\n}\n//# sourceMappingURL=xFindClosestIndex.js.map","export function createNumberArray(ArrayConstructor, length) {\n    if (ArrayConstructor === Array) {\n        return new ArrayConstructor(length).fill(0);\n    }\n    else {\n        return new ArrayConstructor(length);\n    }\n}\nexport function createDoubleArray(ArrayConstructor, length) {\n    if (ArrayConstructor === Array) {\n        return new ArrayConstructor(length).fill(0);\n    }\n    else {\n        return new ArrayConstructor(length);\n    }\n}\n//# sourceMappingURL=createArray.js.map","const LOOP = 8;\nconst FLOAT_MUL = 1 / 16777216;\nconst sh1 = 15;\nconst sh2 = 18;\nconst sh3 = 11;\nfunction multiplyUint32(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 class XSadd {\n    random;\n    state;\n    /**\n     * create an instance of XSadd with the specified seed\n     * @param [seed=Date.now()]\n     */\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                    multiplyUint32(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//# sourceMappingURL=XSadd.js.map","import { XSadd } from 'ml-xsadd';\n/**\n * Create a random array of numbers of a specific length.\n * @param options\n * @returns - array of random floats normally distributed\n */\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    const returnArray = new Float64Array(length);\n    switch (distribution) {\n        case 'normal': {\n            const gaussianGenerator = new GaussianGenerator(mean, standardDeviation, generator);\n            for (let i = 0; i < length; i++) {\n                returnArray[i] = gaussianGenerator.generateGaussian();\n            }\n            break;\n        }\n        case 'uniform': {\n            for (let i = 0; i < length; i++) {\n                returnArray[i] = (generator.random() - 0.5) * range + mean;\n            }\n            break;\n        }\n        default: {\n            throw new Error(`unknown distribution: ${String(distribution)}`);\n        }\n    }\n    return returnArray;\n}\nclass GaussianGenerator {\n    #spare = 0;\n    #hasSpare = false;\n    #mean;\n    #standardDeviation;\n    #generator;\n    constructor(mean, standardDeviation, generator) {\n        this.#mean = mean;\n        this.#standardDeviation = standardDeviation;\n        this.#generator = generator;\n    }\n    generateGaussian() {\n        let val, u, v, s;\n        if (this.#hasSpare) {\n            this.#hasSpare = false;\n            val = this.#spare * this.#standardDeviation + this.#mean;\n        }\n        else {\n            do {\n                u = this.#generator.random() * 2 - 1;\n                v = this.#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            this.#spare = v * s;\n            this.#hasSpare = true;\n            val = this.#mean + this.#standardDeviation * u * s;\n        }\n        return val;\n    }\n}\n//# sourceMappingURL=createRandomArray.js.map","import { xCheck } from \"./xCheck.js\";\nimport { xGetFromToIndex } from \"./xGetFromToIndex.js\";\n/**\n * Computes the maximal value of an array of values\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 the input is a non-empty array of numbers.\n * Only checks the first element.\n * @param input - Array to check.\n * @param options - Additional checks.\n */\nexport function xCheck(input, options = {}) {\n    const { minLength } = options;\n    if (!isAnyArray(input)) {\n        throw new TypeError('input must be an array');\n    }\n    if (input.length === 0) {\n        throw new TypeError('input must not be empty');\n    }\n    if (typeof input[0] !== 'number') {\n        throw new TypeError('input must contain numbers');\n    }\n    if (minLength && input.length < minLength) {\n        throw new Error(`input must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xCheck.js.map","import { xFindClosestIndex } from \"./xFindClosestIndex.js\";\n/**\n * Returns an object with {fromIndex, toIndex} for a specific from / to\n * @param x - array of numbers\n * @param options - Options\n */\nexport function xGetFromToIndex(x, options = {}) {\n    let { fromIndex, toIndex } = options;\n    const { from, to } = options;\n    if (fromIndex === undefined) {\n        if (from !== undefined) {\n            fromIndex = xFindClosestIndex(x, from);\n        }\n        else {\n            fromIndex = 0;\n        }\n    }\n    if (toIndex === undefined) {\n        if (to !== undefined) {\n            toIndex = xFindClosestIndex(x, to);\n        }\n        else {\n            toIndex = x.length - 1;\n        }\n    }\n    if (fromIndex < 0)\n        fromIndex = 0;\n    if (toIndex < 0)\n        toIndex = 0;\n    if (fromIndex >= x.length)\n        fromIndex = x.length - 1;\n    if (toIndex >= x.length)\n        toIndex = x.length - 1;\n    if (fromIndex > toIndex)\n        [fromIndex, toIndex] = [toIndex, fromIndex];\n    return { fromIndex, toIndex };\n}\n//# sourceMappingURL=xGetFromToIndex.js.map","import { createNumberArray } from \"../utils/index.js\";\n/**\n * Create a new matrix based on the size of the current one or by using specific dimensions.\n * @param options\n */\nexport function matrixCreateEmpty(options) {\n    const { matrix, nbRows = matrix?.length || 1, nbColumns = matrix?.[0].length || 1, ArrayConstructor = Float64Array, } = options;\n    const newMatrix = [];\n    for (let row = 0; row < nbRows; row++) {\n        newMatrix.push(createNumberArray(ArrayConstructor, nbColumns));\n    }\n    return newMatrix;\n}\n//# sourceMappingURL=matrixCreateEmpty.js.map","import { matrixCheck } from \"./matrixCheck.js\";\n/**\n * Get min and max Z.\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 must 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 must has the same length');\n        }\n    }\n}\n//# sourceMappingURL=matrixCheck.js.map","import { xMaxValue, xAdd, createRandomArray } from 'ml-spectra-processing';\n/**\n * Adds noise to the spectrum data.\n * @param data - The spectrum data to modify.\n * @param options - Configuration for noise generation.\n * @returns The modified spectrum data.\n */\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 * @param array1 - the first array\n * @param array2 - the second array or number\n * @returns the result of the addition\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('size of array1 and array2 must be identical');\n        }\n    }\n    else {\n        isConstant = true;\n        constant = array2;\n    }\n    const array3 = new Float64Array(array1.length);\n    if (isConstant) {\n        for (let i = 0; i < array1.length; i++) {\n            array3[i] = array1[i] + constant;\n        }\n    }\n    else {\n        for (let i = 0; i < array1.length; i++) {\n            array3[i] = array1[i] + array2[i];\n        }\n    }\n    return array3;\n}\n//# sourceMappingURL=xAdd.js.map","import { getShape1D } from 'ml-peak-shape-generator';\nimport addBaseline from \"./util/addBaseline.js\";\nimport addNoise from \"./util/addNoise.js\";\nexport class SpectrumGenerator {\n    from;\n    to;\n    nbPoints;\n    interval;\n    peakWidthFct;\n    maxPeakHeight;\n    shape;\n    data;\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        const 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     * @param options - Options for adding peaks.\n     * @returns The generator instance.\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        return this;\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 - The peak to add, defined as array or object.\n     * @param options - Options for adding the peak.\n     * @returns The generator instance.\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        const { width } = options;\n        let { 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        const 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        return this;\n    }\n    /**\n     * Add a baseline to the spectrum.\n     * @param baselineFct - Mathematical function producing the baseline you want.\n     * @returns The generator instance.\n     */\n    addBaseline(baselineFct) {\n        addBaseline(this.data, baselineFct);\n        return this;\n    }\n    /**\n     * Add noise to the spectrum.\n     * @param options - Configuration for noise generation.\n     * @returns The generator instance.\n     */\n    addNoise(options) {\n        addNoise(this.data, options);\n        return this;\n    }\n    /**\n     * Get the generated spectrum.\n     * @param options - Options for getting the spectrum.\n     * @returns The generated spectrum data.\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            const minPeakHeight = this.maxPeakHeight * threshold;\n            const x = [];\n            const 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: Float64Array.from(x), y: Float64Array.from(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     * @returns The generator instance.\n     */\n    reset() {\n        if (this.nbPoints === 1) {\n            this.data.x[0] = (this.from + this.to) / 2;\n        }\n        else {\n            for (let i = 0; i < this.nbPoints; i++) {\n                this.data.x[i] = this.from + i * this.interval;\n            }\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 - Configuration for spectrum generation.\n * @returns The generated spectrum data.\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","/**\n * Adds a baseline to the spectrum data.\n * @param data - The spectrum data to modify.\n * @param baselineFct - Function that generates the baseline value for a given x.\n * @returns The modified spectrum data.\n */\nexport default function addBaseline(data, baselineFct) {\n    if (!baselineFct)\n        return data;\n    const xs = data.x;\n    const 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 { matrixCreateEmpty, matrixMinMaxZ } from 'ml-spectra-processing';\nconst axis2D = ['x', 'y'];\nconst peakCoordinates = ['x', 'y', 'z'];\n/**\n * Converts a width value to full width at half maximum (FWHM).\n * @param shape - The 2D shape to use for conversion.\n * @param width - The width value to convert.\n * @returns The converted FWHM value as an XYNumber object.\n */\nconst convertWidthToFWHM = (shape, width) => {\n    const widthData = ensureXYNumber(width);\n    for (const key of axis2D) {\n        widthData[key] = shape.widthToFWHM(widthData[key]);\n    }\n    return widthData;\n};\nexport class Spectrum2DGenerator {\n    from;\n    to;\n    nbPoints;\n    interval;\n    data;\n    maxPeakHeight;\n    shape;\n    peakWidthFct;\n    constructor(options = {}) {\n        const { peakWidthFct = () => 5, shape = {\n            kind: 'gaussian',\n        }, } = options;\n        let { from = 0, to = 100, nbPoints = 1001 } = 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        const shapeGenerator = getShape2D(shape);\n        this.shape = shapeGenerator;\n        this.data = {\n            x: new Float64Array(nbPoints.x),\n            y: new Float64Array(nbPoints.y),\n            z: matrixCreateEmpty({\n                nbRows: this.nbPoints.y,\n                nbColumns: this.nbPoints.x,\n            }),\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    /**\n     * Adds multiple peaks to the 2D spectrum.\n     * @param peaks - Array of peaks or peak series to add.\n     * @param options - Options for adding peaks.\n     * @returns The generator instance.\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            if (!Array.isArray(peaks.x) ||\n                !Array.isArray(peaks.y) ||\n                !Array.isArray(peaks.z)) {\n                throw new TypeError('x, y, z must all be arrays');\n            }\n            const nbPeaks = peaks.x.length;\n            if (peaks.y.length !== nbPeaks || peaks.z.length !== nbPeaks) {\n                throw new Error('x, y, z should have the same length');\n            }\n            for (let i = 0; i < nbPeaks; i++) {\n                this.addPeak([peaks.x[i], peaks.y[i], peaks.z[i]], options);\n            }\n        }\n        return this;\n    }\n    /**\n     * Adds a single peak to the 2D spectrum.\n     * @param peak - Peak to add, can be array or object format.\n     * @param options - Options for adding the peak.\n     * @returns The generator instance.\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        const { width } = options;\n        let { shape: shapeOptions } = 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)), structuredClone(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 (Math.abs(value) > 1e-6) {\n                    this.data.z[yIndex][xIndex] += value;\n                }\n            }\n        }\n        return this;\n    }\n    /**\n     * Gets the generated 2D spectrum data.\n     * @param options - Options for getting the spectrum.\n     * @returns The spectrum data object.\n     */\n    getSpectrum(options = {}) {\n        if (typeof options === 'boolean') {\n            options = { copy: options };\n        }\n        const { copy = true } = options;\n        const 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    /**\n     * Resets the generator to initial state.\n     * @returns The generator instance.\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 (const row of spectrum.z) {\n            for (let j = 0; j < row.length; j++) {\n                row[j] = 0;\n            }\n        }\n        return this;\n    }\n}\n/**\n * Generates a 2D spectrum with the given peaks.\n * @param peaks - Peaks to include in the spectrum.\n * @param options - Options for spectrum generation.\n * @returns The generated spectrum data.\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}\n/**\n * Ensures the input is an XYNumber object.\n * @param input - Number or XYNumber to process.\n * @returns An XYNumber object.\n */\nfunction ensureXYNumber(input) {\n    return typeof input !== 'object' ? { x: input, y: input } : { ...input };\n}\n/**\n * Calculates the intervals between points for both x and y axes.\n * @param from - Starting point coordinates.\n * @param to - Ending point coordinates.\n * @param nbPoints - Number of points in each dimension.\n * @returns The calculated intervals as an XYNumber object.\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}\n/**\n * Validates if a value is an integer.\n * @param value - Number to validate.\n * @param name - Name of the parameter for error message.\n * @throws {TypeError} If value is not an integer.\n */\nfunction assertInteger(value, name) {\n    if (!Number.isInteger(value)) {\n        throw new TypeError(`${name} option must be an integer`);\n    }\n}\n/**\n * Validates if a value is a finite number.\n * @param value - Number to validate.\n * @param name - Name of the parameter for error message.\n * @throws {TypeError} If value is not a finite number.\n */\nfunction assertNumber(value, name) {\n    if (!Number.isFinite(value)) {\n        throw new TypeError(`${name} option must be a number`);\n    }\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","fwhm","sd","this","gaussianWidthToFWHM","fwhmToWidth","gaussianFwhmToWidth","widthToFWHM","width","fct","x","gaussianFct","getArea","height","calculateGaussianHeight","getGaussianArea","getFactor","area","getGaussianFactor","getData","shape","length","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","Error","halfResidual","quantileFunction","p","tan","LorentzianDispersive","lorentzianDispersiveFct","_height","getLorentzianDispersiveData","PseudoVoigt","mu","pseudoVoigtFwhmToWidth","pseudoVoigtWidthToFWHM","pseudoVoigtFct","getPseudoVoigtArea","getPseudoVoigtFactor","calculatePseudoVoigtHeight","getPseudoVoigtData","GeneralizedLorentzian","gamma","generalizedLorentzianFwhmToWidth","generalizedLorentzianWidthToFWHM","generalizedLorentzianFct","getGeneralizedLorentzianArea","getGeneralizedLorentzianFactor","getGeneralizedLorentzianData","calculateGeneralizedLorentzianHeight","u","Gaussian2D","ensureFWHM2D","fwhmX","fwhmY","y","gaussian2DFct","getGaussian2DData","volume","getVolume","calculateGaussian2DHeight","getGaussian2DVolume","ensureXYNumber","xFWHM","yFWHM","axis","xCenter","yCenter","Array","j","input","undefined","sdObject","getShape1D","kind","getShape2D","toString","Object","prototype","isAnyArray","value","tag","call","endsWith","includes","xFindClosestIndex","array","target","sorted","low","high","middle","abs","index","diff","Number","POSITIVE_INFINITY","currentDiff","createNumberArray","ArrayConstructor","fill","FLOAT_MUL","multiplyUint32","n","m","nlo","XSadd","random","state","seed","Date","now","Uint32Array","init","getFloat","bind","getUint32","nextState","isInteger","TypeError","periodCertification","t","GaussianGenerator","spare","hasSpare","mean","standardDeviation","generator","generateGaussian","val","v","s","xMaxValue","minLength","xCheck","fromIndex","toIndex","from","to","xGetFromToIndex","maxValue","matrixCreateEmpty","matrix","nbRows","nbColumns","newMatrix","row","push","matrixMinMaxZ","RangeError","firstLength","matrixCheck","max","column","addNoise","distribution","percent","range","noise","returnArray","gaussianGenerator","String","createRandomArray","array1","array2","isConstant","constant","array3","xAdd","SpectrumGenerator","nbPoints","interval","peakWidthFct","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","slice","isFinite","generateSpectrum","generatorOptions","baseline","peakOptions","axis2D","peakCoordinates","convertWidthToFWHM","widthData","key","Spectrum2DGenerator","calculeIntervals","z","nbPeaks","some","e","yPosition","position","structuredClone","first","last","xIndex","yIndex","minMaxZ","minX","maxX","maxY","minY","minZ","maxZ","spectrum","generateSpectrum2D","addPeaksOptions"],"mappings":";AAAO,MAAMA,GAAsB,EAAKC,KAAKC,IAChCC,EAAmBF,KAAKG,KAAKH,KAAKI,GAAKJ,KAAKC,KAC5CI,EAAaL,KAAKG,KAAK,GACvBG,EAAYN,KAAKG,KAAK,EAAIH,KAAKC,KAC/BM,EAAsBP,KAAKG,KAAK,EAAIH,KAAKC,KAAO,ECiDvD,MAAOO,EAOXC,WAAAA,CAAmBC,EAAgC,IACjD,MAAMC,KAAEA,EAAO,IAAGC,GAAEA,GAAOF,EAE3BG,KAAKF,KAAOC,EAAKE,EAAoB,EAAIF,GAAMD,CACjD,CAEOI,WAAAA,CAAYJ,EAAOE,KAAKF,MAC7B,OAAOK,EAAoBL,EAC7B,CAEOM,WAAAA,CAAYC,GACjB,OAAOJ,EAAoBI,EAC7B,CAEOC,GAAAA,CAAIC,GACT,OAAOC,EAAYD,EAAGP,KAAKF,KAC7B,CAEOW,OAAAA,CAAQC,EAASC,EAAwB,CAAEb,KAAME,KAAKF,QAC3D,OAiDE,SAA0BD,GAC9B,IAAIC,KAAEA,EAAO,IAAGC,GAAEA,EAAEW,OAAEA,EAAS,GAAMb,EAEjCE,IAAID,EAAOG,EAAoB,EAAIF,IAEvC,OAAQW,EAASrB,EAAmBS,EAAQ,CAC9C,CAvDWc,CAAgB,CAAEd,KAAME,KAAKF,KAAMY,UAC5C,CAEOG,SAAAA,CAAUC,GACf,OAAOC,EAAkBD,EAC3B,CAEOE,OAAAA,CAAQnB,EAA4B,IACzC,OAqDE,SACJoB,EAA8B,GAC9BpB,EAA4B,CAAA,GAE5B,IAAIC,KAAEA,EAAO,IAAGC,GAAEA,GAAOkB,EACrBlB,IAAID,EAAOG,EAAoB,EAAIF,IAEvC,IAAImB,OACFA,EAAMC,OACNA,EAASJ,IAAmBL,OAC5BA,EAASC,EAAwB,CAAEb,UACjCD,EAECqB,IACHA,EAAS/B,KAAKiC,IAAIjC,KAAKkC,KAAKvB,EAAOqB,GAAShC,KAAKmC,IAAI,EAAG,IAAM,GAC1DJ,EAAS,GAAM,GAAGA,KAGxB,MAAMK,GAAUL,EAAS,GAAK,EACxBM,EAAO,IAAIC,aAAaP,GAC9B,IAAK,IAAIQ,EAAI,EAAGA,GAAKH,EAAQG,IAC3BF,EAAKE,GAAKlB,EAAYkB,EAAIH,EAAQzB,GAAQY,EAC1Cc,EAAKN,EAAS,EAAIQ,GAAKF,EAAKE,GAG9B,OAAOF,CACT,CA/EWG,CAAgB3B,KAAMH,EAC/B,CAEO+B,eAAAA,CAAgBd,EAAO,GAC5B,OAAOH,EAAwB,CAAEb,KAAME,KAAKF,KAAMgB,QACpD,CAEOe,aAAAA,GACL,MAAO,CAAC,OACV,EAGI,SAAUlB,EACdd,GAEA,IAAIC,KAAEA,EAAO,IAAGgB,KAAEA,EAAO,EAACf,GAAEA,GAAOF,EAInC,OAFIE,IAAID,EAAOG,EAAoB,EAAIF,IAE/B,EAAIe,EAAQzB,EAAmBS,CACzC,CASM,SAAUU,EAAYD,EAAWT,GACrC,OAAOX,KAAK2C,IAAI5C,EAAsBC,KAAKmC,IAAIf,EAAIT,EAAM,GAC3D,CAEM,SAAUG,EAAoBI,GAClC,OAAOA,EAAQZ,CACjB,CAEM,SAAUU,EAAoBL,GAClC,OAAOA,EAAOL,CAChB,CAUM,SAAUsB,EAAkBD,EAAO,OACvC,OAAO3B,KAAKG,KAAK,GCpIL,SAAiBiB,GAE7B,GAAU,IAANA,EAAS,OAAO,EACpB,IAAIwB,EAAgB5C,KAAK6C,IAAI,EAAIzB,EAAIA,GACjC0B,EAAgBF,EAAgB,EAAI,GAHhC,KAGqC5C,KAAKI,IAC9C2C,EAAY/C,KAAKG,KAAK2C,GAAiB,EAAIF,EAJvC,MAMR,OADiB5C,KAAKG,KAAK4C,EAAYD,IAClB1B,EAAI,EAAI,GAAI,EACnC,CD4HwB4B,CAAOrB,EAC/B,CEjHM,MAAOsB,EAOXxC,WAAAA,CAAmBC,EAAkC,IACnD,MAAMC,KAAEA,EAAO,KAAQD,EAEvBG,KAAKF,KAAOA,CACd,CAEOI,WAAAA,CAAYJ,EAAOE,KAAKF,MAC7B,OAAOuC,EAAsBvC,EAC/B,CAEOM,WAAAA,CAAYC,GACjB,OAAOiC,EAAsBjC,EAC/B,CAEOC,GAAAA,CAAIC,GACT,OAAOgC,EAAchC,EAAGP,KAAKF,KAC/B,CAEOW,OAAAA,CAAQC,EAAS,GACtB,OAAO8B,EAAkB,CAAE1C,KAAME,KAAKF,KAAMY,UAC9C,CAEOG,SAAAA,CAAUC,GACf,OAAO2B,EAAoB3B,EAC7B,CAEOE,OAAAA,CAAQnB,EAA4B,IACzC,OAAO6C,EAAkB1C,KAAMH,EACjC,CAEO+B,eAAAA,CAAgBd,EAAO,GAC5B,OAAO6B,EAA0B,CAAE7C,KAAME,KAAKF,KAAMgB,QACtD,CAEOe,aAAAA,GACL,MAAO,CAAC,OACV,EAGK,MAAMc,EAA4BA,EAAG7C,OAAO,EAAGgB,OAAO,KACnD,EAAIA,EAAQ3B,KAAKI,GAAKO,EAGnB0C,EAAqB3C,IAChC,MAAMC,KAAEA,EAAO,IAAGY,OAAEA,EAAS,GAAMb,EACnC,OAAQa,EAASvB,KAAKI,GAAKO,EAAQ,GAGxByC,EAAgBA,CAAChC,EAAWT,IAChCA,GAAQ,GAAK,EAAIS,GAAK,EAAIT,GAAQ,GAG9BwC,EAAyBjC,GAC7BA,EAAQb,EAGJ6C,EAAyBvC,GAC7BA,EAAON,EAGHiD,EAAsBA,CAAC3B,EAAO,SACzC,GAAIA,GAAQ,EACV,MAAM,IAAI8B,MAAM,0BAElB,MAAMC,EAA4B,IAAZ,EAAI/B,GACpBgC,EAAoBC,GAAc5D,KAAK6D,IAAI7D,KAAKI,IAAMwD,EAAI,KAChE,OACGD,EAAiB,EAAID,GAAgBC,EAAiBD,IAAiB,GAI/DH,EAAoBA,CAC/BzB,EAAgC,GAChCpB,EAA4B,CAAA,KAE5B,IAAIC,KAAEA,EAAO,KAAQmB,GACjBC,OACFA,EAAMC,OACNA,EAASsB,IAAqB/B,OAC9BA,EAASiC,EAA0B,CAAE7C,OAAMgB,KAAM,KAC/CjB,EAECqB,IACHA,EAAS/B,KAAKiC,IAAIjC,KAAKkC,KAAKvB,EAAOqB,GAAShC,KAAKmC,IAAI,EAAG,IAAM,GAC1DJ,EAAS,GAAM,GAAGA,KAGxB,MAAMK,GAAUL,EAAS,GAAK,EACxBM,EAAO,IAAIC,aAAaP,GAC9B,IAAK,IAAIQ,EAAI,EAAGA,GAAKH,EAAQG,IAC3BF,EAAKE,GAAKa,EAAcb,EAAIH,EAAQzB,GAAQY,EAC5Cc,EAAKN,EAAS,EAAIQ,GAAKF,EAAKE,GAG9B,OAAOF,GCpHH,MAAOyB,EAOXrD,WAAAA,CAAmBC,EAAkC,IACnD,MAAMC,KAAEA,EAAO,KAAQD,EAEvBG,KAAKF,KAAOA,CACd,CAEOI,WAAAA,CAAYJ,EAAOE,KAAKF,MAC7B,OAAOuC,EAAsBvC,EAC/B,CAEOM,WAAAA,CAAYC,GACjB,OAAOiC,EAAsBjC,EAC/B,CAEOC,GAAAA,CAAIC,GACT,OAAO2C,EAAwB3C,EAAGP,KAAKF,KACzC,CAGOW,OAAAA,CAAQ0C,GACb,OAAO,CACT,CAEOtC,SAAAA,CAAUC,GACf,OAAO2B,EAAoB3B,EAC7B,CAEOE,OAAAA,CAAQnB,EAA4B,IACzC,OAAOuD,EAA4BpD,KAAMH,EAC3C,CAEO+B,eAAAA,CAAgBd,EAAO,GAC5B,OAAO6B,EAA0B,CAAE7C,KAAME,KAAKF,KAAMgB,QACtD,CAEOe,aAAAA,GACL,MAAO,CAAC,OACV,EAGK,MAAMqB,EAA0BA,CAAC3C,EAAWT,IACzC,EAAIA,EAAOS,GAAM,EAAIA,GAAK,EAAIT,GAAQ,GAGnCsD,EAA8BA,CACzCnC,EAAgC,GAChCpB,EAA4B,CAAA,KAE5B,IAAIC,KAAEA,EAAO,KAAQmB,GACjBC,OACFA,EAAMC,OACNA,EAASsB,IAAqB/B,OAC9BA,EAASiC,EAA0B,CAAE7C,OAAMgB,KAAM,KAC/CjB,EAECqB,IACHA,EAAS/B,KAAKiC,IAAIjC,KAAKkC,KAAKvB,EAAOqB,GAAShC,KAAKmC,IAAI,EAAG,IAAM,GAC1DJ,EAAS,GAAM,GAAGA,KAGxB,MAAMK,GAAUL,EAAS,GAAK,EACxBM,EAAO,IAAIC,aAAaP,GAC9B,IAAK,IAAIQ,EAAI,EAAGA,GAAKH,EAAQG,IAC3BF,EAAKE,GAAKwB,EAAwBxB,EAAIH,EAAQzB,GAAQY,EACtDc,EAAKN,EAAS,EAAIQ,IAAMF,EAAKE,GAG/B,OAAOF,GC5BH,MAAO6B,EAQXzD,WAAAA,CAAmBC,EAAmC,IACpD,MAAMC,KAAEA,EAAO,IAAGwD,GAAEA,EAAK,IAAQzD,EAEjCG,KAAKsD,GAAKA,EACVtD,KAAKF,KAAOA,CACd,CAEOI,WAAAA,CAAYJ,EAAOE,KAAKF,KAAMwD,EAAKtD,KAAKsD,IAC7C,OAAOC,EAAuBzD,EAAMwD,EACtC,CAEOlD,WAAAA,CAAYC,EAAeiD,EAAatD,KAAKsD,IAClD,OAAOE,EAAuBnD,EAAOiD,EACvC,CAEOhD,GAAAA,CAAIC,GACT,OAAOkD,EAAelD,EAAGP,KAAKF,KAAME,KAAKsD,GAC3C,CAEO7C,OAAAA,CAAQC,EAAS,GACtB,OAAOgD,EAAmB,CAAE5D,KAAME,KAAKF,KAAMY,SAAQ4C,GAAItD,KAAKsD,IAChE,CAEOzC,SAAAA,CAAUC,GACf,OAAO6C,EAAqB7C,EAC9B,CAEOE,OAAAA,CAAQnB,EAA4B,IACzC,MAAMqB,OACJA,EAAMC,OACNA,EAAMT,OACNA,EAASkD,EAA2B,CAClC9D,KAAME,KAAKF,KACXwD,GAAItD,KAAKsD,GACTxC,KAAM,KAENjB,EACJ,OAAOgE,EAAmB7D,KAAM,CAAEmB,SAAQD,SAAQR,UACpD,CAEOkB,eAAAA,CAAgBd,EAAO,GAC5B,OAAO8C,EAA2B,CAAE9D,KAAME,KAAKF,KAAMwD,GAAItD,KAAKsD,GAAIxC,QACpE,CAEOe,aAAAA,GACL,MAAO,CAAC,OAAQ,KAClB,EAGK,MAAM+B,EAA6BA,CACxC/D,EAA8C,MAE9C,IAAIC,KAAEA,EAAO,EAACwD,GAAEA,EAAK,GAAGxC,KAAEA,EAAO,GAAMjB,EACvC,OAAQ,EAAIiB,GAAShB,GAAQwD,EAAKjE,GAAoB,EAAIiE,GAAMnE,KAAKI,MAG1DkE,EAAiBA,CAAClD,EAAWT,EAAcwD,KAC9C,EAAIA,GAAMf,EAAchC,EAAGT,GAAQwD,EAAK9C,EAAYD,EAAGT,GAGpD0D,EAAyBA,CAACnD,EAAeiD,EAAK,KAClDjD,GAASiD,EAAK5D,EAAsB,GAGhC6D,EAAyBA,CAACzD,EAAcwD,EAAK,KACjDxD,GAAQwD,EAAK5D,EAAsB,GAG/BgE,EAAsB7D,IACjC,MAAMC,KAAEA,EAAO,IAAGY,OAAEA,EAAS,EAAC4C,GAAEA,EAAK,IAAQzD,EAC7C,OAAQC,EAAOY,GAAU4C,EAAKjE,GAAoB,EAAIiE,GAAMnE,KAAKI,IAAO,GAG7DoE,EAAuBA,CAAC7C,EAAO,MAAQwC,EAAK,KAChDA,EAAK,EAAIb,EAAoB3B,GAAQC,EAAkBD,GAGnD+C,EAAqBA,CAChC5C,EAAiC,GACjCpB,EAA4B,CAAA,KAE5B,IAAIC,KAAEA,EAAO,IAAGwD,GAAEA,EAAK,IAAQrC,GAC3BC,OACFA,EAAMC,OACNA,EAASwC,EAAqB,KAAOL,GAAG5C,OACxCA,EAASkD,EAA2B,CAAE9D,OAAMwD,KAAIxC,KAAM,KACpDjB,EAECa,IACHA,EACE,GACE4C,EAAKnE,KAAKG,MAAMJ,EAAsBC,KAAKI,IAAOO,GAChD,EAAIwD,GAAMxD,EAAOX,KAAKI,GAAM,IAG/B2B,IACHA,EAAS/B,KAAKiC,IAAIjC,KAAKkC,KAAKvB,EAAOqB,GAAShC,KAAKmC,IAAI,EAAG,IAAM,GAC1DJ,EAAS,GAAM,GAAGA,KAGxB,MAAMK,GAAUL,EAAS,GAAK,EACxBM,EAAO,IAAIC,aAAaP,GAC9B,IAAK,IAAIQ,EAAI,EAAGA,GAAKH,EAAQG,IAC3BF,EAAKE,GAAK+B,EAAe/B,EAAIH,EAAQzB,EAAMwD,GAAM5C,EACjDc,EAAKN,EAAS,EAAIQ,GAAKF,EAAKE,GAG9B,OAAOF,GCrIH,MAAOsC,EAYXlE,WAAAA,CAAmBC,EAA6C,IAC9D,MAAMC,KAAEA,EAAO,IAAGiE,MAAEA,EAAQ,IAAQlE,EAEpCG,KAAKF,KAAOA,EACZE,KAAK+D,MAAQA,CACf,CAEO7D,WAAAA,CAAYJ,EAAOE,KAAKF,MAC7B,OAAOkE,EAAiClE,EAC1C,CAEOM,WAAAA,CAAYC,GACjB,OAAO4D,EAAiC5D,EAC1C,CAEOC,GAAAA,CAAIC,GACT,OAAO2D,EAAyB3D,EAAGP,KAAKF,KAAME,KAAK+D,MACrD,CAEOtD,OAAAA,CAAQC,EAAS,GACtB,OAAOyD,EAA6B,CAClCrE,KAAME,KAAKF,KACXY,SACAqD,MAAO/D,KAAK+D,OAEhB,CAEOlD,SAAAA,CAAUC,GACf,OAAOsD,EAA+BtD,EACxC,CAEOE,OAAAA,CAAQnB,EAA4B,IACzC,OAAOwE,EAA6BrE,KAAMH,EAC5C,CAEO+B,eAAAA,CAAgBd,EAAO,GAC5B,MAAMiD,MAAEA,EAAKjE,KAAEA,GAASE,KACxB,OAAOsE,EAAqC,CAAExE,OAAMgB,OAAMiD,SAC5D,CAEOlC,aAAAA,GACL,MAAO,CAAC,OAAQ,QAClB,EAGK,MAAMyC,EAAuCA,EAClDxE,OAAO,EACPiE,QAAQ,EACRjD,OAAO,KAECA,EAAOhB,GAAQ,QAAU,QAAWiE,GAAU,EAM3CI,EACXtE,IAEA,MAAMC,KAAEA,EAAO,IAAGY,OAAEA,EAAS,EAACqD,MAAEA,EAAQ,GAAMlE,EAC9C,OAAQa,EAASZ,GAAQ,QAAU,QAAWiE,GAAU,GAG7CG,EAA2BA,CACtC3D,EACAT,EACAiE,KAEA,MAAMQ,GAAM,EAAIhE,EAAKT,IAAS,EAC9B,OAAQ,EAAIiE,IAAU,EAAIQ,GAAMR,GAAS,EAAIQ,EAAI,IAAO,EAAIA,EAAIA,GAAK,IAG1DN,EAAoC5D,GACxCA,EAAQb,EAGJwE,EAAoClE,GACxCA,EAAON,EAGH4E,EAAiCA,CAACtD,EAAO,SACpD,GAAIA,GAAQ,EACV,MAAM,IAAI8B,MAAM,0BAElB,MAAMC,EAA4B,IAAZ,EAAI/B,GACpBgC,EAAoBC,GAAc5D,KAAK6D,IAAI7D,KAAKI,IAAMwD,EAAI,KAChE,OACGD,EAAiB,EAAID,GAAgBC,EAAiBD,IAAiB,GAQ/DwB,EAA+BA,CAC1CpD,EAA2C,GAC3CpB,EAAwC,CAAA,KAExC,IAAIC,KAAEA,EAAO,IAAGiE,MAAEA,EAAQ,GAAM9C,GAC5BC,OACFA,EAAMC,OACNA,EAASiD,IAAgC1D,OACzCA,EAAS4D,EAAqC,CAAExE,OAAMgB,KAAM,EAAGiD,WAC7DlE,EAECqB,IACHA,EAAS/B,KAAKiC,IAAIjC,KAAKkC,KAAKvB,EAAOqB,GAAShC,KAAKmC,IAAI,EAAG,IAAM,GAC1DJ,EAAS,GAAM,GAAGA,KAGxB,MAAMK,GAAUL,EAAS,GAAK,EACxBM,EAAO,IAAIC,aAAaP,GAC9B,IAAK,IAAIQ,EAAI,EAAGA,GAAKH,EAAQG,IAC3BF,EAAKE,GAAKwC,EAAyBxC,EAAIH,EAAQzB,EAAMiE,GAASrD,EAC9Dc,EAAKN,EAAS,EAAIQ,GAAKF,EAAKE,GAG9B,OAAOF,GCzGH,MAAOgD,EAIX5E,WAAAA,CAAmBC,EAAkC,IACnD,IAAIC,KAAEA,EAAO,GAAEC,GAAEA,GAAOF,EAExBC,EAAO2E,EAAa3E,EAAMC,GAE1BC,KAAK0E,MAAQ5E,EAAKS,EAClBP,KAAK2E,MAAQ7E,EAAK8E,CACpB,CAEOtE,GAAAA,CAAIC,EAAWqE,GACpB,OAAOC,EAActE,EAAGqE,EAAG5E,KAAK0E,MAAO1E,KAAK2E,MAC9C,CAEO3D,OAAAA,CAAQnB,EAA4B,IACzC,OAAOiF,EACL,CACEhF,KAAM,CAAES,EAAGP,KAAK0E,MAAOE,EAAG5E,KAAK2E,QAEjC9E,EAEJ,CAEOgB,SAAAA,CAAUkE,EAAS,GACxB,OAAOhE,EAAkBgE,EAC3B,CAEOC,SAAAA,CACLtE,EAASuE,EAA0B,CACjCnF,KAAM,CAAES,EAAGP,KAAK0E,MAAOE,EAAG5E,KAAK2E,OAC/BI,OAAQ,KAGV,OAAOG,EAAoB,CACzBpF,KAAM,CAAES,EAAGP,KAAK0E,MAAOE,EAAG5E,KAAK2E,OAC/BjE,UAEJ,CAEON,WAAAA,CAAYC,GACjB,OAAOJ,EAAoBI,EAC7B,CAEOH,WAAAA,CAAYJ,GACjB,OAAOK,EAAoBL,EAC7B,CAEO8B,eAAAA,CAAgBmD,EAAS,GAC9B,OAAOE,EAA0B,CAC/BF,SACAjF,KAAM,CAAES,EAAGP,KAAK0E,MAAOE,EAAG5E,KAAK2E,QAEnC,CAEA,QAAW7E,CAAKA,GACdA,EAAOqF,EAAerF,GACtBE,KAAK0E,MAAQ5E,EAAKS,EAClBP,KAAK2E,MAAQ7E,EAAK8E,CACpB,EAGK,MAAMC,EAAgBA,CAC3BtE,EACAqE,EACAQ,EACAC,IAEOlG,KAAK2C,IACV5C,GAAuBC,KAAKmC,IAAIf,EAAI6E,EAAO,GAAKjG,KAAKmC,IAAIsD,EAAIS,EAAO,KAI3DP,EAAoBA,CAC/B7D,EACApB,EAA4B,MAE5B,IAAIC,KAAEA,EAAO,GAAEC,GAAEA,GAAOkB,EAExBnB,EAAO2E,EAAa3E,EAAMC,GAE1B,IAAIoB,OACFA,EAASJ,IAAmBG,OAC5BA,EAAS,CAAEX,EAAG,EAAGqE,EAAG,GAAGlE,OACvBA,EAASuE,EAA0B,CAAEnF,OAAMiF,OAAQ,KACjDlF,EAEJsB,EAASgE,EAAehE,GAExBD,EAASiE,EAAejE,GAExB,IAAK,MAAMoE,IAAQ,CAAC,IAAK,KAClBpE,EAAOoE,KACVpE,EAAOoE,GAAQnG,KAAKiC,IAClBjC,KAAKkC,KAAKvB,EAAKwF,GAAQnE,EAAOmE,IAC9BnG,KAAKmC,IAAI,EAAG,IAAM,GAEhBJ,EAAOoE,GAAQ,GAAM,GAAGpE,EAAOoE,MAIvC,MAAMC,GAAWrE,EAAOX,EAAI,GAAK,EAC3BiF,GAAWtE,EAAO0D,EAAI,GAAK,EAC3BpD,EAAO,IAAIiE,MAAMvE,EAAOX,GAC9B,IAAK,IAAImB,EAAI,EAAGA,EAAIR,EAAOX,EAAGmB,IAC5BF,EAAKE,GAAK,IAAID,aAAaP,EAAO0D,GAEpC,IAAK,IAAIlD,EAAI,EAAGA,EAAIR,EAAOX,EAAGmB,IAC5B,IAAK,IAAIgE,EAAI,EAAGA,EAAIxE,EAAO0D,EAAGc,IAC5BlE,EAAKE,GAAGgE,GACNb,EAAcnD,EAAI6D,EAASG,EAAIF,EAAS1F,EAAKS,EAAGT,EAAK8E,GAAKlE,EAGhE,OAAOc,GAGIyD,EAA4BA,CACvCpF,EAA4C,MAE5C,IAAIkF,OAAEA,EAAS,EAACjF,KAAEA,EAAO,GAAEC,GAAEA,GAAOF,EAEpC,OADAC,EAAO2E,EAAa3E,EAAMC,GAClBgF,EAAS5F,KAAKC,IAAM,GAAMD,KAAKI,GAAKO,EAAK8E,EAAI9E,EAAKS,IAG/C2E,EAAsBA,CACjCrF,EAAsC,MAEtC,IAAIC,KAAEA,EAAO,GAAEY,OAAEA,EAAS,EAACX,GAAEA,GAAOF,EAIpC,OAFAC,EAAO2E,EAAa3E,EAAMC,GAElBW,EAASvB,KAAKI,GAAKO,EAAK8E,EAAI9E,EAAKS,EAAKpB,KAAKC,IAAM,GAG3D,SAAS+F,EAAeQ,GACtB,MAAwB,iBAAVA,EAAqB,CAAEpF,EAAGoF,EAAOf,EAAGe,GAAU,IAAKA,EACnE,CAEA,SAASlB,EAAa3E,EAA0BC,GAC9C,QAAW6F,IAAP7F,EAAkB,CACpB,IAAI8F,EAAWV,EAAepF,GAC9B,MAAO,CACLQ,EAAGN,EAAoB,EAAI4F,EAAStF,GACpCqE,EAAG3E,EAAoB,EAAI4F,EAASjB,GAEvC,CAAM,QAAagB,IAAT9F,EACT,OAAOqF,EAAerF,GAEtB,MAAM,IAAI8C,MAAM,mDAEpB,CC5MM,SAAUkD,EAAW7E,GACzB,MAAM8E,KAAEA,GAAS9E,EAEjB,OAAQ8E,GACN,IAAK,WACH,OAAO,IAAIpG,EAASsB,GACtB,IAAK,aACH,OAAO,IAAImB,EAAWnB,GACxB,IAAK,cACH,OAAO,IAAIoC,EAAYpC,GACzB,IAAK,uBACH,OAAO,IAAIgC,EAAqBhC,GAClC,IAAK,wBACH,OAAO,IAAI6C,EAAsB7C,GACnC,QACE,MAAM2B,MAAM,wBAAwBmD,KAG1C,CCvBM,SAAUC,EAAW/E,GACzB,MAAM8E,KAAEA,GAAS9E,EACjB,GACO,aADC8E,EAEJ,OAAO,IAAIvB,EAAWvD,GAItB,MAAM2B,MAAM,wBAFamD,IAK/B,CChBA,MAAME,EAAWC,OAAOC,UAAUF,SAoB5B,SAAUG,EAAWC,GACzB,MAAMC,EAAML,EAASM,KAAKF,GAC1B,OAAOC,EAAIE,SAAS,YAAcF,EAAIG,SAAS,MACjD,CCPM,SAAUC,EACdC,EACAC,EACA/G,EAAoC,CAAA,GAEpC,MAAMgH,OAAEA,GAAS,GAAShH,EAC1B,GAAIgH,EAAQ,CACV,IAAIC,EAAM,EACNC,EAAOJ,EAAMzF,OAAS,EACtB8F,EAAS,EACb,KAAOD,EAAOD,EAAM,GAElB,GADAE,EAASF,GAAQC,EAAOD,GAAQ,GAC5BH,EAAMK,GAAUJ,EAClBE,EAAME,MACD,MAAIL,EAAMK,GAAUJ,GAGzB,OAAOI,EAFPD,EAAOC,CAGT,CAGF,OAAIF,EAAMH,EAAMzF,OAAS,EACnB/B,KAAK8H,IAAIL,EAASD,EAAMG,IAAQ3H,KAAK8H,IAAIN,EAAMG,EAAM,GAAKF,GACrDE,EAEAA,EAAM,EAGRA,CAEX,CAAO,CACL,IAAII,EAAQ,EACRC,EAAOC,OAAOC,kBAClB,IAAK,IAAI3F,EAAI,EAAGA,EAAIiF,EAAMzF,OAAQQ,IAAK,CACrC,MAAM4F,EAAcnI,KAAK8H,IAAIN,EAAMjF,GAAKkF,GACpCU,EAAcH,IAChBA,EAAOG,EACPJ,EAAQxF,EAEZ,CACA,OAAOwF,CACT,CACF,CClBM,SAAUK,EAGdC,EACAtG,GAEA,OAAIsG,IAAqB/B,MAChB,IAAI+B,EAAiBtG,GAAQuG,KAClC,GAGK,IAAID,EACTtG,EAGN,CCxDA,MACMwG,EAAY,EAAI,SAMtB,SAASC,EAAeC,EAAWC,GAGjC,MAAMC,EAAU,OAFhBF,KAAO,GAIP,QADYA,EAAIE,IAFhBD,KAAO,KAGgB,GAAKC,EAAMD,IAAO,CAC3C,CAEM,MAAOE,EACJC,OAECC,MAMRrI,WAAAA,CAAYsI,EAAOC,KAAKC,OACtBpI,KAAKiI,MAAQ,IAAII,YAAY,GAC7BrI,KAAKsI,KAAKJ,GACVlI,KAAKgI,OAAShI,KAAKuI,SAASC,KAAKxI,KACnC,CAKOyI,SAAAA,GAEL,OADAzI,KAAK0I,YACG1I,KAAKiI,MAAM,GAAKjI,KAAKiI,MAAM,KAAQ,CAC7C,CAKOM,QAAAA,GACL,OAAQvI,KAAKyI,cAAgB,GAAKf,CACpC,CAEOY,IAAAA,CAAKJ,GACV,IAAKd,OAAOuB,UAAUT,GACpB,MAAM,IAAIU,UAAU,2BAEtB5I,KAAKiI,MAAM,GAAKC,EAChBlI,KAAKiI,MAAM,GAAK,EAChBjI,KAAKiI,MAAM,GAAK,EAChBjI,KAAKiI,MAAM,GAAK,EAChB,IAAK,IAAIvG,EAAI,EAAGA,EArDP,EAqDiBA,IACxB1B,KAAKiI,MAAU,EAAJvG,IACRA,EACCiG,EACE,WACA3H,KAAKiI,MAAOvG,EAAI,EAAK,GAAO1B,KAAKiI,MAAOvG,EAAI,EAAK,KAAO,KAAQ,KAEpE,EAEJ1B,KAAK6I,sBACL,IAAK,IAAInH,EAAI,EAAGA,EA/DP,EA+DiBA,IACxB1B,KAAK0I,WAET,CAEQG,mBAAAA,GAEc,IAAlB7I,KAAKiI,MAAM,IACO,IAAlBjI,KAAKiI,MAAM,IACO,IAAlBjI,KAAKiI,MAAM,IACO,IAAlBjI,KAAKiI,MAAM,KAEXjI,KAAKiI,MAAM,GAAK,GAChBjI,KAAKiI,MAAM,GAAK,GAChBjI,KAAKiI,MAAM,GAAK,GAChBjI,KAAKiI,MAAM,GAAK,GAEpB,CAEQS,SAAAA,GACN,IAAII,EAAI9I,KAAKiI,MAAM,GACnBa,GAAKA,GAjFG,GAkFRA,GAAKA,IAjFG,GAkFRA,GAAK9I,KAAKiI,MAAM,IAjFR,GAkFRjI,KAAKiI,MAAM,GAAKjI,KAAKiI,MAAM,GAC3BjI,KAAKiI,MAAM,GAAKjI,KAAKiI,MAAM,GAC3BjI,KAAKiI,MAAM,GAAKjI,KAAKiI,MAAM,GAC3BjI,KAAKiI,MAAM,GAAKa,CAClB,ECJF,MAAMC,GACJC,GAAS,EACTC,IAAY,EAEZC,GACAC,GACAC,GAEAxJ,WAAAA,CAAYsJ,EAAcC,EAA2BC,GACnDpJ,MAAKkJ,EAAQA,EACblJ,MAAKmJ,EAAqBA,EAC1BnJ,MAAKoJ,EAAaA,CACpB,CAEAC,gBAAAA,GACE,IAAIC,EAAK/E,EAAGgF,EAAGC,EAEf,GAAIxJ,MAAKiJ,EACPjJ,MAAKiJ,GAAY,EACjBK,EAAMtJ,MAAKgJ,EAAShJ,MAAKmJ,EAAqBnJ,MAAKkJ,MAC9C,CACL,GACE3E,EAA+B,EAA3BvE,MAAKoJ,EAAWpB,SAAe,EACnCuB,EAA+B,EAA3BvJ,MAAKoJ,EAAWpB,SAAe,EAEnCwB,EAAIjF,EAAIA,EAAIgF,EAAIA,QACTC,GAAK,GAAW,IAANA,GAEnBA,EAAIrK,KAAKG,MAAM,EAAKH,KAAK6C,IAAIwH,GAAMA,GAEnCxJ,MAAKgJ,EAASO,EAAIC,EAClBxJ,MAAKiJ,GAAY,EACjBK,EAAMtJ,MAAKkJ,EAAQlJ,MAAKmJ,EAAqB5E,EAAIiF,CACnD,CACA,OAAOF,CACT,EC/GI,SAAUG,GACd9C,EACA9G,EAAkC,KCI9B,SACJ8F,EACA9F,EAAyB,IAEzB,MAAM6J,UAAEA,GAAc7J,EACtB,IAAKuG,EAAWT,GACd,MAAM,IAAIiD,UAAU,0BAEtB,GAAqB,IAAjBjD,EAAMzE,OACR,MAAM,IAAI0H,UAAU,2BAEtB,GAAwB,iBAAbjD,EAAM,GACf,MAAM,IAAIiD,UAAU,8BAEtB,GAAIc,GAAa/D,EAAMzE,OAASwI,EAC9B,MAAM,IAAI9G,MAAM,wCAAwC8G,IAE5D,CDnBEC,CAAOhD,GACP,MAAMiD,UAAEA,EAASC,QAAEA,GEiBf,SACJtJ,EACAV,EAAkC,IAElC,IAAI+J,UAAEA,EAASC,QAAEA,GAAYhK,EAC7B,MAAMiK,KAAEA,EAAIC,GAAEA,GAAOlK,EAsBrB,YApBkB+F,IAAdgE,IAEAA,OADWhE,IAATkE,EACUpD,EAAkBnG,EAAGuJ,GAErB,QAGAlE,IAAZiE,IAEAA,OADSjE,IAAPmE,EACQrD,EAAkBnG,EAAGwJ,GAErBxJ,EAAEW,OAAS,GAGrB0I,EAAY,IAAGA,EAAY,GAC3BC,EAAU,IAAGA,EAAU,GACvBD,GAAarJ,EAAEW,SAAQ0I,EAAYrJ,EAAEW,OAAS,GAC9C2I,GAAWtJ,EAAEW,SAAQ2I,EAAUtJ,EAAEW,OAAS,GAE1C0I,EAAYC,KAAUD,EAAWC,GAAW,CAACA,EAASD,IACnD,CAAEA,YAAWC,UACtB,CF7CiCG,CAAgBrD,EAAO9G,GACtD,IAAIoK,EAAWtD,EAAMiD,GAErB,IAAK,IAAIlI,EAAIkI,EAAY,EAAGlI,GAAKmI,EAASnI,IACpCiF,EAAMjF,GAAKuI,IACbA,EAAWtD,EAAMjF,IAGrB,OAAOuI,CACT,CGaM,SAAUC,GAGdrK,GAEA,MAAMsK,OACJA,EAAMC,OACNA,EAASD,GAAQjJ,QAAU,EAACmJ,UAC5BA,EAAYF,IAAS,GAAGjJ,QAAU,EAACsG,iBACnCA,EAAmB/F,cACjB5B,EAEEyK,EAA0D,GAChE,IAAK,IAAIC,EAAM,EAAGA,EAAMH,EAAQG,IAC9BD,EAAUE,KAAKjD,EAAkBC,EAAkB6C,IAErD,OAAOC,CACT,CC/CM,SAAUG,GAAcN,ICNxB,SAAsB3I,GAC1B,GAAoB,IAAhBA,EAAKN,QAAmC,IAAnBM,EAAK,GAAGN,OAC/B,MAAM,IAAIwJ,WAAW,4BAGvB,MAAMC,EAAcnJ,EAAK,GAAGN,OAC5B,IAAK,IAAIQ,EAAI,EAAGA,EAAIF,EAAKN,OAAQQ,IAC/B,GAAIF,EAAKE,GAAGR,SAAWyJ,EACrB,MAAM,IAAID,WAAW,oCAG3B,CDDEE,CAAYT,GACZ,MAAMC,EAASD,EAAOjJ,OAChBmJ,EAAYF,EAAO,GAAGjJ,OAE5B,IAAIE,EAAM+I,EAAO,GAAG,GAChBU,EAAMV,EAAO,GAAG,GAEpB,IAAK,IAAIW,EAAS,EAAGA,EAAST,EAAWS,IACvC,IAAK,IAAIP,EAAM,EAAGA,EAAMH,EAAQG,IAC1BJ,EAAOI,GAAKO,GAAU1J,IAAKA,EAAM+I,EAAOI,GAAKO,IAC7CX,EAAOI,GAAKO,GAAUD,IAAKA,EAAMV,EAAOI,GAAKO,IAIrD,MAAO,CAAE1J,MAAKyJ,MAChB,CEGc,SAAUE,GAASvJ,EAAc3B,EAAwB,IACrE,MAAMqI,KAAEA,EAAO,EAAC8C,aAAEA,EAAe,SAAQC,QAAEA,EAAU,GAAMpL,EACrDqL,EAASzB,GAAUjI,EAAKoD,GAAKqG,EAAW,IACxCE,EPaF,SACJtL,EAAoC,IAEpC,MAAMqJ,KACJA,EAAO,EAACC,kBACRA,EAAoB,EAACjI,OACrBA,EAAS,IAAIgK,MACbA,EAAQ,EAAChD,KACTA,EAAI8C,aACJA,EAAe,UACbnL,EAEEuJ,EAAY,IAAIrB,EAAMG,GACtBkD,EAAc,IAAI3J,aAAaP,GAErC,OAAQ8J,GACN,IAAK,SAAU,CACb,MAAMK,EAAoB,IAAItC,GAC5BG,EACAC,EACAC,GAEF,IAAK,IAAI1H,EAAI,EAAGA,EAAIR,EAAQQ,IAC1B0J,EAAY1J,GAAK2J,EAAkBhC,mBAErC,KACF,CACA,IAAK,UACH,IAAK,IAAI3H,EAAI,EAAGA,EAAIR,EAAQQ,IAC1B0J,EAAY1J,IAAM0H,EAAUpB,SAAW,IAAOkD,EAAQhC,EAExD,MAEF,QACE,MAAM,IAAItG,MAAM,yBAAyB0I,OAAON,MAIpD,OAAOI,CACT,COpDgBG,CAAkB,CAC9BP,eACA9C,OACAgB,KAAM,EACNC,kBAAmB+B,EACnBA,QACAhK,OAAQM,EAAKjB,EAAEW,SAGjB,OADAM,EAAKoD,EChCD,SACJ4G,EACAC,GAEA,IAAIC,GAAa,EACbC,EAAW,EACf,GAAIvF,EAAWqF,IACb,GAAID,EAAOtK,SAAWuK,EAAOvK,OAC3B,MAAM,IAAI0B,MAAM,oDAGlB8I,GAAa,EACbC,EAAWF,EAGb,MAAMG,EAAS,IAAInK,aAAa+J,EAAOtK,QACvC,GAAIwK,EACF,IAAK,IAAIhK,EAAI,EAAGA,EAAI8J,EAAOtK,OAAQQ,IACjCkK,EAAOlK,GAAK8J,EAAO9J,GAAKiK,OAG1B,IAAK,IAAIjK,EAAI,EAAGA,EAAI8J,EAAOtK,OAAQQ,IACjCkK,EAAOlK,GAAK8J,EAAO9J,GAAM+J,EAAuB/J,GAIpD,OAAOkK,CACT,CDKWC,CAAKrK,EAAKoD,EAAGuG,GACf3J,CACT,CE4DM,MAAOsK,GACHhC,KACAC,GACAgC,SACDC,SACCC,aACAC,cACAjL,MACAO,KACR5B,WAAAA,CAAmBC,EAAuB,IACxC,MAAMiK,KACJA,EAAO,EAACC,GACRA,EAAK,IAAIgC,SACTA,EAAW,MAAKE,aAChBA,EAAYhL,MACZA,EAAQ,CAAE8E,KAAM,WAAYjG,KAAM,IAChCD,EAEJG,KAAK8J,KAAOA,EACZ9J,KAAK+J,GAAKA,EACV/J,KAAK+L,SAAWA,EAChB/L,KAAKgM,UAAYhM,KAAK+J,GAAK/J,KAAK8J,OAAS9J,KAAK+L,SAAW,GACzD/L,KAAKiM,aAAeA,EACpBjM,KAAKkM,cAAgB9E,OAAO+E,iBAE5BnM,KAAKwB,KAAO,CACVjB,EAAG,IAAIkB,aAAazB,KAAK+L,UACzBnH,EAAG,IAAInD,aAAazB,KAAK+L,WAG3B,MAAMK,EAAiBtG,EAAW7E,GAOlC,GANAjB,KAAKiB,MAAQmL,EAEbC,GAAarM,KAAK8J,KAAM,QACxBuC,GAAarM,KAAK+J,GAAI,MA4O1B,SAAuB1D,EAAeiG,GACpC,IAAKlF,OAAOuB,UAAUtC,GACpB,MAAM,IAAIuC,UAAU,GAAG0D,8BAE3B,CA/OIC,CAAcvM,KAAK+L,SAAU,YAEzB/L,KAAK+J,IAAM/J,KAAK8J,KAClB,MAAM,IAAIY,WAAW,sCAGvB,GAAI1K,KAAKiM,cAA6C,mBAAtBjM,KAAKiM,aACnC,MAAM,IAAIrD,UAAU,0CAGtB5I,KAAKwM,OACP,CAQOC,QAAAA,CAASC,EAA8B7M,GAC5C,KACG4F,MAAMkH,QAAQD,IACG,iBAAVA,QACM9G,IAAZ8G,EAAMnM,QACMqF,IAAZ8G,EAAM9H,GACLa,MAAMkH,QAAQD,EAAMnM,IACpBkF,MAAMkH,QAAQD,EAAM9H,IACrB8H,EAAMnM,EAAEW,SAAWwL,EAAM9H,EAAE1D,QAE7B,MAAM,IAAI0H,UACR,8DAGJ,GAAInD,MAAMkH,QAAQD,GAChB,IAAK,MAAME,KAAQF,EACjB1M,KAAK6M,QAAQD,EAAM/M,QAGrB,IAAK,IAAI6B,EAAI,EAAGA,EAAIgL,EAAMnM,EAAEW,OAAQQ,IAClC1B,KAAK6M,QAAQ,CAACH,EAAMnM,EAAEmB,GAAIgL,EAAM9H,EAAElD,IAAK7B,GAG3C,OAAOG,IACT,CASO6M,OAAAA,CAAQD,EAAc/M,EAAuB,IAClD,GAAI4F,MAAMkH,QAAQC,IAASA,EAAK1L,OAAS,EACvC,MAAM,IAAI0B,MACR,mFAIJ,IACG6C,MAAMkH,QAAQC,UACHhH,IAAXgH,EAAKrM,QAA8BqF,IAAXgH,EAAKhI,GAE9B,MAAM,IAAIhC,MACR,mFAIJ,IAAIkK,EACAC,EACAC,EACAC,EACAC,EACAzH,MAAMkH,QAAQC,IACfE,EAAWC,EAAWC,EAAUE,GAAoBN,GAErDE,EAAYF,EAAKrM,EACjBwM,EAAYH,EAAKhI,EACjBqI,EAAYL,EAAKvM,MACjB6M,EAAmBN,EAAK3L,OAEtB8L,EAAY/M,KAAKkM,gBAAelM,KAAKkM,cAAgBa,GAEzD,IAAM9L,MAAOkM,GAAiBtN,EAE1BqN,IACFC,EAAeA,EACX,IAAKA,KAAiBD,GACtBA,GAGN,MAAMjM,EAAQkM,EACVrH,EAAWqH,GACVjH,OAAOkH,OACNlH,OAAOmH,OAAOnH,OAAOoH,eAAetN,KAAKiB,QACzCjB,KAAKiB,QAGLZ,MAAEA,GAAUR,EAClB,IAAI0N,UAAEA,EAASC,WAAEA,GAAe3N,EAWhC,MAAMC,OACS8F,IAAboH,EACIA,EACAC,EACEhM,EAAMb,YAAY6M,GAClBjN,KAAKiM,aACHjM,KAAKiM,aAAaa,QACRlH,IAAVvF,EACEA,EACAY,EAAMnB,KAKlB,GAHKyN,IAAWA,EAAYzN,GACvB0N,IAAYA,EAAa1N,IAEzByN,IAAcC,EACjB,MAAM,IAAI5K,MAAM,4CAGlB,MAAMzB,OACeyE,IAAnB/F,EAAQsB,OAAuBF,EAAMJ,YAAchB,EAAQsB,OAEvDsM,EAAaX,EAAaS,EAAY,EAAKpM,EAC3CuM,EAAYZ,EAAaU,EAAa,EAAKrM,EAE3CwM,EAAaxO,KAAK0L,IACtB,EACA1L,KAAKyO,OAAOH,EAAazN,KAAK8J,MAAQ9J,KAAKgM,WAEvC6B,EAAY1O,KAAKiC,IACrBpB,KAAK+L,SAAW,EAChB5M,KAAKkC,MAAMqM,EAAY1N,KAAK8J,MAAQ9J,KAAKgM,WAErC8B,EAAc3O,KAAK4O,OAAOjB,EAAY9M,KAAK8J,MAAQ9J,KAAKgM,UAK9D/K,EAAMnB,KAAOyN,EACb,IAAK,IAAIrG,EAAQyG,EAAYzG,EAAQ/H,KAAK0L,IAAIiD,EAAa,GAAI5G,IAC7DlH,KAAKwB,KAAKoD,EAAEsC,IACV6F,EAAY9L,EAAMX,IAAIN,KAAKwB,KAAKjB,EAAE2G,GAAS4F,GAI/C7L,EAAMnB,KAAO0N,EACb,IACE,IAAItG,EAAQ/H,KAAKiC,IAAI0M,EAAaD,GAClC3G,GAAS2G,EACT3G,IAEAlH,KAAKwB,KAAKoD,EAAEsC,IACV6F,EAAY9L,EAAMX,IAAIN,KAAKwB,KAAKjB,EAAE2G,GAAS4F,GAG/C,OAAO9M,IACT,CAOOgO,WAAAA,CAAYC,GAEjB,OC9SU,SAAsBzM,EAAcyM,GAChD,IAAKA,EAAa,OAAOzM,EACzB,MAAM0M,EAAK1M,EAAKjB,EACV4N,EAAK3M,EAAKoD,EAChB,IAAK,IAAIlD,EAAI,EAAGA,EAAIwM,EAAGhN,OAAQQ,IAC7ByM,EAAGzM,IAAMuM,EAAYC,EAAGxM,GAG5B,CDqSIsM,CAAYhO,KAAKwB,KAAMyM,GAChBjO,IACT,CAOO+K,QAAAA,CAASlL,GAEd,OADAkL,GAAS/K,KAAKwB,KAAM3B,GACbG,IACT,CAOOoO,WAAAA,CAAYvO,EAAwC,IAClC,kBAAZA,IACTA,EAAU,CAAEwO,KAAMxO,IAEpB,MAAMwO,KAAEA,GAAO,EAAIC,UAAEA,EAAY,GAAMzO,EACvC,GAAIyO,EAAW,CACb,MAAMC,EAAgBvO,KAAKkM,cAAgBoC,EACrC/N,EAAI,GACJqE,EAAI,GACV,IAAK,IAAIlD,EAAI,EAAGA,EAAI1B,KAAKwB,KAAKjB,EAAEW,OAAQQ,IAClC1B,KAAKwB,KAAKoD,EAAElD,IAAM6M,IACpBhO,EAAEiK,KAAKxK,KAAKwB,KAAKjB,EAAEmB,IACnBkD,EAAE4F,KAAKxK,KAAKwB,KAAKoD,EAAElD,KAGvB,MAAO,CAAEnB,EAAGkB,aAAaqI,KAAKvJ,GAAIqE,EAAGnD,aAAaqI,KAAKlF,GACzD,CACA,OAAIyJ,EACK,CACL9N,EAAGP,KAAKwB,KAAKjB,EAAEiO,QACf5J,EAAG5E,KAAKwB,KAAKoD,EAAE4J,SAGVxO,KAAKwB,IAEhB,CAMOgL,KAAAA,GACL,GAAsB,IAAlBxM,KAAK+L,SACP/L,KAAKwB,KAAKjB,EAAE,IAAMP,KAAK8J,KAAO9J,KAAK+J,IAAM,OAEzC,IAAK,IAAIrI,EAAI,EAAGA,EAAI1B,KAAK+L,SAAUrK,IACjC1B,KAAKwB,KAAKjB,EAAEmB,GAAK1B,KAAK8J,KAAOpI,EAAI1B,KAAKgM,SAG1C,OAAOhM,IACT,EASF,SAASqM,GAAahG,EAAeiG,GACnC,IAAKlF,OAAOqH,SAASpI,GACnB,MAAM,IAAIuC,UAAU,GAAG0D,4BAE3B,CAQM,SAAUoC,GACdhC,EACA7M,EAAmC,IAEnC,MACEuJ,UAAWuF,EAAgBxD,MAC3BA,EAAKyD,SACLA,EAAQN,UACRA,EAASO,YACTA,GACEhP,EAEEuJ,EAAY,IAAI0C,GAAkB6C,GAOxC,OALAvF,EAAUqD,SAASC,EAAOmC,GACtBD,GAAUxF,EAAU4E,YAAYY,GAChCzD,GACF/B,EAAU2B,SAASI,GAEd/B,EAAUgF,YAAY,CAC3BE,aAEJ,CE7YA,MAAMQ,GAAmB,CAAC,IAAK,KAGzBC,GAAqC,CAAC,IAAK,IAAK,KAQhDC,GAAqBA,CAAC/N,EAAqBZ,KAC/C,MAAM4O,EAAY9J,GAAe9E,GACjC,IAAK,MAAM6O,KAAOJ,GAChBG,EAAUC,GAAOjO,EAAMb,YAAY6O,EAAUC,IAE/C,OAAOD,GAgFH,MAAOE,GACHrF,KACAC,GACAgC,SACDC,SACCxK,KACA0K,cACAjL,MACAgL,aAERrM,WAAAA,CAAmBC,EAAuB,IACxC,MAAMoM,aACJA,EAAeA,IAAM,EAAChL,MACtBA,EAAQ,CACN8E,KAAM,aAENlG,EACJ,IAAIiK,KAAEA,EAAO,EAACC,GAAEA,EAAK,IAAGgC,SAAEA,EAAW,MAASlM,EAE9CiK,EAAO3E,GAAe2E,GACtBC,EAAK5E,GAAe4E,GACpBgC,EAAW5G,GAAe4G,GAE1B,IAAK,MAAMzG,KAAQwJ,GACjBzC,GAAavC,EAAKxE,GAAO,QAAQA,KACjC+G,GAAatC,EAAGzE,GAAO,MAAMA,KAC7BiH,GAAcR,EAASzG,GAAO,YAAYA,KAG5CtF,KAAK8J,KAAOA,EACZ9J,KAAK+J,GAAKA,EACV/J,KAAK+L,SAAWA,EAChB/L,KAAKgM,SAoQT,SAA0BlC,EAAgBC,EAAcgC,GACtD,MAAO,CACLxL,GAAIwJ,EAAGxJ,EAAIuJ,EAAKvJ,IAAMwL,EAASxL,EAAI,GACnCqE,GAAImF,EAAGnF,EAAIkF,EAAKlF,IAAMmH,EAASnH,EAAI,GAEvC,CAzQoBwK,CAAiBtF,EAAMC,EAAIgC,GAE3C/L,KAAKiM,aAAeA,EACpBjM,KAAKkM,cAAgB9E,OAAO+E,iBAE5B,MAAMC,EAAiBpG,EAAW/E,GAClCjB,KAAKiB,MAAQmL,EAEbpM,KAAKwB,KAAO,CACVjB,EAAG,IAAIkB,aAAasK,EAASxL,GAC7BqE,EAAG,IAAInD,aAAasK,EAASnH,GAC7ByK,EAAGnF,GAAkB,CACnBE,OAAQpK,KAAK+L,SAASnH,EACtByF,UAAWrK,KAAK+L,SAASxL,KAI7B,IAAK,MAAM+E,KAAQwJ,GACjB,GAAI9O,KAAK+J,GAAGzE,IAAStF,KAAK8J,KAAKxE,GAC7B,MAAM,IAAIoF,WAAW,sCAIzB,GAAiC,mBAAtB1K,KAAKiM,aACd,MAAM,IAAIrD,UAAU,0CAGtB5I,KAAKwM,OACP,CAQOC,QAAAA,CAASC,EAAgC7M,GAC9C,KACG4F,MAAMkH,QAAQD,IACG,iBAAVA,QACM9G,IAAZ8G,EAAMnM,QACMqF,IAAZ8G,EAAM9H,GACLa,MAAMkH,QAAQD,EAAMnM,IACpBkF,MAAMkH,QAAQD,EAAM9H,IACrB8H,EAAMnM,EAAEW,SAAWwL,EAAM9H,EAAE1D,QAE7B,MAAM,IAAI0H,UACR,8DAGJ,GAAInD,MAAMkH,QAAQD,GAChB,IAAK,MAAME,KAAQF,EACjB1M,KAAK6M,QAAQD,EAAM/M,OAEhB,CACL,IACG4F,MAAMkH,QAAQD,EAAMnM,KACpBkF,MAAMkH,QAAQD,EAAM9H,KACpBa,MAAMkH,QAAQD,EAAM2C,GAErB,MAAM,IAAIzG,UAAU,8BAEtB,MAAM0G,EAAU5C,EAAMnM,EAAEW,OACxB,GAAIwL,EAAM9H,EAAE1D,SAAWoO,GAAW5C,EAAM2C,EAAEnO,SAAWoO,EACnD,MAAM,IAAI1M,MAAM,uCAElB,IAAK,IAAIlB,EAAI,EAAGA,EAAI4N,EAAS5N,IAC3B1B,KAAK6M,QAAQ,CAACH,EAAMnM,EAAEmB,GAAIgL,EAAM9H,EAAElD,GAAIgL,EAAM2C,EAAE3N,IAAK7B,EAEvD,CAEA,OAAOG,IACT,CAQO6M,OAAAA,CAAQD,EAAc/M,EAA4B,IACvD,GAAI4F,MAAMkH,QAAQC,IAASA,EAAK1L,OAAS,EACvC,MAAM,IAAI0B,MACR,sFAIJ,IACG6C,MAAMkH,QAAQC,IACfmC,GAAgBQ,KAAMC,QAAkB5J,IAAZgH,EAAK4C,IAEjC,MAAM,IAAI5M,MACR,sFAIJ,IAAIkK,EACA2C,EACA1C,EACAC,EACAC,EACAC,EACAzH,MAAMkH,QAAQC,IACfE,EAAW2C,EAAW1C,EAAWC,EAAUE,GAAoBN,GAEhEE,EAAYF,EAAKrM,EACjBkP,EAAY7C,EAAKhI,EACjBmI,EAAYH,EAAKyC,EACjBrC,EAAWJ,EAAK9M,KAChBmN,EAAYL,EAAKvM,MACjB6M,EAAmBN,EAAK3L,OAG1B,MAAMyO,EAAqB,CAAEnP,EAAGuM,EAAWlI,EAAG6K,GAC1C1C,EAAY/M,KAAKkM,gBAAelM,KAAKkM,cAAgBa,GAEzD,MAAM1M,MAAEA,GAAUR,EAClB,IAAMoB,MAAOkM,GAAiBtN,EAE1BqN,IACFC,EAAeA,EACX,IAAKA,KAAiBD,GACtBA,GAGN,MAAMjM,EAAQkM,EACVnH,EAAWmH,GACVjH,OAAOkH,OACNlH,OAAOmH,OAAOnH,OAAOoH,eAAetN,KAAKiB,QACzC0O,gBAAgB3P,KAAKiB,QAG3B,IAAInB,KACFA,QAAoB8F,IAAboH,EACHA,EACAC,EACE+B,GAAmB/N,EAAOgM,GAC1B5M,EACE2O,GAAmB/N,EAAOZ,GAC1BL,KAAKiM,aAAaa,EAAW2C,KACnC5P,EAEJC,EAAOqF,GAAerF,GAEtB,IAAIqB,OACiByE,IAAnB/F,EAAQsB,OAAuBF,EAAMJ,YAAchB,EAAQsB,OAE7DA,EAASgE,GAAehE,GAExB,MAAMwM,EAAuB,CAAEpN,EAAG,EAAGqE,EAAG,GAClCiJ,EAAsB,CAAEtN,EAAG,EAAGqE,EAAG,GACvC,IAAK,MAAMU,KAAQwJ,GAAQ,CACzB,MAAMc,EAAQF,EAASpK,GAASxF,EAAKwF,GAAQ,EAAKnE,EAAOmE,GACnDuK,EAAOH,EAASpK,GAASxF,EAAKwF,GAAQ,EAAKnE,EAAOmE,GACxDqI,EAAWrI,GAAQnG,KAAK0L,IACtB,EACA1L,KAAKyO,OAAOgC,EAAQ5P,KAAK8J,KAAKxE,IAAStF,KAAKgM,SAAS1G,KAEvDuI,EAAUvI,GAAQnG,KAAKiC,IACrBpB,KAAK+L,SAASzG,GACdnG,KAAKkC,MAAMwO,EAAO7P,KAAK8J,KAAKxE,IAAStF,KAAKgM,SAAS1G,IAEvD,CAEArE,EAAMnB,KAAOA,EACb,IAAK,IAAIgQ,EAASnC,EAAWpN,EAAGuP,EAASjC,EAAUtN,EAAGuP,IACpD,IAAK,IAAIC,EAASpC,EAAW/I,EAAGmL,EAASlC,EAAUjJ,EAAGmL,IAAU,CAC9D,MAAM1J,EACJ0G,EACA9L,EAAMX,IACJN,KAAKwB,KAAKjB,EAAEuP,GAAUJ,EAASnP,EAC/BP,KAAKwB,KAAKoD,EAAEmL,GAAUL,EAAS9K,GAE/BzF,KAAK8H,IAAIZ,GAAS,OACpBrG,KAAKwB,KAAK6N,EAAEU,GAAQD,IAAWzJ,EAEnC,CAGF,OAAOrG,IACT,CAOOoO,WAAAA,CAAYvO,EAA0C,IACpC,kBAAZA,IACTA,EAAU,CAAEwO,KAAMxO,IAEpB,MAAMwO,KAAEA,GAAO,GAASxO,EAClBmQ,EAAUvF,GAAczK,KAAKwB,KAAK6N,GAExC,MAAO,CACLY,KAAMjQ,KAAK8J,KAAKvJ,EAChB2P,KAAMlQ,KAAK+J,GAAGxJ,EACd4P,KAAMnQ,KAAK+J,GAAGnF,EACdwL,KAAMpQ,KAAK8J,KAAKlF,EAChByL,KAAML,EAAQ5O,IACdkP,KAAMN,EAAQnF,IACdwE,EAAGhB,EAAOrO,KAAKwB,KAAK6N,EAAEb,QAAUxO,KAAKwB,KAAK6N,EAE9C,CAMO7C,KAAAA,GACL,MAAM+D,EAAmBvQ,KAAKwB,KAE9B,IAAK,MAAM8D,KAAQwJ,GACjB,IAAK,IAAIpN,EAAI,EAAGA,EAAI1B,KAAK+L,SAASzG,GAAO5D,IACvC6O,EAASjL,GAAM5D,GAAK1B,KAAK8J,KAAKxE,GAAQ5D,EAAI1B,KAAKgM,SAAS1G,GAG5D,IAAK,MAAMiF,KAAOgG,EAASlB,EACzB,IAAK,IAAI3J,EAAI,EAAGA,EAAI6E,EAAIrJ,OAAQwE,IAC9B6E,EAAI7E,GAAK,EAGb,OAAO1F,IACT,EASI,SAAUwQ,GACd9D,EACA7M,EAAqC,IAErC,MAAQuJ,UAAWuF,EAAkBjC,MAAO+D,GAAoB5Q,EAE1DuJ,EAAY,IAAI+F,GAAoBR,GAG1C,OADAvF,EAAUqD,SAASC,EAAO+D,GACnBrH,EAAUgF,aACnB,CAOA,SAASjJ,GAAeQ,GACtB,MAAwB,iBAAVA,EAAqB,CAAEpF,EAAGoF,EAAOf,EAAGe,GAAU,IAAKA,EACnE,CAsBA,SAAS4G,GAAclG,EAAeiG,GACpC,IAAKlF,OAAOuB,UAAUtC,GACpB,MAAM,IAAIuC,UAAU,GAAG0D,8BAE3B,CAQA,SAASD,GAAahG,EAAeiG,GACnC,IAAKlF,OAAOqH,SAASpI,GACnB,MAAM,IAAIuC,UAAU,GAAG0D,4BAE3B","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,22]}