{"version":3,"file":"mgf-parser.umd.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]}