{"version":3,"file":"xy-parser.min.js","sources":["../node_modules/ensure-string/lib-esm/index.js","../node_modules/isutf8/dist/index.esm.js","../node_modules/is-any-array/lib-esm/index.js","../node_modules/ml-spectra-processing/lib-esm/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xMaxValue.js","../node_modules/ml-spectra-processing/lib-esm/x/xCheck.js","../node_modules/ml-spectra-processing/lib-esm/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xIsMonotonic.js","../node_modules/ml-spectra-processing/lib-esm/xy/xyUniqueX.js","../node_modules/ml-spectra-processing/lib-esm/xy/xyCheck.js","../node_modules/ml-spectra-processing/lib-esm/xy/xySortX.js","../lib-esm/parse.js","../lib-esm/index.js"],"sourcesContent":["import isutf8 from 'isutf8';\n/**\n * Ensure that the data is string. If it is an ArrayBuffer it will be converted to string using TextDecoder.\n * @param blob\n * @param options\n * @returns\n */\nexport function ensureString(blob, options = {}) {\n    if (typeof blob === 'string') {\n        return blob;\n    }\n    if (ArrayBuffer.isView(blob) || blob instanceof ArrayBuffer) {\n        const { encoding = guessEncoding(blob) } = options;\n        const decoder = new TextDecoder(encoding);\n        return decoder.decode(blob);\n    }\n    throw new TypeError(`blob must be a string, ArrayBuffer or ArrayBufferView`);\n}\nfunction guessEncoding(blob) {\n    const uint8 = ArrayBuffer.isView(blob)\n        ? new Uint8Array(blob.buffer, blob.byteOffset, blob.byteLength)\n        : new Uint8Array(blob);\n    if (uint8.length >= 2) {\n        if (uint8[0] === 0xfe && uint8[1] === 0xff) {\n            return 'utf-16be';\n        }\n        if (uint8[0] === 0xff && uint8[1] === 0xfe) {\n            return 'utf-16le';\n        }\n    }\n    //@ts-expect-error an ArrayBuffer is also ok\n    if (!isutf8(blob))\n        return 'latin1';\n    return 'utf-8';\n}\n//# sourceMappingURL=index.js.map","/*\n    https://tools.ietf.org/html/rfc3629\n\n    UTF8-char = UTF8-1 / UTF8-2 / UTF8-3 / UTF8-4\n\n    UTF8-1    = %x00-7F\n\n    UTF8-2    = %xC2-DF UTF8-tail\n\n    UTF8-3    = %xE0 %xA0-BF UTF8-tail\n                %xE1-EC 2( UTF8-tail )\n                %xED %x80-9F UTF8-tail\n                %xEE-EF 2( UTF8-tail )\n\n    UTF8-4    = %xF0 %x90-BF 2( UTF8-tail )\n                %xF1-F3 3( UTF8-tail )\n                %xF4 %x80-8F 2( UTF8-tail )\n\n    UTF8-tail = %x80-BF\n*/\n/**\n * Check if a Node.js Buffer or Uint8Array is UTF-8.\n */\nfunction isUtf8(buf) {\n    if (!buf) {\n        return false;\n    }\n    var i = 0;\n    var len = buf.length;\n    while (i < len) {\n        // UTF8-1 = %x00-7F\n        if (buf[i] <= 0x7F) {\n            i++;\n            continue;\n        }\n        // UTF8-2 = %xC2-DF UTF8-tail\n        if (buf[i] >= 0xC2 && buf[i] <= 0xDF) {\n            // if(buf[i + 1] >= 0x80 && buf[i + 1] <= 0xBF) {\n            if (buf[i + 1] >> 6 === 2) {\n                i += 2;\n                continue;\n            }\n            else {\n                return false;\n            }\n        }\n        // UTF8-3 = %xE0 %xA0-BF UTF8-tail\n        // UTF8-3 = %xED %x80-9F UTF8-tail\n        if (((buf[i] === 0xE0 && buf[i + 1] >= 0xA0 && buf[i + 1] <= 0xBF) ||\n            (buf[i] === 0xED && buf[i + 1] >= 0x80 && buf[i + 1] <= 0x9F)) && buf[i + 2] >> 6 === 2) {\n            i += 3;\n            continue;\n        }\n        // UTF8-3 = %xE1-EC 2( UTF8-tail )\n        // UTF8-3 = %xEE-EF 2( UTF8-tail )\n        if (((buf[i] >= 0xE1 && buf[i] <= 0xEC) ||\n            (buf[i] >= 0xEE && buf[i] <= 0xEF)) &&\n            buf[i + 1] >> 6 === 2 &&\n            buf[i + 2] >> 6 === 2) {\n            i += 3;\n            continue;\n        }\n        // UTF8-4 = %xF0 %x90-BF 2( UTF8-tail )\n        //          %xF1-F3 3( UTF8-tail )\n        //          %xF4 %x80-8F 2( UTF8-tail )\n        if (((buf[i] === 0xF0 && buf[i + 1] >= 0x90 && buf[i + 1] <= 0xBF) ||\n            (buf[i] >= 0xF1 && buf[i] <= 0xF3 && buf[i + 1] >> 6 === 2) ||\n            (buf[i] === 0xF4 && buf[i + 1] >= 0x80 && buf[i + 1] <= 0x8F)) &&\n            buf[i + 2] >> 6 === 2 &&\n            buf[i + 3] >> 6 === 2) {\n            i += 4;\n            continue;\n        }\n        return false;\n    }\n    return true;\n}\n\nexport { isUtf8 as default };\n","// eslint-disable-next-line @typescript-eslint/unbound-method\nconst toString = Object.prototype.toString;\n/**\n * Checks if an object is an instance of an Array (array or typed array, except those that contain bigint values).\n *\n * @param value - Object to check.\n * @returns True if the object is an array or a typed array.\n */\nexport function isAnyArray(value) {\n    const tag = toString.call(value);\n    return tag.endsWith('Array]') && !tag.includes('Big');\n}\n//# sourceMappingURL=index.js.map","/**\n * Returns the closest index of a `target`\n *\n * @param array - array of numbers\n * @param target - target\n * @returns - closest index\n */\nexport function xFindClosestIndex(array, target, options = {}) {\n    const { sorted = true } = options;\n    if (sorted) {\n        let low = 0;\n        let high = array.length - 1;\n        let middle = 0;\n        while (high - low > 1) {\n            middle = low + ((high - low) >> 1);\n            if (array[middle] < target) {\n                low = middle;\n            }\n            else if (array[middle] > target) {\n                high = middle;\n            }\n            else {\n                return middle;\n            }\n        }\n        if (low < array.length - 1) {\n            if (Math.abs(target - array[low]) < Math.abs(array[low + 1] - target)) {\n                return low;\n            }\n            else {\n                return low + 1;\n            }\n        }\n        else {\n            return low;\n        }\n    }\n    else {\n        let index = 0;\n        let diff = Number.POSITIVE_INFINITY;\n        for (let i = 0; i < array.length; i++) {\n            const currentDiff = Math.abs(array[i] - target);\n            if (currentDiff < diff) {\n                diff = currentDiff;\n                index = i;\n            }\n        }\n        return index;\n    }\n}\n//# sourceMappingURL=xFindClosestIndex.js.map","import { xCheck } from './xCheck';\nimport { xGetFromToIndex } from './xGetFromToIndex';\n/**\n * Computes the maximal value of an array of values\n *\n * @param array - array of numbers\n * @param options - options\n */\nexport function xMaxValue(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let maxValue = array[fromIndex];\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n        if (array[i] > maxValue) {\n            maxValue = array[i];\n        }\n    }\n    return maxValue;\n}\n//# sourceMappingURL=xMaxValue.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * Checks if input is of type array\n *\n * @param input - input\n */\nexport function xCheck(input, options = {}) {\n    const { minLength } = options;\n    if (!isAnyArray(input)) {\n        throw new TypeError('input must be an array');\n    }\n    if (input.length === 0) {\n        throw new TypeError('input must not be empty');\n    }\n    //@ts-expect-error we already checked that input is an array\n    if (minLength && input.length < minLength) {\n        throw new Error(`input must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xCheck.js.map","import { xFindClosestIndex } from './xFindClosestIndex';\n/**\n * Returns an object with {fromIndex, toIndex} for a specific from / to\n *\n * @param x - array of numbers\n * @param options - Options\n */\nexport function xGetFromToIndex(x, options = {}) {\n    let { fromIndex, toIndex, from, to } = options;\n    if (fromIndex === undefined) {\n        if (from !== undefined) {\n            fromIndex = xFindClosestIndex(x, from);\n        }\n        else {\n            fromIndex = 0;\n        }\n    }\n    if (toIndex === undefined) {\n        if (to !== undefined) {\n            toIndex = xFindClosestIndex(x, to);\n        }\n        else {\n            toIndex = x.length - 1;\n        }\n    }\n    if (fromIndex < 0)\n        fromIndex = 0;\n    if (toIndex < 0)\n        toIndex = 0;\n    if (fromIndex >= x.length)\n        fromIndex = x.length - 1;\n    if (toIndex >= x.length)\n        toIndex = x.length - 1;\n    if (fromIndex > toIndex)\n        [fromIndex, toIndex] = [toIndex, fromIndex];\n    return { fromIndex, toIndex };\n}\n//# sourceMappingURL=xGetFromToIndex.js.map","/**\n * Returns true if x is monotone\n *\n * @param array - array of numbers\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[array.length - 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 { xyCheck } from './xyCheck';\nimport { xySortX } from './xySortX';\n/**\n * Ensure x values are unique\n *\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    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(`xyUniqueX: unknown algorithm: ${algorithm}`);\n    }\n}\n/**\n * Average.\n *\n * @param data - Input.\n * @returns Result.\n */\nfunction average(data) {\n    let x = [];\n    let 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[data.x.length - 1]);\n    y.push(cumulativeY / divider);\n    return { x, y };\n}\n/**\n * Sum.\n *\n * @param data - Input.\n * @returns Result.\n */\nfunction sum(data) {\n    let x = [];\n    let 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[data.x.length - 1]);\n    y.push(cumulativeY);\n    return { x, y };\n}\n//# sourceMappingURL=xyUniqueX.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * Throw an error in no an object of x,y arrays\n *\n * @param data - array of points {x,y,z}\n */\nexport function xyCheck(data, options = {}) {\n    const { minLength } = options;\n    if (typeof data !== 'object' || !isAnyArray(data.x) || !isAnyArray(data.y)) {\n        throw new Error('Data must be an object of x and y arrays');\n    }\n    if (data.x.length !== data.y.length) {\n        throw new Error('The x and y arrays must have the same length');\n    }\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 { xIsMonotonic } from '../x/xIsMonotonic';\n/**\n * This function performs a quick sort of the x array while transforming the y array to preserve the coordinates.\n *\n * @param data - Object that contains property x (Array) and y (Array)\n */\nexport function xySortX(data) {\n    const { x, y } = data;\n    if (xIsMonotonic(x) && x.length > 1) {\n        if (x[0] < x[1]) {\n            return {\n                x: Float64Array.from(x),\n                y: Float64Array.from(y),\n            };\n        }\n        else {\n            return {\n                x: Float64Array.from(x).reverse(),\n                y: Float64Array.from(y).reverse(),\n            };\n        }\n    }\n    let xyObject = x\n        .map((val, index) => ({\n        x: val,\n        y: y[index],\n    }))\n        .sort((a, b) => a.x - b.x);\n    let response = {\n        x: new Float64Array(x.length),\n        y: new Float64Array(y.length),\n    };\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 { ensureString } from 'ensure-string';\nimport { xyUniqueX, xMaxValue, xIsMonotonic } from 'ml-spectra-processing';\n/**\n * General internal parsing function\n *\n * @param text - Csv or tsv strings.\n * @param options - Parsing options\n * @returns parsed text file with column information\n */\nexport function parse(text, options = {}) {\n    let { rescale = false, uniqueX = false, xColumn = 0, yColumn = 1, bestGuess = false, \n    //@ts-expect-error old library used this property and we want to throw an error so that people are forced to migrate\n    keepInfo, numberColumns = Number.MAX_SAFE_INTEGER, maxNumberColumns = Number.MAX_SAFE_INTEGER, minNumberColumns = 2, } = options;\n    if (keepInfo !== undefined) {\n        throw new Error('keepInfo has been deprecated, pelase use the new method parseXYAndKeepInfo');\n    }\n    text = ensureString(text);\n    maxNumberColumns = Math.max(maxNumberColumns, xColumn + 1, yColumn + 1);\n    minNumberColumns = Math.max(xColumn + 1, yColumn + 1, minNumberColumns);\n    let lines = text.split(/[\\r\\n]+/);\n    let matrix = [];\n    let info = [];\n    let position = 0;\n    lines.forEach((line) => {\n        line = line.trim();\n        // we will consider only lines that contains only numbers\n        if (/[0-9]+/.test(line) && /^[0-9eE,;. \\t+-]+$/.test(line)) {\n            let fields = line.split(/,[; \\t]+|[; \\t]+/);\n            if (fields.length === 1) {\n                fields = line.split(/[,; \\t]+/);\n            }\n            if (fields &&\n                fields.length >= minNumberColumns && // we filter lines that have not enough or too many columns\n                fields.length <= maxNumberColumns) {\n                matrix.push(fields.map((value) => parseFloat(value.replace(',', '.'))));\n                position++;\n            }\n        }\n        else if (line) {\n            info.push({ position, value: line });\n        }\n    });\n    if (bestGuess) {\n        if (matrix[0] &&\n            matrix[0].length === 3 &&\n            options.xColumn === undefined &&\n            options.yColumn === undefined) {\n            // is the first column a seuqnetial number ?\n            let skipFirstColumn = true;\n            for (let i = 0; i < matrix.length - 1; i++) {\n                if (Math.abs(matrix[i][0] - matrix[i + 1][0]) !== 1) {\n                    skipFirstColumn = false;\n                }\n            }\n            if (skipFirstColumn) {\n                xColumn = 1;\n                yColumn = 2;\n            }\n        }\n        if (matrix[0] && matrix[0].length > 3) {\n            const xs = [];\n            for (let row of matrix) {\n                for (let i = xColumn; i < row.length; i += 2) {\n                    xs.push(row[i]);\n                }\n            }\n            if (xIsMonotonic(xs)) {\n                numberColumns = 2;\n            }\n        }\n    }\n    if (numberColumns) {\n        const newMatrix = [];\n        for (const row of matrix) {\n            for (let i = 0; i < row.length; i += numberColumns) {\n                newMatrix.push(row.slice(i, i + numberColumns));\n            }\n        }\n        matrix = newMatrix;\n    }\n    let result = {\n        x: matrix.map((row) => row[xColumn]),\n        y: matrix.map((row) => row[yColumn]),\n    };\n    if (uniqueX) {\n        result = xyUniqueX(result, { algorithm: 'sum' });\n    }\n    if (rescale) {\n        let maxY = xMaxValue(result.y);\n        for (let i = 0; i < result.y.length; i++) {\n            result.y[i] /= maxY;\n        }\n    }\n    return {\n        info,\n        data: result,\n    };\n}\n//# sourceMappingURL=parse.js.map","import { parse } from './parse';\nexport * from './ParseXYOptions';\n/**\n * Parse a text-file and convert it to an object {x:[], y:[]}\n *\n * @param text - Csv or tsv strings.\n * @param options - Parsing options\n * @returns - The parsed data\n */\nexport function parseXY(text, options = {}) {\n    return parse(text, options).data;\n}\n/**\n * Parse a text-file and returns the parsed data and information about the columns\n *\n * @param text - Csv or tsv strings.\n * @param options - Parsing options\n * @returns - The parsed data with information about the columns\n */\nexport function parseXYAndKeepInfo(text, options = {}) {\n    return parse(text, options);\n}\n//# sourceMappingURL=index.js.map"],"names":["guessEncoding","blob","uint8","ArrayBuffer","isView","Uint8Array","buffer","byteOffset","byteLength","length","buf","i","len","isutf8","toString","Object","prototype","isAnyArray","value","tag","call","endsWith","includes","xFindClosestIndex","array","target","options","arguments","undefined","sorted","low","high","middle","Math","abs","index","diff","Number","POSITIVE_INFINITY","currentDiff","xMaxValue","input","minLength","TypeError","Error","xCheck","fromIndex","toIndex","x","from","to","xGetFromToIndex","maxValue","xIsMonotonic","xyUniqueX","data","y","xyCheck","algorithm","isSorted","Float64Array","reverse","xyObject","map","val","sort","a","b","response","xySortX","cumulativeY","divider","push","average","sum","parse","text","rescale","uniqueX","xColumn","yColumn","bestGuess","keepInfo","numberColumns","MAX_SAFE_INTEGER","maxNumberColumns","minNumberColumns","encoding","TextDecoder","decode","ensureString","max","lines","split","matrix","info","position","forEach","line","trim","test","fields","parseFloat","replace","skipFirstColumn","xs","row","newMatrix","slice","result","maxY"],"mappings":"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"}