{"version":3,"file":"mgf-parser.esm.js","sources":["../node_modules/is-any-array/lib/index.js","../node_modules/ml-spectra-processing/lib/x/getOutputArray.js","../node_modules/ml-spectra-processing/lib/x/xCheck.js","../node_modules/ml-spectra-processing/lib/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib/utils/isLittleEndian.js","../node_modules/ml-spectra-processing/lib/x/utils/radixSortOrder.js","../node_modules/ml-spectra-processing/lib/x/xGetSortOrder.js","../node_modules/ml-spectra-processing/lib/x/xMaxValue.js","../node_modules/ml-spectra-processing/lib/x/xIsMonotonic.js","../node_modules/ml-spectra-processing/lib/x/xSum.js","../node_modules/ml-spectra-processing/lib/x/xNormed.js","../node_modules/ml-spectra-processing/lib/xy/xyCheck.js","../node_modules/ml-spectra-processing/lib/xy/xySortX.js","../node_modules/ml-spectra-processing/lib/xy/xyUniqueX.js","../lib/index.js"],"sourcesContent":["// 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 { 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","/**\n * Returns the closest index of a `target`\n * @param array - array of numbers.\n * @param target - target value.\n * @param options - 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","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","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","import { isLittleEndian } from \"../../utils/isLittleEndian.js\";\n// Internal helpers: not re-exported from `x/index.ts`, so they stay out of the public API.\n// The counting pass costs O(radix) whatever the length, so the digit stays narrow until the\n// array is long enough to amortize a wide one.\nconst SMALL_DIGIT_BITS = 8;\nconst LARGE_DIGIT_BITS = 16;\nconst LARGE_ARRAY_LENGTH = 1 << LARGE_DIGIT_BITS;\n/**\n * Length from which ordering through the radix beats a comparator, for a caller that has to\n * build the keys and read the values back through the order. The measured crossover is around\n * 150 values on both V8 and JavaScriptCore, whether the values come from a typed array, a\n * plain array or the x of an array of points.\n */\nexport const RADIX_ORDER_MIN_LENGTH = 1 << SMALL_DIGIT_BITS;\n/**\n * Orders the values by their full 64 bits, as an LSD radix sort.\n * @param array - the values to order.\n * @param descending - order from the largest to the smallest.\n * @returns the indices of the values, in order.\n */\nexport function radixSortOrderExact(array, descending) {\n    const values = ensureFloat64(array);\n    const length = values.length;\n    let order = new Uint32Array(length);\n    if (length < 2)\n        return order;\n    const digitBits = getDigitBits(length);\n    const radix = 1 << digitBits;\n    const digitMask = radix - 1;\n    const words = new Uint32Array(values.buffer, values.byteOffset, length * 2);\n    const flip = descending ? 0xffffffff : 0;\n    const highWord = isLittleEndian() ? 1 : 0;\n    const lowWord = 1 - highWord;\n    let keysLow = new Uint32Array(length);\n    let keysHigh = new Uint32Array(length);\n    for (let i = 0; i < length; i++) {\n        const high = words[i * 2 + highWord];\n        const low = words[i * 2 + lowWord];\n        // Monotonic unsigned key of the double: a negative flips every bit, a positive only the\n        // sign bit. Complementing that key reverses the order.\n        if ((high & 0x80000000) === 0) {\n            keysHigh[i] = high ^ 0x80000000 ^ flip;\n            keysLow[i] = low ^ flip;\n        }\n        else {\n            keysHigh[i] = ~high ^ flip;\n            keysLow[i] = ~low ^ flip;\n        }\n        order[i] = i;\n    }\n    let nextOrder = new Uint32Array(length);\n    let nextLow = new Uint32Array(length);\n    let nextHigh = new Uint32Array(length);\n    const counts = new Uint32Array(radix);\n    for (let shift = 0; shift < 64; shift += digitBits) {\n        const onHigh = shift >= 32;\n        const wordShift = onHigh ? shift - 32 : shift;\n        const keys = onHigh ? keysHigh : keysLow;\n        counts.fill(0);\n        for (let i = 0; i < length; i++) {\n            counts[(keys[i] >>> wordShift) & digitMask]++;\n        }\n        // A digit shared by every value would make this pass the identity.\n        if (counts[(keys[0] >>> wordShift) & digitMask] === length)\n            continue;\n        cumulate(counts);\n        for (let i = 0; i < length; i++) {\n            const low = keysLow[i];\n            const high = keysHigh[i];\n            const at = counts[((onHigh ? high : low) >>> wordShift) & digitMask]++;\n            nextOrder[at] = order[i];\n            nextLow[at] = low;\n            nextHigh[at] = high;\n        }\n        // A destructuring swap makes JavaScriptCore give up the typed array specialization of\n        // these variables, which costs 8x on the whole sort.\n        let swap = order;\n        order = nextOrder;\n        nextOrder = swap;\n        swap = keysLow;\n        keysLow = nextLow;\n        nextLow = swap;\n        swap = keysHigh;\n        keysHigh = nextHigh;\n        nextHigh = swap;\n    }\n    return order;\n}\n/**\n * Orders the values by the high word of each double, as an LSD radix sort. Values differing by\n * less than their 2^-20 relative resolution share a key and keep their input order.\n * @param array - the values to order.\n * @param descending - order from the largest to the smallest.\n * @returns the indices of the values, in order.\n */\nexport function radixSortOrderApproximate(array, descending) {\n    const values = ensureFloat64(array);\n    const length = values.length;\n    let order = new Uint32Array(length);\n    if (length < 2)\n        return order;\n    const digitBits = getDigitBits(length);\n    const radix = 1 << digitBits;\n    const digitMask = radix - 1;\n    const words = new Uint32Array(values.buffer, values.byteOffset, length * 2);\n    const flip = descending ? 0xffffffff : 0;\n    const highWord = isLittleEndian() ? 1 : 0;\n    let keys = new Uint32Array(length);\n    for (let i = 0; i < length; i++) {\n        const high = words[i * 2 + highWord];\n        keys[i] = ((high & 0x80000000) === 0 ? high ^ 0x80000000 : ~high) ^ flip;\n        order[i] = i;\n    }\n    let nextOrder = new Uint32Array(length);\n    let nextKeys = new Uint32Array(length);\n    const counts = new Uint32Array(radix);\n    for (let shift = 0; shift < 32; shift += digitBits) {\n        counts.fill(0);\n        for (let i = 0; i < length; i++) {\n            counts[(keys[i] >>> shift) & digitMask]++;\n        }\n        if (counts[(keys[0] >>> shift) & digitMask] === length)\n            continue;\n        cumulate(counts);\n        for (let i = 0; i < length; i++) {\n            const key = keys[i];\n            const at = counts[(key >>> shift) & digitMask]++;\n            nextOrder[at] = order[i];\n            nextKeys[at] = key;\n        }\n        // See radixSortOrderExact: a destructuring swap is 8x slower on JavaScriptCore.\n        let swap = order;\n        order = nextOrder;\n        nextOrder = swap;\n        swap = keys;\n        keys = nextKeys;\n        nextKeys = swap;\n    }\n    return order;\n}\n/**\n * Turns the counts of each digit into the position its first entry goes to.\n * @param counts - counts per digit, replaced in place by the start offsets.\n */\nfunction cumulate(counts) {\n    let start = 0;\n    for (let i = 0; i < counts.length; i++) {\n        const count = counts[i];\n        counts[i] = start;\n        start += count;\n    }\n}\n/**\n * Picks the digit width, keeping the radix no wider than the array it scans.\n * @param length - number of values to order.\n * @returns the number of bits of one digit.\n */\nfunction getDigitBits(length) {\n    return length >= LARGE_ARRAY_LENGTH ? LARGE_DIGIT_BITS : SMALL_DIGIT_BITS;\n}\n/**\n * Returns the values as a Float64Array, without copying one that already is.\n * @param array - values.\n * @returns the values, readable as doubles.\n */\nfunction ensureFloat64(array) {\n    return array instanceof Float64Array ? array : Float64Array.from(array);\n}\n//# sourceMappingURL=radixSortOrder.js.map","import { radixSortOrderExact } from \"./utils/radixSortOrder.js\";\n/**\n * Returns the indices that order the values, without moving them.\n * The sort is a radix sort over the full 64 bits of each double: it costs a fixed number of\n * linear passes instead of the n log n comparisons of `Array.prototype.sort`, and orders\n * exactly, NaN, infinities, subnormals and the two zeros included.\n * The sort is stable, so equal values keep their input order.\n * @param array - values to order.\n * @param options - options.\n * @returns the indices of the values, in order.\n */\nexport function xGetSortOrder(array, options = {}) {\n    const { descending = false } = options;\n    return radixSortOrderExact(array, descending);\n}\n//# sourceMappingURL=xGetSortOrder.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","/**\n * Returns true if x is monotonic.\n * @param array - array of numbers.\n * @returns 1 if monotonic increasing, -1 if monotonic decreasing, 0 if not monotonic.\n */\nexport function xIsMonotonic(array) {\n    if (array.length < 2) {\n        return 1;\n    }\n    if (array[0] === array[1]) {\n        // maybe a constant series\n        for (let i = 1; i < array.length - 1; i++) {\n            if (array[i] !== array[i + 1])\n                return 0;\n        }\n        return 1;\n    }\n    if (array[0] < array.at(-1)) {\n        for (let i = 0; i < array.length - 1; i++) {\n            if (array[i] >= array[i + 1])\n                return 0;\n        }\n        return 1;\n    }\n    else {\n        for (let i = 0; i < array.length - 1; i++) {\n            if (array[i] <= array[i + 1])\n                return 0;\n        }\n        return -1;\n    }\n}\n//# sourceMappingURL=xIsMonotonic.js.map","import { xCheck } from \"./xCheck.js\";\nimport { xGetFromToIndex } from \"./xGetFromToIndex.js\";\n/**\n * Calculate the sum of the values\n * @param array - object that contains property x (an ordered increasing array) and y (an array).\n * @param options - options.\n * @returns sum value on the specified range.\n */\nexport function xSum(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let sumValue = array[fromIndex];\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n        sumValue += array[i];\n    }\n    return sumValue;\n}\n//# sourceMappingURL=xSum.js.map","import { getOutputArray } from \"./getOutputArray.js\";\nimport { xCheck } from \"./xCheck.js\";\nimport { xMaxValue } from \"./xMaxValue.js\";\nimport { xSum } from \"./xSum.js\";\n/**\n * Divides the data with either the sum, the absolute sum or the maximum of the data\n * @param input - array containing values.\n * @param options - options.\n * @returns normalized data.\n */\nexport function xNormed(input, options = {}) {\n    const { algorithm = 'absolute', value = 1 } = options;\n    xCheck(input);\n    const output = getOutputArray(options.output, input.length);\n    if (input.length === 0) {\n        throw new Error('input must not be empty');\n    }\n    switch (algorithm) {\n        case 'absolute': {\n            const absoluteSumValue = absoluteSum(input) / value;\n            if (absoluteSumValue === 0) {\n                throw new Error('trying to divide by 0');\n            }\n            for (let i = 0; i < input.length; i++) {\n                output[i] = input[i] / absoluteSumValue;\n            }\n            return output;\n        }\n        case 'max': {\n            const currentMaxValue = xMaxValue(input);\n            if (currentMaxValue === 0) {\n                throw new Error('trying to divide by 0');\n            }\n            const factor = value / currentMaxValue;\n            for (let i = 0; i < input.length; i++) {\n                output[i] = input[i] * factor;\n            }\n            return output;\n        }\n        case 'sum': {\n            const sumFactor = xSum(input) / value;\n            if (sumFactor === 0) {\n                throw new Error('trying to divide by 0');\n            }\n            for (let i = 0; i < input.length; i++) {\n                output[i] = input[i] / sumFactor;\n            }\n            return output;\n        }\n        default:\n            throw new Error(`unknown algorithm: ${String(algorithm)}`);\n    }\n}\nfunction absoluteSum(input) {\n    let sumValue = 0;\n    for (let i = 0; i < input.length; i++) {\n        sumValue += Math.abs(input[i]);\n    }\n    return sumValue;\n}\n//# sourceMappingURL=xNormed.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * Verify that `data` is an object of x,y arrays.\n * Throws an error if it's not.\n * @param data - data to check.\n * @param options - options.\n * @param options.minLength - minimum required length.\n */\nexport function xyCheck(data, options = {}) {\n    const { minLength } = options;\n    if (data === null ||\n        typeof data !== 'object' ||\n        // @ts-expect-error Typechecking\n        !isAnyArray(data.x) ||\n        // @ts-expect-error Typechecking\n        !isAnyArray(data.y)) {\n        throw new Error('data must be an object of x and y arrays');\n    }\n    // @ts-expect-error Typechecking\n    if (data.x.length !== data.y.length) {\n        throw new Error('the x and y arrays must have the same length');\n    }\n    // @ts-expect-error Typechecking\n    if (minLength && data.x.length < minLength) {\n        throw new Error(`data.x must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xyCheck.js.map","import { xGetSortOrder, xIsMonotonic } from \"../x/index.js\";\nimport { RADIX_ORDER_MIN_LENGTH } from \"../x/utils/radixSortOrder.js\";\n/**\n * This function performs a quick sort of the x array while transforming the y array to preserve the coordinates.\n * @param data - object that contains property x (Array) and y (Array).\n * @returns the points, ascending by x.\n */\nexport function xySortX(data) {\n    const { x, y } = data;\n    if (xIsMonotonic(x) && x.length > 1) {\n        const floatX = Float64Array.from(x);\n        const floatY = Float64Array.from(y);\n        if (floatX.at(-1) < floatX[0]) {\n            floatX.reverse();\n            floatY.reverse();\n        }\n        return {\n            x: floatX,\n            y: floatY,\n        };\n    }\n    const response = {\n        x: new Float64Array(x.length),\n        y: new Float64Array(y.length),\n    };\n    if (x.length >= RADIX_ORDER_MIN_LENGTH) {\n        const order = xGetSortOrder(x);\n        for (let i = 0; i < order.length; i++) {\n            const at = order[i];\n            response.x[i] = x[at];\n            response.y[i] = y[at];\n        }\n        return response;\n    }\n    const xyObject = Array.from(x, (val, index) => ({\n        x: val,\n        y: y[index],\n    }));\n    xyObject.sort((a, b) => a.x - b.x);\n    for (let i = 0; i < x.length; i++) {\n        response.x[i] = xyObject[i].x;\n        response.y[i] = xyObject[i].y;\n    }\n    return response;\n}\n//# sourceMappingURL=xySortX.js.map","import { xyCheck } from \"./xyCheck.js\";\nimport { xySortX } from \"./xySortX.js\";\n/**\n * Ensure x values are unique\n * @param data - object that contains property x (Array) and y (Array).\n * @param options - object containing a property algorithm (can be 'sum' or 'average', the latter being the default value), and a property isSorted (boolean indicating if the x-array is sorted).\n */\nexport function xyUniqueX(data, options = {}) {\n    xyCheck(data);\n    if (data.x.length === 0) {\n        return { x: [], y: [] };\n    }\n    const { algorithm = 'average', isSorted = true } = options;\n    if (!isSorted) {\n        data = xySortX(data);\n    }\n    switch (algorithm) {\n        case 'average':\n            return average(data);\n        case 'sum':\n            return sum(data);\n        default:\n            throw new Error(`unknown algorithm: ${String(algorithm)}`);\n    }\n}\n/**\n * Averages duplicate x values by averaging their y values.\n * @param data - input.\n * @returns result.\n */\nfunction average(data) {\n    const x = [];\n    const y = [];\n    let cumulativeY = data.y[0];\n    let divider = 1;\n    for (let i = 1; i < data.x.length; i++) {\n        if (!(data.x[i] === data.x[i - 1])) {\n            x.push(data.x[i - 1]);\n            y.push(cumulativeY / divider);\n            cumulativeY = 0;\n            divider = 0;\n        }\n        cumulativeY += data.y[i];\n        divider++;\n    }\n    x.push(data.x.at(-1));\n    y.push(cumulativeY / divider);\n    return { x, y };\n}\n/**\n * Merges duplicate x values by summing their y values.\n * @param data - input.\n * @returns result.\n */\nfunction sum(data) {\n    const x = [];\n    const y = [];\n    let cumulativeY = data.y[0];\n    for (let i = 1; i < data.x.length; i++) {\n        if (!(data.x[i] === data.x[i - 1])) {\n            x.push(data.x[i - 1]);\n            y.push(cumulativeY);\n            cumulativeY = 0;\n        }\n        cumulativeY += data.y[i];\n    }\n    x.push(data.x.at(-1));\n    y.push(cumulativeY);\n    return { x, y };\n}\n//# sourceMappingURL=xyUniqueX.js.map","import { xNormed, xySortX, xyUniqueX } from 'ml-spectra-processing';\nconst BEGIN_REGEXP = /^BEGIN\\b\\s*(?<kind>.*)$/;\nconst END_REGEXP = /^END\\b/;\nconst COMMENT_REGEXP = /^[!#;/]/;\nconst PEAK_SEPARATOR_REGEXP = /[ \\t,;]+/;\n/**\n * Parses MGF files into a JSON. The spectrum can be delimited by ' ', '\\t', ',' or ';'.\n * Comment lines (starting with '#', ';', '!' or '/'), blank lines and the optional\n * third column of a peak line (the fragment charge) are ignored.\n * @param rawData - Input data (MGF).\n * @param options - Parsing options.\n * @returns Parsed data entries.\n */\nexport function parse(rawData, options = {}) {\n    const { recordTypes = '', uniqueX = false, normedY = false, maxY } = options;\n    if (normedY && maxY !== undefined) {\n        throw new Error('Option maxY must be undefined if normedY is true');\n    }\n    const shouldSortX = uniqueX || (options.sortX ?? false);\n    const recordTypesRegExp = new RegExp(recordTypes);\n    const lines = rawData.split(/\\r?\\n/);\n    const results = [];\n    const globalMeta = {};\n    let entry;\n    let peaks = { x: [], y: [] };\n    let shouldSkip = false;\n    for (let i = 0; i < lines.length; i++) {\n        const line = lines[i]?.trim();\n        if (!line || COMMENT_REGEXP.test(line))\n            continue;\n        const begin = BEGIN_REGEXP.exec(line);\n        if (begin) {\n            const kind = begin.groups?.kind ?? '';\n            shouldSkip = !recordTypesRegExp.test(kind);\n            entry = { data: { x: [], y: [] }, meta: { ...globalMeta }, kind };\n            peaks = { x: [], y: [] };\n            continue;\n        }\n        if (END_REGEXP.test(line)) {\n            if (entry && !shouldSkip) {\n                entry.data = treatSpectrum(peaks, {\n                    shouldSortX,\n                    uniqueX,\n                    normedY,\n                    maxY,\n                });\n                results.push(entry);\n            }\n            entry = undefined;\n            shouldSkip = false;\n            continue;\n        }\n        if (shouldSkip)\n            continue;\n        const equalPosition = line.indexOf('=');\n        if (equalPosition !== -1) {\n            const key = line.slice(0, equalPosition);\n            const value = line.slice(equalPosition + 1);\n            if (entry) {\n                entry.meta[key] = value;\n            }\n            else {\n                globalMeta[key] = value;\n            }\n            continue;\n        }\n        const fields = line.split(PEAK_SEPARATOR_REGEXP);\n        const x = Number(fields[0]);\n        const y = Number(fields[1]);\n        if (Number.isNaN(x) || Number.isNaN(y)) {\n            throw new Error(`Could not parse line number ${i + 1}`);\n        }\n        if (!entry) {\n            throw new Error(`Found fragment ion data outside of a BEGIN/END block on line number ${i + 1}`);\n        }\n        peaks.x.push(x);\n        peaks.y.push(y);\n    }\n    return results;\n}\nfunction treatSpectrum(peaks, options) {\n    const { shouldSortX, uniqueX, normedY, maxY } = options;\n    let spectrum = shouldSortX ? xySortX(peaks) : peaks;\n    if (uniqueX) {\n        spectrum = xyUniqueX(spectrum, { algorithm: 'sum' });\n    }\n    if (normedY) {\n        return { x: spectrum.x, y: xNormed(spectrum.y) };\n    }\n    if (maxY !== undefined) {\n        return {\n            x: spectrum.x,\n            y: xNormed(spectrum.y, { algorithm: 'max', value: maxY }),\n        };\n    }\n    return spectrum;\n}\n//# sourceMappingURL=index.js.map"],"names":["toString","Object","prototype","isAnyArray","value","tag","call","endsWith","includes","getOutputArray","output","length","undefined","TypeError","Float64Array","xCheck","input","options","minLength","Error","xFindClosestIndex","array","target","sorted","low","high","middle","Math","abs","index","diff","Number","POSITIVE_INFINITY","i","currentDiff","xGetFromToIndex","x","fromIndex","toIndex","from","to","LITTLE_ENDIAN","Uint8Array","Uint16Array","buffer","isLittleEndian","SMALL_DIGIT_BITS","LARGE_DIGIT_BITS","LARGE_ARRAY_LENGTH","RADIX_ORDER_MIN_LENGTH","radixSortOrderExact","descending","values","ensureFloat64","order","Uint32Array","digitBits","getDigitBits","radix","digitMask","words","byteOffset","flip","highWord","lowWord","keysLow","keysHigh","nextOrder","nextLow","nextHigh","counts","shift","onHigh","wordShift","keys","fill","cumulate","at","swap","start","count","xGetSortOrder","xMaxValue","maxValue","xIsMonotonic","xSum","sumValue","xNormed","algorithm","absoluteSumValue","absoluteSum","currentMaxValue","factor","sumFactor","String","xyCheck","data","y","xySortX","floatX","floatY","reverse","response","xyObject","Array","val","sort","a","b","xyUniqueX","isSorted","average","sum","cumulativeY","divider","push","BEGIN_REGEXP","END_REGEXP","COMMENT_REGEXP","PEAK_SEPARATOR_REGEXP","parse","rawData","recordTypes","uniqueX","normedY","maxY","shouldSortX","sortX","recordTypesRegExp","RegExp","lines","split","results","globalMeta","entry","peaks","shouldSkip","line","trim","test","begin","exec","kind","groups","meta","treatSpectrum","equalPosition","indexOf","key","slice","fields","isNaN","spectrum"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]}