{"version":3,"file":"convert-to-jcamp.esm.min.js","sources":["../lib/utils/addInfoData.js","../node_modules/is-any-array/lib/index.js","../node_modules/ml-spectra-processing/lib/x/getOutputArray.js","../node_modules/ml-spectra-processing/lib/x/xMinMaxValues.js","../node_modules/ml-spectra-processing/lib/x/xCheck.js","../node_modules/ml-spectra-processing/lib/x/xMultiply.js","../node_modules/ml-spectra-processing/lib/matrix/matrixMinMaxZ.js","../node_modules/ml-spectra-processing/lib/matrix/matrixCheck.js","../lib/utils/checkMatrix.js","../lib/utils/checkNumberOrArray.js","../lib/utils/getExtremeValues.js","../lib/utils/getFactorNumber.js","../lib/utils/getBestFactor.js","../lib/utils/getNumber.js","../lib/utils/rescaleAndEnsureInteger.js","../node_modules/ml-spectra-processing/lib/x/xDivide.js","../node_modules/ml-spectra-processing/lib/utils/isLittleEndian.js","../lib/utils/vectorEncoder.js","../lib/fromJSON.js","../lib/utils/xyDataCreator.js","../lib/utils/peakTableCreator.js","../lib/fromVariables.js","../lib/creatorNtuples.js","../lib/getOneIfArray.js","../lib/from1DNMRVariables.js","../lib/from2DNMRVariables.js","../lib/utils/getBestFactorMatrix.js"],"sourcesContent":["export const addInfoData = (data, options = {}) => {\n    const { keys = Object.keys(data), prefix = '##$' } = options;\n    let header = '';\n    for (const key of keys) {\n        header +=\n            typeof data[key] === 'object'\n                ? `${prefix}${key}=${JSON.stringify(data[key])}\\n`\n                : `${prefix}${key}=${data[key]}\\n`;\n    }\n    return header;\n};\n//# sourceMappingURL=addInfoData.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 * @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","import { isAnyArray } from 'is-any-array';\n/**\n * This function\n * @param output - undefined or a new array\n * @param length - length of the output array\n * @returns\n */\nexport function getOutputArray(output, length) {\n    if (output !== undefined) {\n        if (!isAnyArray(output)) {\n            throw new TypeError('output option must be an array if specified');\n        }\n        if (output.length !== length) {\n            throw new TypeError('the output array does not have the correct length');\n        }\n        return output;\n    }\n    else {\n        return new Float64Array(length);\n    }\n}\n//# sourceMappingURL=getOutputArray.js.map","import { xCheck } from \"./xCheck.js\";\n/**\n * Return min and max values of an array.\n * @param array - array of number\n * @returns object with 2 properties, min and max.\n */\nexport function xMinMaxValues(array) {\n    xCheck(array);\n    let min = array[0];\n    let max = array[0];\n    for (let i = 1; i < array.length; i++) {\n        const value = array[i];\n        if (value < min)\n            min = value;\n        else if (value > max)\n            max = value;\n    }\n    return { min, max };\n}\n//# sourceMappingURL=xMinMaxValues.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 = 1 } = 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 (input.length < minLength) {\n        throw new Error(`input must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xCheck.js.map","import { isAnyArray } from 'is-any-array';\nimport { getOutputArray } from \"./getOutputArray.js\";\n/**\n * This function xMultiply the first array by the second array or a constant value to each element of the first array\n * @param array1 - first array\n * @param array2 - second array\n * @param options - options\n */\nexport function xMultiply(array1, array2, options = {}) {\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 = getOutputArray(options.output, 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=xMultiply.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 { isAnyArray } from 'is-any-array';\nexport function checkMatrix(data) {\n    if (!isAnyArray(data) || !isAnyArray(data[0])) {\n        throw new Error(`2D data should be a matrix`);\n    }\n}\n//# sourceMappingURL=checkMatrix.js.map","import { isAnyArray } from 'is-any-array';\nexport function checkNumberOrArray(data) {\n    if (!isAnyArray(data) || isAnyArray(data[0])) {\n        throw new Error(`x and y data should be an array of numbers`);\n    }\n}\n//# sourceMappingURL=checkNumberOrArray.js.map","import { isAnyArray } from 'is-any-array';\nimport { matrixMinMaxZ } from 'ml-spectra-processing/matrix';\nimport { xMinMaxValues } from 'ml-spectra-processing/x';\nimport { checkMatrix } from \"./checkMatrix.js\";\nimport { checkNumberOrArray } from \"./checkNumberOrArray.js\";\nexport function getExtremeValues(data) {\n    if (isAnyArray(data[0])) {\n        checkMatrix(data);\n        const firstRow = data[0];\n        return {\n            firstLast: {\n                first: firstRow[0],\n                last: data.at(-1)[firstRow.length - 1],\n            },\n            minMax: matrixMinMaxZ(data),\n        };\n    }\n    checkNumberOrArray(data);\n    return {\n        firstLast: {\n            first: data[0],\n            last: data.at(-1),\n        },\n        minMax: xMinMaxValues(data),\n    };\n}\n//# sourceMappingURL=getExtremeValues.js.map","export function getFactorNumber(minMax, maxValue = 2 ** 31 - 1) {\n    let factor;\n    if (minMax.min < 0) {\n        if (minMax.max > 0) {\n            factor = Math.max(-minMax.min, minMax.max) / maxValue;\n        }\n        else {\n            factor = -minMax.min / maxValue;\n        }\n    }\n    else {\n        factor = minMax.max / maxValue;\n    }\n    return factor;\n}\n//# sourceMappingURL=getFactorNumber.js.map","import { xMinMaxValues } from 'ml-spectra-processing/x';\nimport { getFactorNumber } from \"./getFactorNumber.js\";\nexport function getBestFactor(array, options = {}) {\n    const { maxValue, factor, minMax } = options;\n    if (factor !== undefined) {\n        return factor;\n    }\n    // is there non integer number ?\n    let isOnlyInteger = true;\n    for (const y of array) {\n        if (Math.round(y) !== y) {\n            isOnlyInteger = false;\n            break;\n        }\n    }\n    if (isOnlyInteger) {\n        return 1;\n    }\n    // we need to rescale the values\n    // need to find the max and min values\n    const extremeValues = minMax || xMinMaxValues(array);\n    return getFactorNumber(extremeValues, maxValue);\n}\n//# sourceMappingURL=getBestFactor.js.map","/**\n * Reconvert number to original value\n * @param number - Number used for computation\n * @param factor - Multiplying factor\n * @returns Original value\n */\nexport function getNumber(number, factor) {\n    if (factor !== 1)\n        number /= factor;\n    const rounded = Math.round(number);\n    if (rounded !== number && Math.abs(rounded - number) <= Number.EPSILON) {\n        return rounded;\n    }\n    return number;\n}\n//# sourceMappingURL=getNumber.js.map","import { xDivide } from 'ml-spectra-processing/x';\nexport function rescaleAndEnsureInteger(data, factor = 1) {\n    if (factor === 1)\n        return data.map((value) => Math.round(value));\n    return xDivide(data, factor).map((value) => Math.round(value));\n}\n//# sourceMappingURL=rescaleAndEnsureInteger.js.map","import { isAnyArray } from 'is-any-array';\nimport { getOutputArray } from \"./getOutputArray.js\";\n/**\n * This function divide the first array by the second array or a constant value to each element of the first array\n * @param array1 - first array\n * @param array2 - second array or number\n * @param options - options\n */\nexport function xDivide(array1, array2, options = {}) {\n    let isConstant = false;\n    let constant = 0;\n    if (isAnyArray(array2)) {\n        if (array1.length !== array2.length) {\n            throw new RangeError('size of array1 and array2 must be identical');\n        }\n    }\n    else {\n        isConstant = true;\n        constant = array2;\n    }\n    const array3 = getOutputArray(options.output, 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=xDivide.js.map","const LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n/**\n * Check whether the host stores multi-byte values least significant byte first.\n * Needed whenever a typed array is reinterpreted through another view, because\n * the position of the words of a value then depends on the platform.\n * @returns true on a little-endian host.\n */\nexport function isLittleEndian() {\n    return LITTLE_ENDIAN;\n}\n//# sourceMappingURL=isLittleEndian.js.map","/**\n * class encodes a integer vector as a String in order to store it in a text file.\n * The algorithms used to encode the data are describe in:\n *            https://www.iupac.org/publications/pac/pdf/2001/pdf/7311x1765.pdf\n */\nconst newLine = '\\n';\nconst pseudoDigits = [\n    ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],\n    ['@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'],\n    ['@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'],\n    ['%', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R'],\n    ['%', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r'],\n    [' ', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 's'],\n];\nconst SQZ_P = 1;\nconst SQZ_N = 2;\nconst DIF_P = 3;\nconst DIF_N = 4;\nconst DUP = 5;\nconst maxLinelength = 100;\n/**\n * This function encodes the given vector. The xyEncoding format is specified by the\n * xyEncoding option\n * @param data - Integer vector to encode.\n * @param firstX - First x value.\n * @param intervalX - Interval between two x values.\n * @param xyEncoding - 'FIX', 'SQZ', 'DIF', 'DIFDUP', 'CVS' or 'PAC'. Default 'DIFDUP'.\n * @returns The encoded data.\n */\nexport function vectorEncoder(data, firstX, intervalX, xyEncoding) {\n    switch (xyEncoding) {\n        case 'FIX':\n            return fixEncoding(data, firstX, intervalX);\n        case 'SQZ':\n            return squeezedEncoding(data, firstX, intervalX);\n        case 'DIF':\n            return differenceEncoding(data, firstX, intervalX);\n        case 'DIFDUP':\n            return differenceDuplicateEncoding(data, firstX, intervalX);\n        case 'CSV':\n            return commaSeparatedValuesEncoding(data, firstX, intervalX);\n        case 'PAC':\n            return packedEncoding(data, firstX, intervalX);\n        case undefined:\n        default:\n            return differenceEncoding(data, firstX, intervalX);\n    }\n}\n/**\n * @param data\n * @param firstX\n * @param intervalX\n * @private\n * No data compression used. The data is separated by a comma(',').\n */\nexport function commaSeparatedValuesEncoding(data, firstX, intervalX) {\n    return fixEncoding(data, firstX, intervalX, ',');\n}\n/**\n * @param data\n * @param firstX\n * @param intervalX\n * @param separator\n * @private\n * No data compression used. The data is separated by the specified separator.\n */\nexport function fixEncoding(data, firstX, intervalX, separator = ' ') {\n    let outputData = '';\n    let j = 0;\n    const dataLength = data.length;\n    while (j < dataLength - 7) {\n        outputData += String(Math.ceil(firstX + j * intervalX));\n        for (let i = 0; i < 8; i++) {\n            outputData += `${separator}${data[j++]}`;\n        }\n        outputData += newLine;\n    }\n    if (j < dataLength) {\n        // We add last numbers\n        outputData += String(Math.ceil(firstX + j * intervalX));\n        for (let i = j; i < dataLength; i++) {\n            outputData += `${separator}${data[i]}`;\n        }\n    }\n    return outputData;\n}\n/**\n * @param data\n * @param firstX\n * @param intervalX\n * @private\n * No data compression used. The data is separated by the sign of the number.\n */\nexport function packedEncoding(data, firstX, intervalX) {\n    let outputData = '';\n    let j = 0;\n    const dataLength = data.length;\n    while (j < dataLength - 7) {\n        outputData += String(Math.ceil(firstX + j * intervalX));\n        for (let i = 0; i < 8; i++) {\n            outputData +=\n                data[j] < 0 ? String(data[j++]) : `+${data[j++]}`;\n        }\n        outputData += newLine;\n    }\n    if (j < dataLength) {\n        // We add last numbers\n        outputData += String(Math.ceil(firstX + j * intervalX));\n        for (let i = j; i < dataLength; i++) {\n            outputData += data[i] < 0 ? String(data[i]) : `+${data[i]}`;\n        }\n    }\n    return outputData;\n}\n/**\n * @param data\n * @param firstX\n * @param intervalX\n * @private\n * Data compression is possible using the squeezed form (SQZ) in which the delimiter, the leading digit,\n * and sign are replaced by a pseudo-digit from Table 1. For example, the Y-values 30, 32 would be\n * represented as C0C2.\n */\nexport function squeezedEncoding(data, firstX, intervalX) {\n    let outputData = '';\n    // String outputData = new String();\n    let j = 0;\n    const dataLength = data.length;\n    while (j < dataLength - 10) {\n        outputData += String(Math.ceil(firstX + j * intervalX));\n        for (let i = 0; i < 10; i++) {\n            outputData += squeezedDigit(String(data[j++]));\n        }\n        outputData += newLine;\n    }\n    if (j < dataLength) {\n        // We add last numbers\n        outputData += String(Math.ceil(firstX + j * intervalX));\n        for (let i = j; i < dataLength; i++) {\n            outputData += squeezedDigit(String(data[i]));\n        }\n    }\n    return outputData;\n}\n/**\n * @param data\n * @param firstX\n * @param intervalX\n * @private\n * Duplicate suppression xyEncoding\n */\nexport function differenceDuplicateEncoding(data, firstX, intervalX) {\n    let mult = 0;\n    let index = 0;\n    let charCount = 0;\n    // We built a string where we store the encoded data.\n    let encodedData = '';\n    let encodedNumber = '';\n    let temporary = '';\n    // We calculate the differences vector\n    const diffData = new Array(data.length - 1);\n    for (let i = 0; i < diffData.length; i++) {\n        diffData[i] = data[i + 1] - data[i];\n    }\n    // We simulate a line carry\n    const numberDiff = diffData.length;\n    while (index < numberDiff) {\n        if (charCount === 0) {\n            // Start line\n            encodedNumber = `${Math.ceil(firstX + index * intervalX)}${squeezedDigit(String(data[index]))}${differenceDigit(diffData[index].toString())}`;\n            encodedData += encodedNumber;\n            charCount += encodedNumber.length;\n        }\n        else if (diffData[index - 1] === diffData[index]) {\n            // Try to insert next difference\n            mult++;\n        }\n        else if (mult > 0) {\n            // Now we know that it can be in line\n            mult++;\n            encodedNumber = duplicateDigit(mult.toString());\n            encodedData += encodedNumber;\n            charCount += encodedNumber.length;\n            mult = 0;\n            index--;\n        }\n        else {\n            // Check if it fits, otherwise start a new line\n            encodedNumber = differenceDigit(diffData[index].toString());\n            if (encodedNumber.length + charCount < maxLinelength) {\n                encodedData += encodedNumber;\n                charCount += encodedNumber.length;\n            }\n            else {\n                // start a new line\n                encodedData += newLine;\n                temporary = `${Math.ceil(firstX + index * intervalX)}${squeezedDigit(String(data[index]))}${encodedNumber}`;\n                encodedData += temporary; // Each line start with first index number.\n                charCount = temporary.length;\n            }\n        }\n        index++;\n    }\n    if (mult > 0) {\n        encodedData += duplicateDigit((mult + 1).toString());\n    }\n    // We insert the last data from fid. It is done to control of data\n    // The last line start with the number of datas in the fid.\n    encodedData += `${newLine}${Math.ceil(firstX + index * intervalX)}${squeezedDigit(String(data[index]))}`;\n    return encodedData;\n}\n/**\n * @param data\n * @param firstX\n * @param intervalX\n * @private\n * Differential xyEncoding\n */\nexport function differenceEncoding(data, firstX, intervalX) {\n    let index = 0;\n    let charCount = 0;\n    let i;\n    let encodedData = '';\n    let encodedNumber = '';\n    let temporary = '';\n    // We calculate the differences vector\n    const diffData = new Array(data.length - 1);\n    for (i = 0; i < diffData.length; i++) {\n        diffData[i] = data[i + 1] - data[i];\n    }\n    const numberDiff = diffData.length;\n    while (index < numberDiff) {\n        if (charCount === 0) {\n            // We convert the first number.\n            encodedNumber = `${Math.ceil(firstX + index * intervalX)}${squeezedDigit(String(data[index]))}${differenceDigit(diffData[index].toString())}`;\n            encodedData += encodedNumber;\n            charCount += encodedNumber.length;\n        }\n        else {\n            encodedNumber = differenceDigit(diffData[index].toString());\n            if (encodedNumber.length + charCount < maxLinelength) {\n                encodedData += encodedNumber;\n                charCount += encodedNumber.length;\n            }\n            else {\n                encodedData += newLine;\n                temporary = `${Math.ceil(firstX + index * intervalX)}${squeezedDigit(String(data[index]))}${encodedNumber}`;\n                encodedData += temporary; // Each line start with first index number.\n                charCount = temporary.length;\n            }\n        }\n        index++;\n    }\n    // We insert the last number from data. It is done to control of data\n    encodedData += `${newLine}${Math.ceil(firstX + index * intervalX)}${squeezedDigit(String(data[index]))}`;\n    return encodedData;\n}\n/**\n * @param num\n * @param number_\n * @private\n * Convert number to the ZQZ format, using pseudo digits.\n */\nfunction squeezedDigit(number_) {\n    let sqzDigits = '';\n    if (number_.startsWith('-')) {\n        sqzDigits += pseudoDigit(SQZ_N, number_.charAt(1));\n        if (number_.length > 2) {\n            sqzDigits += number_.slice(2);\n        }\n    }\n    else {\n        sqzDigits += pseudoDigit(SQZ_P, number_.charAt(0));\n        if (number_.length > 1) {\n            sqzDigits += number_.slice(1);\n        }\n    }\n    return sqzDigits;\n}\n/**\n * Convert number to the DIF format, using pseudo digits.\n * @param num\n * @param number_\n */\nfunction differenceDigit(number_) {\n    let diffDigits = '';\n    if (number_.startsWith('-')) {\n        diffDigits += pseudoDigit(DIF_N, number_.charAt(1));\n        if (number_.length > 2) {\n            diffDigits += number_.slice(2);\n        }\n    }\n    else {\n        diffDigits += pseudoDigit(DIF_P, number_.charAt(0));\n        if (number_.length > 1) {\n            diffDigits += number_.slice(1);\n        }\n    }\n    return diffDigits;\n}\n/**\n * Convert number to the DUP format, using pseudo digits.\n * @param num\n * @param number_\n */\nfunction duplicateDigit(number_) {\n    let dupDigits = '';\n    dupDigits += pseudoDigit(DUP, number_.charAt(0));\n    if (number_.length > 1) {\n        dupDigits += number_.slice(1);\n    }\n    return dupDigits;\n}\nfunction pseudoDigit(row, digit) {\n    return pseudoDigits[row][Number(digit)];\n}\n//# sourceMappingURL=vectorEncoder.js.map","import { addInfoData } from \"./utils/addInfoData.js\";\nimport { getBestFactor } from \"./utils/getBestFactor.js\";\nimport { peakTableCreator } from \"./utils/peakTableCreator.js\";\nimport { xyDataCreator } from \"./utils/xyDataCreator.js\";\n/**\n * Create a jcamp\n * @param data - object of array\n * @param - - [options={meta:{},info:{}} - metadata object\n * @param options\n * @returns JCAMP of the input\n */\nexport function fromJSON(data, options = {}) {\n    const { meta = {}, info = {}, xyEncoding } = options;\n    const { title = '', owner = '', origin = '', dataType = '', xUnits = '', yUnits = '', ...resultInfo } = info;\n    let { xFactor, yFactor } = info;\n    data = { x: data.x, y: data.y };\n    let header = `##TITLE=${title}\n##JCAMP-DX=4.24\n##DATA TYPE=${dataType}\n##ORIGIN=${origin}\n##OWNER=${owner}\n##XUNITS=${xUnits}\n##YUNITS=${yUnits}\\n`;\n    header += addInfoData(resultInfo, { prefix: '##' });\n    header += addInfoData(meta);\n    // we leave the header and utf8 fonts ${header.replace(/[^\\t\\n\\x20-\\x7F]/g, '')\n    if (xyEncoding) {\n        xFactor = getBestFactor(data.x, { factor: xFactor });\n        yFactor = getBestFactor(data.y, { factor: yFactor });\n        return `${header}##NPOINTS=${data.x.length}\n${xyDataCreator(data, { info: { xFactor, yFactor }, xyEncoding }).join('\\n')}\n##END=`;\n    }\n    if (xFactor === undefined)\n        xFactor = 1;\n    if (yFactor === undefined)\n        yFactor = 1;\n    if (xFactor !== 1) {\n        data.x = data.x.map((value) => value / xFactor);\n    }\n    if (yFactor !== 1) {\n        data.y = data.y.map((value) => value / yFactor);\n    }\n    return `${header}##NPOINTS=${data.x.length}\n${peakTableCreator(data, { info: { xFactor, yFactor } }).join('\\n')}\n##END=`;\n}\n//# sourceMappingURL=fromJSON.js.map","import { rescaleAndEnsureInteger } from \"./rescaleAndEnsureInteger.js\";\nimport { vectorEncoder } from \"./vectorEncoder.js\";\nexport function xyDataCreator(data, options = {}) {\n    const { xyEncoding = 'DIF' } = options;\n    const { xFactor = 1, yFactor = 1 } = options.info || {};\n    const firstX = data.x[0];\n    const lastX = data.x.at(-1);\n    const firstY = data.y[0];\n    const lastY = data.y.at(-1);\n    const nbPoints = data.x.length;\n    const deltaX = (lastX - firstX) / (nbPoints - 1);\n    const lines = [\n        `##FIRSTX=${firstX}`,\n        `##LASTX=${lastX}`,\n        `##FIRSTY=${firstY}`,\n        `##LASTY=${lastY}`,\n        `##DELTAX=${deltaX}`,\n        `##XFACTOR=${xFactor}`,\n        `##YFACTOR=${yFactor}`,\n        '##XYDATA=(X++(Y..Y))',\n    ];\n    const line = vectorEncoder(rescaleAndEnsureInteger(data.y, yFactor), firstX / xFactor, deltaX / xFactor, xyEncoding);\n    if (line)\n        lines.push(line);\n    return lines;\n}\n//# sourceMappingURL=xyDataCreator.js.map","import { getNumber } from \"./getNumber.js\";\nexport function peakTableCreator(data, options = {}) {\n    const { xFactor = 1, yFactor = 1 } = options.info || {};\n    let firstX = Infinity;\n    let lastX = -Infinity;\n    let firstY = Infinity;\n    let lastY = -Infinity;\n    const lines = [];\n    for (let i = 0; i < data.x.length; i++) {\n        const x = data.x[i];\n        const y = data.y[i];\n        if (firstX > x) {\n            firstX = x;\n        }\n        if (lastX < x) {\n            lastX = x;\n        }\n        if (firstY > y) {\n            firstY = y;\n        }\n        if (lastY < y) {\n            lastY = y;\n        }\n    }\n    lines.push(`##FIRSTX=${firstX}`, `##LASTX=${lastX}`, `##FIRSTY=${firstY}`, `##LASTY=${lastY}`, `##XFACTOR=${xFactor}`, `##YFACTOR=${yFactor}`, '##PEAK TABLE=(XY..XY)');\n    for (let i = 0; i < data.x.length; i++) {\n        lines.push(`${getNumber(data.x[i], xFactor)} ${getNumber(data.y[i], yFactor)}`);\n    }\n    return lines;\n}\n//# sourceMappingURL=peakTableCreator.js.map","import creatorNtuples from \"./creatorNtuples.js\";\nimport { fromJSON } from \"./fromJSON.js\";\nimport { checkNumberOrArray } from \"./utils/checkNumberOrArray.js\";\n/**\n * Create a jcamp from variables\n * @param variables\n * @param options\n */\nexport function fromVariables(\n/**\n * object of variables\n */\nvariables, options = {}) {\n    const { info = {}, meta = {}, forceNtuples = false } = options;\n    const jcampOptions = {\n        info,\n        meta,\n    };\n    const keys = Object.keys(variables).map((key) => key.toLowerCase());\n    if (!forceNtuples && keys.length === 2) {\n        const x = variables.x;\n        const xLabel = x.label || 'x';\n        if (variables.x.units) {\n            if (xLabel.includes(variables.x.units)) {\n                jcampOptions.info.xUnits = xLabel;\n            }\n            else {\n                jcampOptions.info.xUnits = `${xLabel} (${variables.x.units})`;\n            }\n        }\n        else {\n            jcampOptions.info.xUnits = xLabel;\n        }\n        const y = variables.y;\n        const yLabel = y.label || 'y';\n        if (variables.y.units) {\n            if (yLabel.includes(variables.y.units)) {\n                jcampOptions.info.xUnits = yLabel;\n            }\n            else {\n                jcampOptions.info.yUnits = `${yLabel} (${variables.y.units})`;\n            }\n        }\n        else {\n            jcampOptions.info.yUnits = yLabel;\n        }\n        const xData = variables.x.data;\n        const yData = variables.y.data;\n        checkNumberOrArray(xData);\n        checkNumberOrArray(yData);\n        return fromJSON({ x: xData, y: yData }, jcampOptions);\n    }\n    return creatorNtuples(variables, options);\n}\n//# sourceMappingURL=fromVariables.js.map","import { addInfoData } from \"./utils/addInfoData.js\";\nimport { getExtremeValues } from \"./utils/getExtremeValues.js\";\n/**\n * Parse from a xyxy data array\n * @param variables - Variables to convert to jcamp\n * @param [options={}] - options that allows to add meta data in the jcamp\n * @returns JCAMP-DX text file corresponding to the variables\n */\nexport default function creatorNtuples(variables, options) {\n    const { meta = {}, info = {} } = options;\n    const { title = '', owner = '', origin = '', dataType = '', ...resultInfo } = info;\n    const symbol = [];\n    const variableName = [];\n    const variableType = [];\n    const variableDim = [];\n    const units = [];\n    const first = [];\n    const last = [];\n    const min = [];\n    const max = [];\n    const keys = Object.keys(variables);\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        const variable = variables[key];\n        if (!variable)\n            continue;\n        const name = variable?.label.replace(/ *\\[.*/, '');\n        const unit = variable?.label.replace(/.*\\[(?<units>.*)\\].*/, '$<units>');\n        const { firstLast, minMax } = getExtremeValues(variable.data);\n        symbol.push(variable.symbol || key);\n        variableName.push(name || key);\n        variableDim.push(variable.data.length);\n        first.push(firstLast.first);\n        last.push(firstLast.last);\n        max.push(minMax.max);\n        min.push(minMax.min);\n        if (variable.isDependent !== undefined) {\n            variableType.push(variable.isDependent ? 'DEPENDENT' : 'INDEPENDENT');\n        }\n        else {\n            variableType.push(variable.isDependent !== undefined\n                ? !variable.isDependent\n                : i === 0\n                    ? 'INDEPENDENT'\n                    : 'DEPENDENT');\n        }\n        units.push(variable.units || unit || '');\n    }\n    let header = `##TITLE=${title}\n##JCAMP-DX=6.00\n##DATA TYPE=${dataType}\n##DATA CLASS= NTUPLES\n##ORIGIN=${origin}\n##OWNER=${owner}\\n`;\n    header += addInfoData(resultInfo, { prefix: '##' });\n    header += addInfoData(meta);\n    header += `##NTUPLES= ${dataType}\n##VAR_NAME=  ${variableName.join(',')}\n##SYMBOL=    ${symbol.join(',')}\n##VAR_TYPE=  ${variableType.join(',')}\n##VAR_DIM=   ${variableDim.join(',')}\n##UNITS=     ${units.join(',')}\n##FIRST=     ${first.join(',')}\n##LAST=      ${last.join(',')}\n##MIN=       ${min.join(',')}\n##MAX=       ${max.join(',')}\n##PAGE= N=1\\n`;\n    header += `##DATA TABLE= (${symbol.join('')}..${symbol.join('')}), PEAKS\\n`;\n    for (let i = 0; i < variables.x.data.length; i++) {\n        const point = [];\n        for (const key of keys) {\n            const variable = variables[key];\n            if (!variable)\n                continue;\n            point.push(variable.data[i]);\n        }\n        header += `${point.join('\\t')}\\n`;\n    }\n    header += `##END NTUPLES= ${dataType}\\n`;\n    header += '##END=\\n##END=';\n    return header;\n}\n//# sourceMappingURL=creatorNtuples.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * It returns an element if the input is an array otherwise it returns the input.\n * @param data - one list or single value\n * @param index - index of the desired element, if the index is out of the boundaries it throws an error.\n * @returns\n */\nexport function getOneIfArray(data, index = 0) {\n    if (isAnyArray(data)) {\n        const value = data.at(index);\n        if (value !== undefined) {\n            return value;\n        }\n        throw new RangeError('An array with a index out of boundaries');\n    }\n    return data;\n}\n//# sourceMappingURL=getOneIfArray.js.map","import { xMultiply } from 'ml-spectra-processing/x';\nimport { getOneIfArray } from \"./getOneIfArray.js\";\nimport { addInfoData } from \"./utils/addInfoData.js\";\nimport { checkNumberOrArray } from \"./utils/checkNumberOrArray.js\";\nimport { getBestFactor } from \"./utils/getBestFactor.js\";\nimport { getExtremeValues } from \"./utils/getExtremeValues.js\";\nimport { rescaleAndEnsureInteger } from \"./utils/rescaleAndEnsureInteger.js\";\nimport { vectorEncoder } from \"./utils/vectorEncoder.js\";\nconst ntuplesKeys = ['r', 'i'];\nfunction isNTuplesData(variables) {\n    return 'r' in variables && 'i' in variables;\n}\nfunction isRealData(variables) {\n    return 'r' in variables && !('i' in variables);\n}\n/**\n * Create a jcamp of 1D NMR data by variables x and y or x, r, i\n * @param variables - Variables to convert to jcamp\n * @param [options={}] - options that allows to add meta data in the jcamp\n * @returns JCAMP-DX text file corresponding to the variables\n */\nexport function from1DNMRVariables(variables, options) {\n    const { info: infoInput = {}, meta: currentMeta = {}, xyEncoding, nmrInfo, } = options;\n    const { isFid, title, frequencyOffset, decim, dspfvs, nucleus, originFrequency: originFreq, baseFrequency: baseFreq, spectralWidth: nmrSpectralWidth, solvent, owner: nmrOwner, dataType: nmrDataType, dataClass = variables.i ? 'NTUPLES' : 'XYDATA', scaleFactor, digitalFilter, ...currentInfo } = nmrInfo;\n    const baseFrequency = getOneIfArray(baseFreq || originFreq);\n    const originFrequency = getOneIfArray(originFreq || infoInput['.OBSERVE FREQUENCY']);\n    if (!originFrequency) {\n        throw new Error('originFrequency is mandatory into the info object for nmr data');\n    }\n    const xVariable = variables.x;\n    const x = xVariable.data.slice();\n    const xData = isFid ? x : xMultiply(x, originFrequency);\n    // --- Extracted: Metadata construction ---\n    const newMeta = constructMeta(xData, isFid, nmrSpectralWidth, baseFrequency, originFrequency, digitalFilter, decim, dspfvs, currentMeta, variables);\n    const meta = { ...currentInfo, ...currentMeta, ...newMeta };\n    // --- Extracted: Scaling logic ---\n    applyScaling(variables, scaleFactor, meta);\n    // --- Extracted: Info construction ---\n    const newInfo = constructInfo(isFid, xData, dataClass, solvent, nmrSpectralWidth, frequencyOffset, baseFrequency, title, originFrequency, nucleus, nmrDataType, nmrOwner);\n    const info = { ...infoInput, ...newInfo };\n    // --- Extracted: Header construction ---\n    const header = constructHeader(info, meta);\n    const nbPoints = xData.length;\n    const firstX = xData[0];\n    const secondX = xData[1];\n    const spectralWidth = Math.abs(xData[nbPoints - 1] - firstX);\n    const firstPoint = firstX > secondX ? spectralWidth : 0;\n    const lastPoint = firstX > secondX ? 0 : spectralWidth;\n    const symbol = ['X'];\n    const variableDim = [nbPoints];\n    const units = [xVariable.units ?? (isFid ? 'Time' : 'Hz')];\n    const variableType = ['INDEPENDENT'];\n    const variableForm = ['AFFN'];\n    const factor = 'factor' in options\n        ? { ...options.factor }\n        : {};\n    const factorArray = [spectralWidth / (nbPoints - 1)];\n    const variableName = [xVariable.label.replace(/ *\\[.*/, '') || 'X'];\n    const first = [firstPoint];\n    const last = [lastPoint];\n    const max = [Math.max(lastPoint, firstPoint)];\n    const min = [Math.min(lastPoint, firstPoint)];\n    for (const key of ntuplesKeys) {\n        const variable = variables[key];\n        if (!variable) {\n            if (key !== 'i') {\n                throw new Error(`variable ${key} is mandatory in real/imaginary data`);\n            }\n            continue;\n        }\n        const name = variable?.label.replace(/ *\\[.*/, '');\n        const { firstLast, minMax } = getExtremeValues(variable.data);\n        factor[key] = getBestFactor(variable.data, {\n            factor: factor[key],\n            minMax,\n        });\n        const currentFactor = factor[key];\n        factorArray.push(currentFactor || 1);\n        symbol.push(variable.symbol || (key === 'r' ? 'R' : 'I'));\n        variableName.push(name || key);\n        variableDim.push(variable.data.length);\n        variableForm.push('ASDF');\n        first.push(firstLast.first);\n        last.push(firstLast.last);\n        max.push(minMax.max);\n        min.push(minMax.min);\n        variableType.push('DEPENDENT');\n        units.push(variable.units ?? 'Arbitrary');\n    }\n    return isNTuplesData(variables)\n        ? addNtuplesHeader(header, variables, {\n            symbol,\n            varName: variableName,\n            varDim: variableDim,\n            varForm: variableForm,\n            first,\n            last,\n            min,\n            max,\n            units,\n            factor,\n            varType: variableType,\n            factorArray,\n        }, nmrDataType)\n        : isRealData(variables)\n            ? addRealData(header, {\n                xData,\n                yData: variables.r.data,\n                xyEncoding,\n                info: {\n                    XUNITS: 'HZ',\n                    YUNITS: units[1],\n                    XFACTOR: factorArray[0],\n                    YFACTOR: factorArray[1],\n                    DELTAX: xData[1] - xData[0],\n                    FIRSTX: first[0],\n                    FIRSTY: first[1],\n                    LASTX: last[0],\n                    MAXY: max[1],\n                    MINY: min[1],\n                    NPOINTS: xData.length,\n                    XYDATA: '(X++(Y..Y))',\n                },\n            })\n            : header;\n}\nfunction addNtuplesHeader(header, variables, inputs, dataType = '') {\n    const { symbol, varName, varDim, first, last, min, max, units, varType, varForm, factorArray, xyEncoding, factor, } = inputs;\n    header += `##NTUPLES= ${dataType}\n##VAR_NAME=  ${varName.join(',')}\n##SYMBOL=    ${symbol.join(',')}\n##VAR_TYPE=  ${varType.join(',')}\n##VAR_FORM=  ${varForm.join(',')}\n##VAR_DIM=   ${varDim.join(',')}\n##UNITS=     ${units.join(',')}\n##FACTOR=    ${factorArray.join(',')}\n##FIRST=     ${first.join(',')}\n##LAST=      ${last.join(',')}\n##MIN=       ${min.join(',')}\n##MAX=       ${max.join(',')}\\n`;\n    for (const key of ['r', 'i']) {\n        const variable = variables[key];\n        if (!variable)\n            continue;\n        checkNumberOrArray(variable.data);\n        header += `##PAGE= N=${key === 'r' ? 1 : 2}\\n`;\n        header += `##DATA TABLE= (X++(${key === 'r' ? 'R..R' : 'I..I'})), XYDATA\\n`;\n        header += vectorEncoder(rescaleAndEnsureInteger(variable.data, factor[key]), first[0] > last[0] ? varDim[0] : 0, first[0] > last[0] ? -1 : 1, xyEncoding);\n        header += '\\n';\n    }\n    header += `##END NTUPLES= ${dataType}\\n`;\n    header += '##END=';\n    return header;\n}\nfunction addRealData(header, options) {\n    const { xData, yData, info, xyEncoding } = options;\n    header += addInfoData(info, { prefix: '##' });\n    return `${header}${vectorEncoder(rescaleAndEnsureInteger(yData, info.YFACTOR), xData.length - 1, -1, xyEncoding)}\n##END=`;\n}\nfunction constructMeta(xData, isFid, nmrSpectralWidth, baseFrequency, originFrequency, digitalFilter, decim, dspfvs, currentMeta, variables) {\n    const newMeta = {\n        OFFSET: xData[0] / originFrequency,\n    };\n    maybeAdd(newMeta, 'SW', nmrSpectralWidth);\n    maybeAdd(newMeta, 'BF1', baseFrequency);\n    if (isFid) {\n        maybeAdd(newMeta, 'GRPDLY', digitalFilter);\n        maybeAdd(newMeta, 'DECIM', decim);\n        maybeAdd(newMeta, 'REVERSE', 'no');\n        maybeAdd(newMeta, 'DSPFVS', dspfvs);\n    }\n    maybeAdd(newMeta, 'SYMBOL', variables.i ? '' : currentMeta.SYMBOL);\n    return newMeta;\n}\nfunction constructInfo(isFid, xData, dataClass, solvent, nmrSpectralWidth, frequencyOffset, baseFrequency, title, originFrequency, nucleus, nmrDataType, nmrOwner) {\n    let shiftReference;\n    if (frequencyOffset && baseFrequency) {\n        const offset = frequencyOffset / baseFrequency;\n        shiftReference = offset + 0.5 * (nmrSpectralWidth ?? 0);\n    }\n    else {\n        shiftReference = xData.at(-1);\n    }\n    const newInfo = {};\n    maybeAdd(newInfo, '.SHIFT REFERENCE', `INTERNAL, ${String(solvent)}, ${isFid ? xData.length : 1}, ${shiftReference}`);\n    maybeAdd(newInfo, 'TITLE', title);\n    maybeAdd(newInfo, '.OBSERVE FREQUENCY', originFrequency);\n    maybeAdd(newInfo, '.OBSERVE NUCLEUS', getOneIfArray(nucleus));\n    maybeAdd(newInfo, 'DATATYPE', nmrDataType);\n    maybeAdd(newInfo, 'DATACLASS', dataClass);\n    maybeAdd(newInfo, '.SOLVENT', solvent);\n    maybeAdd(newInfo, 'OWNER', nmrOwner);\n    return newInfo;\n}\nfunction applyScaling(variables, scaleFactor, newMeta) {\n    const scale = 1 / (scaleFactor ?? 1);\n    if (scale === 1) {\n        return;\n    }\n    maybeAdd(newMeta, 'NC_proc', -Math.log2(scale));\n    xMultiply(variables.r?.data || [], scale, {\n        output: variables.r?.data,\n    });\n    if (variables.i) {\n        xMultiply(variables.i?.data || [], scale, {\n            output: variables.i?.data,\n        });\n    }\n}\nfunction constructHeader(info, meta) {\n    const { TITLE = '', OWNER = '', ORIGIN = '', DATATYPE = '', DATACLASS, ...resultInfo } = info;\n    let header = `##TITLE=${TITLE}\n##JCAMP-DX=6.00\n##DATA TYPE= ${DATATYPE}\n##DATA CLASS= ${DATACLASS}\n##ORIGIN=${ORIGIN}\n##OWNER=${OWNER}\\n`;\n    header += addInfoData(resultInfo, { prefix: '##' });\n    header += addInfoData(meta);\n    return header;\n}\nfunction maybeAdd(object, name, value) {\n    if (value === undefined)\n        return;\n    object[name] = getOneIfArray(value);\n}\n//# sourceMappingURL=from1DNMRVariables.js.map","import { isAnyArray } from 'is-any-array';\nimport { addInfoData } from \"./utils/addInfoData.js\";\nimport { checkMatrix } from \"./utils/checkMatrix.js\";\nimport { checkNumberOrArray } from \"./utils/checkNumberOrArray.js\";\nimport { getBestFactor } from \"./utils/getBestFactor.js\";\nimport { getBestFactorMatrix } from \"./utils/getBestFactorMatrix.js\";\nimport { getExtremeValues } from \"./utils/getExtremeValues.js\";\nimport { rescaleAndEnsureInteger } from \"./utils/rescaleAndEnsureInteger.js\";\nimport { vectorEncoder } from \"./utils/vectorEncoder.js\";\n/**\n * Create a jcamp of 2D NMR data by variables. Currently only the convertion of processed data\n * is supported. The variables x and y are the direct (F2 in Bruker) and indirect (F1 in bruker),\n * data should be in ppm scale, the z variable is the intensity (dependent)\n * @param variables\n * @param options\n */\nexport function from2DNMRVariables(variables, options) {\n    const { nmrInfo, info = {}, meta = {}, xyEncoding = 'DIFDUP' } = options;\n    const factor = 'factor' in options\n        ? { ...options.factor }\n        : {};\n    const { title = '', owner = '', origin = '', dataType = 'NMR SPECTRUM', ...otherInfo } = nmrInfo;\n    const symbol = [];\n    const variableName = [];\n    const variableType = [];\n    const variableDim = [];\n    const units = [];\n    const first = [];\n    const last = [];\n    const min = [];\n    const max = [];\n    const factors = [];\n    const keys = ['y', 'x', 'z'];\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        const variable = variables[key];\n        if (!variable)\n            throw new Error('variables x, y and z are mandatory');\n        const name = variable?.label.replace(/ *\\[.*/, '');\n        const unit = variable?.label.replace(/.*\\[(?<units>.*)\\].*/, '$<units>');\n        const { firstLast, minMax } = getExtremeValues(variable.data);\n        if (!Object.hasOwn(factor, key)) {\n            factor[key] = calculateFactor(variable.data, minMax);\n        }\n        symbol.push(variable.symbol || key);\n        variableName.push(name || key);\n        variableDim.push(variable.data.length);\n        first.push(firstLast.first);\n        last.push(firstLast.last);\n        max.push(minMax.max);\n        min.push(minMax.min);\n        factors.push(factor[key]);\n        if (variable.isDependent !== undefined) {\n            variableType.push(variable.isDependent ? 'DEPENDENT' : 'INDEPENDENT');\n        }\n        else {\n            variableType.push(variable.isDependent !== undefined\n                ? !variable.isDependent\n                : i === 0\n                    ? 'INDEPENDENT'\n                    : 'DEPENDENT');\n        }\n        units.push(variable.units || unit || '');\n    }\n    let header = `##TITLE=${title}\n##JCAMP-DX=6.00\n##DATA TYPE=${dataType}\n##DATA CLASS= NTUPLES\n##ORIGIN=${origin}\n##OWNER=${owner}\\n`;\n    header += addInfoData(info, { prefix: '##' });\n    header += addInfoData({ ...otherInfo, ...meta });\n    let xData = variables.x.data;\n    let yData = variables.y.data;\n    checkNumberOrArray(xData);\n    checkNumberOrArray(yData);\n    checkMandatoryParameters(meta);\n    const zData = variables.z?.data || [];\n    checkMatrix(zData);\n    const { direct, indirect, dependent } = getDimensionIndices(symbol);\n    const nuc1 = String(meta.NUC1);\n    const nuc2 = String(meta.NUC2);\n    const nucleus = new Array(3);\n    nucleus[direct] = nuc1;\n    nucleus[indirect] = nuc2;\n    const sfo1 = Number(meta.SFO1);\n    const sfo2 = Number(meta.SFO2);\n    const optionsScaleAndJoin = {\n        indices: { direct, indirect },\n        sfo1,\n        sfo2,\n    };\n    header += `##NTUPLES= ${dataType}\n##VAR_NAME=  ${variableName.join(',')}\n##SYMBOL=    ${symbol.join(',')}\n##VAR_TYPE=  ${variableType.join(',')}\n##VAR_DIM=   ${variableDim.join(',')}\n##.NUCLEUS=  ${nucleus.join(',')}\n##UNITS=     ${units.join(',')}\n##FACTOR=    ${factors.join(',')}\n##FIRST=     ${scaleAndJoin(first, optionsScaleAndJoin)}\n##LAST=      ${scaleAndJoin(last, optionsScaleAndJoin)}\n##MIN=       ${scaleAndJoin(min, optionsScaleAndJoin)}\n##MAX=       ${scaleAndJoin(max, optionsScaleAndJoin)}\\n`;\n    header += `##VAR_FORM= AFFN, AFFN, ASDF\\n`;\n    header += '##NUM DIM= 2\\n';\n    if (keys[direct] !== 'x') {\n        [yData, xData] = [xData, yData];\n    }\n    const directSymbol = symbol[direct].toUpperCase();\n    const indirectSymbol = symbol[indirect].toUpperCase();\n    const firstY = yData[0] * sfo2;\n    const lastY = yData.at(-1) * sfo2;\n    const firstX = xData[0];\n    const lastX = xData.at(-1);\n    const deltaX = (lastX - firstX) / (xData.length - 1);\n    const deltaY = (lastY - firstY) / (yData.length - 1);\n    const firstData = new Float64Array(3);\n    firstData[direct] = firstX * sfo1;\n    firstData[indirect] = firstY;\n    const yFactor = factor.y || 1;\n    const xFactor = factor.x || 1;\n    const zFactor = factor.z || 1;\n    for (let index = 0; index < zData.length; index++) {\n        const row = zData[index];\n        firstData[dependent] = row[0];\n        header += `##PAGE= ${indirectSymbol}=${(firstY + deltaY * index) / yFactor}\\n`;\n        header += `##FIRST=  ${firstData.join(',')}\\n`;\n        header += `##DATA TABLE= (${directSymbol}++(Y..Y)), PROFILE\\n`;\n        header += vectorEncoder(rescaleAndEnsureInteger(row, zFactor), firstX / xFactor, deltaX / xFactor, xyEncoding);\n        header += '\\n';\n    }\n    return header;\n}\nfunction scaleAndJoin(variable, options) {\n    const { sfo1, sfo2 } = options;\n    const { direct, indirect } = options.indices;\n    const copy = variable.slice();\n    copy[direct] = copy[direct] * sfo1;\n    copy[indirect] = copy[indirect] * sfo2;\n    return copy.join(',');\n}\nfunction getDimensionIndices(entry) {\n    const symbol = entry.map((item) => item.toUpperCase());\n    const direct = symbol.includes('F2')\n        ? symbol.indexOf('F2')\n        : symbol.indexOf('T2');\n    const indirect = symbol.includes('F1')\n        ? symbol.indexOf('F1')\n        : symbol.indexOf('T1');\n    if (direct === -1 || indirect === -1) {\n        throw new Error('F2/T2 and F1/T1 symbol should be defined for nD NMR SPECTRUM');\n    }\n    return { direct, indirect, dependent: 3 - direct - indirect };\n}\nfunction checkMandatoryParameters(meta) {\n    const list = ['SFO1', 'SFO2', 'NUC1', 'NUC2'];\n    for (const key of list) {\n        const value = meta[key];\n        if (!value) {\n            throw new Error(`${key} in options.meta should be defined`);\n        }\n    }\n}\nfunction calculateFactor(data, minMax) {\n    return isAnyArray(data[0])\n        ? getBestFactorMatrix(data, { minMax })\n        : getBestFactor(data, { minMax });\n}\n//# sourceMappingURL=from2DNMRVariables.js.map","import { matrixMinMaxZ } from 'ml-spectra-processing/matrix';\nimport { getFactorNumber } from \"./getFactorNumber.js\";\nexport function getBestFactorMatrix(matrix, options = {}) {\n    const { maxValue, factor, minMax } = options;\n    if (factor !== undefined) {\n        return factor;\n    }\n    // is there non integer number ?\n    let isOnlyInteger = true;\n    for (const row of matrix) {\n        for (const y of row) {\n            if (Math.round(y) !== y) {\n                isOnlyInteger = false;\n                break;\n            }\n        }\n    }\n    if (isOnlyInteger) {\n        return 1;\n    }\n    // we need to rescale the values\n    // need to find the max and min values\n    const extremeValues = minMax || matrixMinMaxZ(matrix);\n    return getFactorNumber(extremeValues, maxValue);\n}\n//# sourceMappingURL=getBestFactorMatrix.js.map"],"names":["addInfoData","data","options","keys","Object","prefix","header","key","JSON","stringify","toString","prototype","isAnyArray","value","tag","call","endsWith","includes","getOutputArray","output","length","undefined","TypeError","Float64Array","xMinMaxValues","array","input","minLength","Error","xCheck","min","max","i","xMultiply","array1","array2","isConstant","constant","array3","matrixMinMaxZ","matrix","RangeError","firstLength","matrixCheck","nbRows","nbColumns","column","row","checkMatrix","checkNumberOrArray","getExtremeValues","firstRow","firstLast","first","last","at","minMax","getFactorNumber","maxValue","factor","Math","getBestFactor","isOnlyInteger","y","round","getNumber","number","rounded","abs","Number","EPSILON","rescaleAndEnsureInteger","map","xDivide","Uint8Array","Uint16Array","buffer","newLine","pseudoDigits","vectorEncoder","firstX","intervalX","xyEncoding","fixEncoding","outputData","j","dataLength","String","ceil","squeezedDigit","squeezedEncoding","differenceEncoding","mult","index","charCount","encodedData","encodedNumber","temporary","diffData","Array","numberDiff","differenceDigit","duplicateDigit","differenceDuplicateEncoding","commaSeparatedValuesEncoding","packedEncoding","separator","number_","sqzDigits","startsWith","pseudoDigit","charAt","slice","diffDigits","dupDigits","digit","fromJSON","meta","info","title","owner","origin","dataType","xUnits","yUnits","resultInfo","xFactor","yFactor","x","lastX","firstY","lastY","deltaX","lines","line","push","xyDataCreator","join","Infinity","peakTableCreator","fromVariables","variables","forceNtuples","jcampOptions","toLowerCase","xLabel","label","units","yLabel","xData","yData","symbol","variableName","variableType","variableDim","variable","name","replace","unit","isDependent","point","creatorNtuples","getOneIfArray","ntuplesKeys","from1DNMRVariables","infoInput","currentMeta","nmrInfo","isFid","frequencyOffset","decim","dspfvs","nucleus","originFrequency","originFreq","baseFrequency","baseFreq","spectralWidth","nmrSpectralWidth","solvent","nmrOwner","nmrDataType","dataClass","scaleFactor","digitalFilter","currentInfo","xVariable","newMeta","OFFSET","maybeAdd","SYMBOL","constructMeta","scale","log2","r","applyScaling","newInfo","shiftReference","constructInfo","TITLE","OWNER","ORIGIN","DATATYPE","DATACLASS","constructHeader","nbPoints","secondX","firstPoint","lastPoint","variableForm","factorArray","currentFactor","isNTuplesData","inputs","varName","varDim","varType","varForm","addNtuplesHeader","isRealData","YFACTOR","addRealData","XUNITS","YUNITS","XFACTOR","DELTAX","FIRSTX","FIRSTY","LASTX","MAXY","MINY","NPOINTS","XYDATA","object","from2DNMRVariables","otherInfo","factors","hasOwn","calculateFactor","list","checkMandatoryParameters","zData","z","direct","indirect","dependent","entry","item","toUpperCase","indexOf","getDimensionIndices","nuc1","NUC1","nuc2","NUC2","sfo1","SFO1","sfo2","SFO2","optionsScaleAndJoin","indices","scaleAndJoin","directSymbol","indirectSymbol","deltaY","firstData","zFactor","copy","getBestFactorMatrix"],"mappings":"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","x_google_ignoreList":[1,2,3,4,5,6,7,15,16]}