{"version":3,"file":"spc-parser.min.js","sources":["../node_modules/iobuffer/lib-esm/utf8.browser.js","../node_modules/iobuffer/lib-esm/IOBuffer.js","../src/dataBlock.js","../src/utility.js","../src/logBlock.js","../src/types.js","../src/mainHeader.js","../src/index.js"],"sourcesContent":["// eslint-disable-next-line import/no-unassigned-import\r\nimport './text-encoding-polyfill';\r\nconst decoder = new TextDecoder('utf-8');\r\nexport function decode(bytes) {\r\n    return decoder.decode(bytes);\r\n}\r\nconst encoder = new TextEncoder();\r\nexport function encode(str) {\r\n    return encoder.encode(str);\r\n}\r\n//# sourceMappingURL=utf8.browser.js.map","import { decode, encode } from './utf8';\r\nconst defaultByteLength = 1024 * 8;\r\nexport class IOBuffer {\r\n    /**\r\n     * @param data - The data to construct the IOBuffer with.\r\n     * If data is a number, it will be the new buffer's length<br>\r\n     * If data is `undefined`, the buffer will be initialized with a default length of 8Kb<br>\r\n     * If data is an ArrayBuffer, SharedArrayBuffer, an ArrayBufferView (Typed Array), an IOBuffer instance,\r\n     * or a Node.js Buffer, a view will be created over the underlying ArrayBuffer.\r\n     * @param options\r\n     */\r\n    constructor(data = defaultByteLength, options = {}) {\r\n        let dataIsGiven = false;\r\n        if (typeof data === 'number') {\r\n            data = new ArrayBuffer(data);\r\n        }\r\n        else {\r\n            dataIsGiven = true;\r\n            this.lastWrittenByte = data.byteLength;\r\n        }\r\n        const offset = options.offset ? options.offset >>> 0 : 0;\r\n        const byteLength = data.byteLength - offset;\r\n        let dvOffset = offset;\r\n        if (ArrayBuffer.isView(data) || data instanceof IOBuffer) {\r\n            if (data.byteLength !== data.buffer.byteLength) {\r\n                dvOffset = data.byteOffset + offset;\r\n            }\r\n            data = data.buffer;\r\n        }\r\n        if (dataIsGiven) {\r\n            this.lastWrittenByte = byteLength;\r\n        }\r\n        else {\r\n            this.lastWrittenByte = 0;\r\n        }\r\n        this.buffer = data;\r\n        this.length = byteLength;\r\n        this.byteLength = byteLength;\r\n        this.byteOffset = dvOffset;\r\n        this.offset = 0;\r\n        this.littleEndian = true;\r\n        this._data = new DataView(this.buffer, dvOffset, byteLength);\r\n        this._mark = 0;\r\n        this._marks = [];\r\n    }\r\n    /**\r\n     * Checks if the memory allocated to the buffer is sufficient to store more\r\n     * bytes after the offset.\r\n     * @param byteLength - The needed memory in bytes.\r\n     * @returns `true` if there is sufficient space and `false` otherwise.\r\n     */\r\n    available(byteLength = 1) {\r\n        return this.offset + byteLength <= this.length;\r\n    }\r\n    /**\r\n     * Check if little-endian mode is used for reading and writing multi-byte\r\n     * values.\r\n     * @returns `true` if little-endian mode is used, `false` otherwise.\r\n     */\r\n    isLittleEndian() {\r\n        return this.littleEndian;\r\n    }\r\n    /**\r\n     * Set little-endian mode for reading and writing multi-byte values.\r\n     */\r\n    setLittleEndian() {\r\n        this.littleEndian = true;\r\n        return this;\r\n    }\r\n    /**\r\n     * Check if big-endian mode is used for reading and writing multi-byte values.\r\n     * @returns `true` if big-endian mode is used, `false` otherwise.\r\n     */\r\n    isBigEndian() {\r\n        return !this.littleEndian;\r\n    }\r\n    /**\r\n     * Switches to big-endian mode for reading and writing multi-byte values.\r\n     */\r\n    setBigEndian() {\r\n        this.littleEndian = false;\r\n        return this;\r\n    }\r\n    /**\r\n     * Move the pointer n bytes forward.\r\n     * @param n - Number of bytes to skip.\r\n     */\r\n    skip(n = 1) {\r\n        this.offset += n;\r\n        return this;\r\n    }\r\n    /**\r\n     * Move the pointer to the given offset.\r\n     * @param offset\r\n     */\r\n    seek(offset) {\r\n        this.offset = offset;\r\n        return this;\r\n    }\r\n    /**\r\n     * Store the current pointer offset.\r\n     * @see {@link IOBuffer#reset}\r\n     */\r\n    mark() {\r\n        this._mark = this.offset;\r\n        return this;\r\n    }\r\n    /**\r\n     * Move the pointer back to the last pointer offset set by mark.\r\n     * @see {@link IOBuffer#mark}\r\n     */\r\n    reset() {\r\n        this.offset = this._mark;\r\n        return this;\r\n    }\r\n    /**\r\n     * Push the current pointer offset to the mark stack.\r\n     * @see {@link IOBuffer#popMark}\r\n     */\r\n    pushMark() {\r\n        this._marks.push(this.offset);\r\n        return this;\r\n    }\r\n    /**\r\n     * Pop the last pointer offset from the mark stack, and set the current\r\n     * pointer offset to the popped value.\r\n     * @see {@link IOBuffer#pushMark}\r\n     */\r\n    popMark() {\r\n        const offset = this._marks.pop();\r\n        if (offset === undefined) {\r\n            throw new Error('Mark stack empty');\r\n        }\r\n        this.seek(offset);\r\n        return this;\r\n    }\r\n    /**\r\n     * Move the pointer offset back to 0.\r\n     */\r\n    rewind() {\r\n        this.offset = 0;\r\n        return this;\r\n    }\r\n    /**\r\n     * Make sure the buffer has sufficient memory to write a given byteLength at\r\n     * the current pointer offset.\r\n     * If the buffer's memory is insufficient, this method will create a new\r\n     * buffer (a copy) with a length that is twice (byteLength + current offset).\r\n     * @param byteLength\r\n     */\r\n    ensureAvailable(byteLength = 1) {\r\n        if (!this.available(byteLength)) {\r\n            const lengthNeeded = this.offset + byteLength;\r\n            const newLength = lengthNeeded * 2;\r\n            const newArray = new Uint8Array(newLength);\r\n            newArray.set(new Uint8Array(this.buffer));\r\n            this.buffer = newArray.buffer;\r\n            this.length = this.byteLength = newLength;\r\n            this._data = new DataView(this.buffer);\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * Read a byte and return false if the byte's value is 0, or true otherwise.\r\n     * Moves pointer forward by one byte.\r\n     */\r\n    readBoolean() {\r\n        return this.readUint8() !== 0;\r\n    }\r\n    /**\r\n     * Read a signed 8-bit integer and move pointer forward by 1 byte.\r\n     */\r\n    readInt8() {\r\n        return this._data.getInt8(this.offset++);\r\n    }\r\n    /**\r\n     * Read an unsigned 8-bit integer and move pointer forward by 1 byte.\r\n     */\r\n    readUint8() {\r\n        return this._data.getUint8(this.offset++);\r\n    }\r\n    /**\r\n     * Alias for {@link IOBuffer#readUint8}.\r\n     */\r\n    readByte() {\r\n        return this.readUint8();\r\n    }\r\n    /**\r\n     * Read `n` bytes and move pointer forward by `n` bytes.\r\n     */\r\n    readBytes(n = 1) {\r\n        const bytes = new Uint8Array(n);\r\n        for (let i = 0; i < n; i++) {\r\n            bytes[i] = this.readByte();\r\n        }\r\n        return bytes;\r\n    }\r\n    /**\r\n     * Read a 16-bit signed integer and move pointer forward by 2 bytes.\r\n     */\r\n    readInt16() {\r\n        const value = this._data.getInt16(this.offset, this.littleEndian);\r\n        this.offset += 2;\r\n        return value;\r\n    }\r\n    /**\r\n     * Read a 16-bit unsigned integer and move pointer forward by 2 bytes.\r\n     */\r\n    readUint16() {\r\n        const value = this._data.getUint16(this.offset, this.littleEndian);\r\n        this.offset += 2;\r\n        return value;\r\n    }\r\n    /**\r\n     * Read a 32-bit signed integer and move pointer forward by 4 bytes.\r\n     */\r\n    readInt32() {\r\n        const value = this._data.getInt32(this.offset, this.littleEndian);\r\n        this.offset += 4;\r\n        return value;\r\n    }\r\n    /**\r\n     * Read a 32-bit unsigned integer and move pointer forward by 4 bytes.\r\n     */\r\n    readUint32() {\r\n        const value = this._data.getUint32(this.offset, this.littleEndian);\r\n        this.offset += 4;\r\n        return value;\r\n    }\r\n    /**\r\n     * Read a 32-bit floating number and move pointer forward by 4 bytes.\r\n     */\r\n    readFloat32() {\r\n        const value = this._data.getFloat32(this.offset, this.littleEndian);\r\n        this.offset += 4;\r\n        return value;\r\n    }\r\n    /**\r\n     * Read a 64-bit floating number and move pointer forward by 8 bytes.\r\n     */\r\n    readFloat64() {\r\n        const value = this._data.getFloat64(this.offset, this.littleEndian);\r\n        this.offset += 8;\r\n        return value;\r\n    }\r\n    /**\r\n     * Read a 1-byte ASCII character and move pointer forward by 1 byte.\r\n     */\r\n    readChar() {\r\n        return String.fromCharCode(this.readInt8());\r\n    }\r\n    /**\r\n     * Read `n` 1-byte ASCII characters and move pointer forward by `n` bytes.\r\n     */\r\n    readChars(n = 1) {\r\n        let result = '';\r\n        for (let i = 0; i < n; i++) {\r\n            result += this.readChar();\r\n        }\r\n        return result;\r\n    }\r\n    /**\r\n     * Read the next `n` bytes, return a UTF-8 decoded string and move pointer\r\n     * forward by `n` bytes.\r\n     */\r\n    readUtf8(n = 1) {\r\n        return decode(this.readBytes(n));\r\n    }\r\n    /**\r\n     * Write 0xff if the passed value is truthy, 0x00 otherwise and move pointer\r\n     * forward by 1 byte.\r\n     */\r\n    writeBoolean(value) {\r\n        this.writeUint8(value ? 0xff : 0x00);\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as an 8-bit signed integer and move pointer forward by 1 byte.\r\n     */\r\n    writeInt8(value) {\r\n        this.ensureAvailable(1);\r\n        this._data.setInt8(this.offset++, value);\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as an 8-bit unsigned integer and move pointer forward by 1\r\n     * byte.\r\n     */\r\n    writeUint8(value) {\r\n        this.ensureAvailable(1);\r\n        this._data.setUint8(this.offset++, value);\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * An alias for {@link IOBuffer#writeUint8}.\r\n     */\r\n    writeByte(value) {\r\n        return this.writeUint8(value);\r\n    }\r\n    /**\r\n     * Write all elements of `bytes` as uint8 values and move pointer forward by\r\n     * `bytes.length` bytes.\r\n     */\r\n    writeBytes(bytes) {\r\n        this.ensureAvailable(bytes.length);\r\n        for (let i = 0; i < bytes.length; i++) {\r\n            this._data.setUint8(this.offset++, bytes[i]);\r\n        }\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as a 16-bit signed integer and move pointer forward by 2\r\n     * bytes.\r\n     */\r\n    writeInt16(value) {\r\n        this.ensureAvailable(2);\r\n        this._data.setInt16(this.offset, value, this.littleEndian);\r\n        this.offset += 2;\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as a 16-bit unsigned integer and move pointer forward by 2\r\n     * bytes.\r\n     */\r\n    writeUint16(value) {\r\n        this.ensureAvailable(2);\r\n        this._data.setUint16(this.offset, value, this.littleEndian);\r\n        this.offset += 2;\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as a 32-bit signed integer and move pointer forward by 4\r\n     * bytes.\r\n     */\r\n    writeInt32(value) {\r\n        this.ensureAvailable(4);\r\n        this._data.setInt32(this.offset, value, this.littleEndian);\r\n        this.offset += 4;\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as a 32-bit unsigned integer and move pointer forward by 4\r\n     * bytes.\r\n     */\r\n    writeUint32(value) {\r\n        this.ensureAvailable(4);\r\n        this._data.setUint32(this.offset, value, this.littleEndian);\r\n        this.offset += 4;\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as a 32-bit floating number and move pointer forward by 4\r\n     * bytes.\r\n     */\r\n    writeFloat32(value) {\r\n        this.ensureAvailable(4);\r\n        this._data.setFloat32(this.offset, value, this.littleEndian);\r\n        this.offset += 4;\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write `value` as a 64-bit floating number and move pointer forward by 8\r\n     * bytes.\r\n     */\r\n    writeFloat64(value) {\r\n        this.ensureAvailable(8);\r\n        this._data.setFloat64(this.offset, value, this.littleEndian);\r\n        this.offset += 8;\r\n        this._updateLastWrittenByte();\r\n        return this;\r\n    }\r\n    /**\r\n     * Write the charCode of `str`'s first character as an 8-bit unsigned integer\r\n     * and move pointer forward by 1 byte.\r\n     */\r\n    writeChar(str) {\r\n        return this.writeUint8(str.charCodeAt(0));\r\n    }\r\n    /**\r\n     * Write the charCodes of all `str`'s characters as 8-bit unsigned integers\r\n     * and move pointer forward by `str.length` bytes.\r\n     */\r\n    writeChars(str) {\r\n        for (let i = 0; i < str.length; i++) {\r\n            this.writeUint8(str.charCodeAt(i));\r\n        }\r\n        return this;\r\n    }\r\n    /**\r\n     * UTF-8 encode and write `str` to the current pointer offset and move pointer\r\n     * forward according to the encoded length.\r\n     */\r\n    writeUtf8(str) {\r\n        return this.writeBytes(encode(str));\r\n    }\r\n    /**\r\n     * Export a Uint8Array view of the internal buffer.\r\n     * The view starts at the byte offset and its length\r\n     * is calculated to stop at the last written byte or the original length.\r\n     */\r\n    toArray() {\r\n        return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);\r\n    }\r\n    /**\r\n     * Update the last written byte offset\r\n     * @private\r\n     */\r\n    _updateLastWrittenByte() {\r\n        if (this.offset > this.lastWrittenByte) {\r\n            this.lastWrittenByte = this.offset;\r\n        }\r\n    }\r\n}\r\n//# sourceMappingURL=IOBuffer.js.map","/* eslint-disable no-control-regex */\nimport { equidistantArray, getSubFlagParameters } from './utility';\n\n/**\n * Parses the subheader of the current subfile\n *\n * @export\n * @param {object} buffer SPC buffer\n * @return {object} Current subfile's subheader\n */\nexport function subHeader(buffer) {\n  const subHeader = {};\n  subHeader.parameters = getSubFlagParameters(buffer.readUint8());\n  subHeader.exponentY = buffer.readInt8();\n  subHeader.indexNumber = buffer.readUint16();\n  subHeader.startingZ = buffer.readFloat32();\n  subHeader.endingZ = buffer.readFloat32();\n  subHeader.noiseValue = buffer.readFloat32();\n  subHeader.numberPoints = buffer.readUint32();\n  subHeader.numberCoAddedScans = buffer.readUint32();\n  subHeader.wAxisValue = buffer.readFloat32();\n  subHeader.reserved = buffer.readChars(4).trim().replace(/\\x00/g, '');\n  return subHeader;\n}\n\n/**\n * Reads the data block of the SPC file\n *\n * @export\n * @param {object} buffer spc buffer\n * @param {object} mainHeader main header\n * @return {array} Array containing the spectra\n */\nexport function readDataBlock(buffer, mainHeader) {\n  let x;\n  let y;\n  let spectra = [];\n\n  if (!mainHeader.parameters.xyxy && mainHeader.xy) {\n    x = new Float32Array(mainHeader.numberPoints);\n    for (let i = 0; i < mainHeader.numberPoints; i++) {\n      x[i] = buffer.readFloat32();\n    }\n  } else if (!mainHeader.parameters.xy) {\n    x = equidistantArray(\n      mainHeader.startingX,\n      mainHeader.endingX,\n      mainHeader.numberPoints,\n    );\n  }\n  let spectrum;\n  for (\n    let i = 0;\n    i < mainHeader.spectra ||\n    (mainHeader.fileVersion === 0x4d &&\n      buffer.offset + mainHeader.numberPoints < buffer.length);\n    i++\n  ) {\n    spectrum = {};\n    spectrum.meta = subHeader(buffer);\n    if (mainHeader.parameters.xyxy) {\n      x = new Float32Array(spectrum.meta.numberPoints);\n      for (let j = 0; j < spectrum.meta.numberPoints; j++) {\n        x[j] = buffer.readFloat32();\n      }\n    }\n    if (spectrum.meta.exponentY === 0) {\n      spectrum.meta.exponentY = mainHeader.exponentY;\n    }\n    const yFactor = Math.pow(\n      2,\n      spectrum.meta.exponentY -\n        (mainHeader.parameters.y16BitPrecision ? 16 : 32),\n    );\n\n    const nbPoints = spectrum.meta.numberPoints\n      ? spectrum.meta.numberPoints\n      : mainHeader.numberPoints;\n\n    if (mainHeader.parameters.y16BitPrecision) {\n      y = new Float32Array(nbPoints);\n      for (let j = 0; j < nbPoints; j++) {\n        y[j] = buffer.readInt16() * yFactor;\n      }\n    } else {\n      y = new Float32Array(nbPoints);\n      for (let j = 0; j < nbPoints; j++) {\n        if (mainHeader.fileVersion === 0x4d) {\n          y[j] =\n            ((buffer.readUint8() << 16) +\n              (buffer.readInt8() << 24) +\n              (buffer.readUint8() << 0) +\n              (buffer.readUint8() << 8)) *\n            yFactor;\n        } else {\n          if (spectrum.meta.exponentY !== -128) {\n            y[j] = buffer.readInt32() * yFactor;\n          } else {\n            y[j] = buffer.readFloat32();\n          }\n        }\n      }\n    }\n    const xAxis = mainHeader.xUnitsType.match(\n      /(?<label>.*?) ?[([](?<units>.*)[)\\]]/,\n    );\n    const yAxis = mainHeader.yUnitsType.match(\n      /(?<label>.*?) ?[([](?<units>.*)[)\\]]/,\n    );\n    const variables = {\n      x: {\n        symbol: 'x',\n        label: (xAxis && xAxis.groups.label) || mainHeader.xUnitsType,\n        units: (xAxis && xAxis.groups.units) || '',\n        data: x,\n        type: 'INDEPENDENT',\n      },\n      y: {\n        symbol: 'y',\n        label: (yAxis && yAxis.groups.label) || mainHeader.yUnitsType,\n        units: (yAxis && yAxis.groups.units) || '',\n        data: y,\n        type: 'DEPENDENT',\n      },\n    };\n    spectrum.variables = variables;\n    spectra.push(spectrum);\n  }\n  return spectra;\n}\n","/**\n * Gets the parameter in each bit of the flag\n * @param {number} flag First byte of the main header\n * @returns {object} The parameters\n */\nexport function getFlagParameters(flag) {\n  const parameters = {}; //Z is time\n  parameters.y16BitPrecision = (flag & 1) !== 0; //Y values are 16 bits instead of 32\n  parameters.useExperimentExtension = (flag & 2) !== 0; //Enable experiment mode\n  parameters.multiFile = (flag & 4) !== 0; //Multiple spectra\n  parameters.zValuesRandom = (flag & 8) !== 0; //Z values in random order if multiFile\n  parameters.zValuesUneven = (flag & 16) !== 0; //Z values ordered but unevenly spaced if multi\n  parameters.customAxisLabels = (flag & 32) !== 0; //Custom labels\n  parameters.xyxy = (flag & 64) !== 0; //One X array per subfile, for discontinuous curves\n  parameters.xy = (flag & 128) !== 0; // Non-evenly spaced X, X before Y\n  return parameters;\n}\n\n/**\n *\n * Gets the Subfile flags\n * @param {number} flag First byte of the subheader\n * @return {object} The parameters\n */\nexport function getSubFlagParameters(flag) {\n  const parameters = {};\n  parameters.changed = (flag & 1) !== 0;\n  parameters.noPeakTable = (flag & 8) !== 0;\n  parameters.modifiedArithmetic = (flag & 128) !== 0;\n  return parameters;\n}\n\n/**\n * Generates an array of evenly spaced numbers\n * @param {number} minimum Lower bound\n * @param {number} maximum Upper bound\n * @param {number} numberPoints Number of points\n * @return {array} Evenly spaced numbers\n */\nexport function equidistantArray(minimum, maximum, numberPoints) {\n  const equidistantArray = new Float64Array(numberPoints);\n  const step = (maximum - minimum) / (numberPoints - 1);\n  for (let i = 0; i < numberPoints; i++) {\n    equidistantArray[i] = minimum + i * step;\n  }\n  return equidistantArray;\n}\n\n/**\n * Gets the date encoded in binary in a long number\n * @param {number} long Binary date\n * @return {string} Date formatted to ISO 8601:2019 convention\n */\nexport function longToDate(long) {\n  if (long === 0) {\n    return '0000-00-00T00:00:00.00Z';\n  }\n  const date = new Date();\n  date.setUTCFullYear(long >> 20);\n  date.setUTCMonth(((long >> 16) & 0x0f) - 1);\n  date.setUTCDate((long >> 11) & 0x1f);\n  date.setUTCHours((long >> 6) & 0x1f);\n  date.setUTCMinutes(long & 0x3f);\n  date.setUTCSeconds(0);\n  date.setUTCMilliseconds(0);\n  return date.toISOString();\n}\n","/* eslint-disable no-control-regex */\n/**\n *\n * @param {object} buffer SPC buffer\n * @param {number} logOffset Offset of the log (from mainHeader)\n * @return {object} Object containing log meta, data and text\n */\nexport function readLogBlock(buffer, logOffset) {\n  const logHeader = {};\n  logHeader.size = buffer.readUint32(); //Size of the block in bytes\n  logHeader.memorySize = buffer.readUint32(); //Size of the memory rounded up to nearest multiple of 4096\n  logHeader.textOffset = buffer.readUint32(); //Offset to Text section\n  logHeader.binarySize = buffer.readUint32(); //Size of binary log block\n  logHeader.diskArea = buffer.readUint32(); //Size of the disk area\n  logHeader.reserved = buffer.readChars(44).trim().replace(/\\x00/g, ''); //Reserved space\n  const logData = buffer.readChars(logHeader.binarySize);\n  buffer.offset = logOffset + logHeader.textOffset;\n  const logASCII = buffer\n    .readChars(logHeader.size - logHeader.textOffset)\n    .trim()\n    .replace(/\\x00/g, '');\n  return { meta: logHeader, data: logData, text: logASCII };\n}\n","/**\n * Gives meaning to type codes\n * @param {number} xzwType x, z or w type code\n * @return {string} String corresponding to the code\n */\nexport function xzwTypes(xzwType) {\n  switch (xzwType) {\n    case 1:\n      return 'Wavenumber (cm-1)';\n    case 2:\n      return 'Micrometers (um)';\n    case 3:\n      return 'Nanometers (nm)';\n    case 4:\n      return 'Seconds';\n    case 5:\n      return 'Minutes';\n    case 6:\n      return 'Hertz (Hz)';\n    case 7:\n      return 'Kilohertz (KHz)';\n    case 8:\n      return 'Megahertz (MHz)';\n    case 9:\n      return 'Mass (M/z)';\n    case 10:\n      return 'Parts per million (PPM)';\n    case 11:\n      return 'Days';\n    case 12:\n      return 'Years';\n    case 13:\n      return 'Raman Shift (cm-1)';\n    case 14:\n      return 'eV';\n    case 15:\n      return 0;\n    case 16:\n      return 'Diode Number';\n    case 17:\n      return 'Channel ';\n    case 18:\n      return 'Degrees';\n    case 19:\n      return 'Temperature (F)';\n    case 20:\n      return 'Temperature (C)';\n    case 21:\n      return 'Temperature (K)';\n    case 22:\n      return 'Data Points';\n    case 23:\n      return 'Milliseconds (mSec)';\n    case 24:\n      return 'Microseconds (uSec)';\n    case 25:\n      return 'Nanoseconds (nSec)';\n    case 26:\n      return 'Gigahertz (GHz)';\n    case 27:\n      return 'Centimeters (cm)';\n    case 28:\n      return 'Meters (m)';\n    case 29:\n      return 'Millimeters (mm)';\n    case 30:\n      return 'Hours';\n    case 255:\n      return 'Double interferogram';\n    default:\n      return 'Arbitrary';\n  }\n}\n/**\n * Gives meaning to y type codes\n * @param {number} yType y type code\n * @return {string} String corresponding to the code\n */\nexport function yTypes(yType) {\n  switch (yType) {\n    case 0:\n      return 'Arbitrary Intensity';\n    case 1:\n      return 'Interferogram';\n    case 2:\n      return 'Absorbance';\n    case 3:\n      return 'Kubelka-Monk';\n    case 4:\n      return 'Counts';\n    case 5:\n      return 'Volts';\n    case 6:\n      return 'Degrees';\n    case 7:\n      return 'Milliamps';\n    case 8:\n      return 'Millimeters';\n    case 9:\n      return 'Millivolts';\n    case 10:\n      return 'Log(1/R)';\n    case 11:\n      return 'Percent';\n    case 12:\n      return 'Intensity';\n    case 13:\n      return 'Relative Intensity';\n    case 14:\n      return 'Energy';\n    case 16:\n      return 'Decibel';\n    case 19:\n      return 'Temperature (F)';\n    case 20:\n      return 'Temperature (C)';\n    case 21:\n      return 'Temperature (K)';\n    case 22:\n      return 'Index of Refraction [N]';\n    case 23:\n      return 'Extinction Coeff. [K]';\n    case 24:\n      return 'Real';\n    case 25:\n      return 'Imaginary';\n    case 26:\n      return 'Complex';\n    case 128:\n      return 'Transmission';\n    case 129:\n      return 'Reflectance';\n    case 130:\n      return 'Arbitrary or Single Beam with Valley Peaks';\n    case 131:\n      return 'Emission';\n    default:\n      return 'Reference Arbitrary Energy';\n  }\n}\n\n/**\n * Experiment settings code converter\n * @param {number} code\n * @return {string}\n */\nexport function experimentSettings(code) {\n  switch (code) {\n    case 1:\n      return 'Gas Chromatogram';\n    case 2:\n      return 'General Chromatogram (same as SPCGEN with TCGRAM)';\n    case 3:\n      return 'HPLC Chromatogram';\n    case 4:\n      return 'FT-IR, FT-NIR, FT-Raman Spectrum or Igram (Can also be used for scanning IR.)';\n    case 5:\n      return 'NIR Spectrum (Usually multi-spectral data sets for calibration.)';\n    case 7:\n      return 'UV-VIS Spectrum (Can be used for single scanning UV-VIS-NIR.)';\n    case 8:\n      return 'X-ray Diffraction Spectrum';\n    case 9:\n      return 'Mass Spectrum  (Can be single, GC-MS, Continuum, Centroid or TOF.)';\n    case 10:\n      return 'NMR Spectrum or FID';\n    case 11:\n      return 'Raman Spectrum (Usually Diode Array, CCD, etc. use SPCFTIR for FT-Raman.)';\n    case 12:\n      return 'Fluorescence Spectrum';\n    case 13:\n      return 'Atomic Spectrum';\n    case 14:\n      return 'Chromatography Diode Array Spectra';\n    default:\n      return 'General SPC (could be anything)';\n  }\n}\n","/* eslint-disable no-control-regex */\nimport { xzwTypes, yTypes, experimentSettings } from './types';\nimport { getFlagParameters, longToDate } from './utility';\n\n/**\n * Main header parsing - First 512/256 bytes (new/old format)\n * @param {object} buffer SPC buffer\n * @return {object} Main header\n */\nexport function mainHeader(buffer) {\n  const header = {};\n  header.parameters = getFlagParameters(buffer.readUint8()); //Each bit contains a parameter\n  header.fileVersion = buffer.readUint8(); //4B => New format; 4D => LabCalc format\n  switch (header.fileVersion) {\n    case 0x4b: // new format\n      break;\n    case 0x4c:\n      buffer.setBigEndian();\n      break;\n    case 0x4d: // old LabCalc format\n      return oldHeader(buffer, header);\n    default:\n      throw new Error(\n        'Unrecognized file format: byte 01 must be either 4B, 4C or 4D',\n      );\n  }\n\n  header.experimentType = experimentSettings(buffer.readUint8()); //Experiment type code (See SPC.h)\n  header.exponentY = buffer.readInt8(); //Exponent for Y values (80h = floating point): FloatY = (2^Exp)*IntY/(2^32) 32-bit; FloatY = (2^Exp)*IntY/(2^16) 32-bit\n  header.numberPoints = buffer.readUint32(); //Number of points (if not XYXY)\n  header.startingX = buffer.readFloat64(); //First X coordinate\n  header.endingX = buffer.readFloat64(); //Last X coordinate\n  header.spectra = buffer.readUint32(); //Number of spectrums\n  header.xUnitsType = xzwTypes(buffer.readUint8()); //X Units type code (See types.js)\n\n  header.yUnitsType = yTypes(buffer.readUint8()); //Y \"\"\n  header.zUnitsType = xzwTypes(buffer.readUint8()); //Z \"\"\n  header.postingDisposition = buffer.readUint8(); //Posting disposition (See GRAMSDDE.H)\n  header.date = longToDate(buffer.readUint32()); //Date: minutes = first 6 bits, hours = 5 next bits, days = 5 next, months = 4 next, years = 12 last\n  header.resolutionDescription = buffer\n    .readChars(9)\n    .trim()\n    .replace(/\\x00/g, ''); //Resolution description text\n  header.sourceInstrumentDescription = buffer\n    .readChars(9)\n    .trim()\n    .replace(/\\x00/g, ''); // Source Instrument description text\n  header.peakPointNumber = buffer.readUint16(); //Peak point number for interferograms\n  header.spare = [];\n  for (let i = 0; i < 8; i++) {\n    header.spare.push(buffer.readFloat32());\n  }\n  if (header.fileVersion === 0x4c) {\n    //Untested case because no test files\n    header.spare.reverse();\n  }\n  header.memo = buffer.readChars(130).trim().replace(/\\x00/g, '');\n  header.xyzLabels = buffer.readChars(30).trim().replace(/\\x00/g, '');\n  header.logOffset = buffer.readUint32(); //Byte offset to Log Block\n  header.modifiedFlag = buffer.readUint32(); //File modification flag (See values in SPC.H)\n  header.processingCode = buffer.readUint8(); //Processing code (See GRAMSDDE.H)\n  header.calibrationLevel = buffer.readUint8(); //Calibration level + 1\n  header.subMethodSampleInjectionNumber = buffer.readUint16(); //Sub-method sample injection number\n  header.concentrationFactor = buffer.readFloat32(); //Floating data multiplier concentration factor\n  header.methodFile = buffer.readChars(48).trim().replace(/\\x00/g, ''); //Method file\n  header.zSubIncrement = buffer.readFloat32(); //Z subfile increment for even Z Multifiles\n  header.wPlanes = buffer.readUint32();\n  header.wPlaneIncrement = buffer.readFloat32();\n  header.wAxisUnits = xzwTypes(buffer.readUint8()); //W axis units code\n  header.reserved = buffer.readChars(187).trim().replace(/\\x00/g, ''); //Reserved space (Must be zero)\n  if (header.xUnitsType === 0) {\n    header.xUnitsType = header.xyzLabels.substr(0, 10);\n  }\n  if (header.zUnitsType === 0) {\n    header.zUnitsType = header.xyzLabels.substr(20, 10);\n  }\n  return header;\n}\n\n/**\n *Old version files header parsing\n *\n * @export\n * @param {object} buffer SPC buffer\n * @param {object} header Header from the previous function\n * @return {object} Object containing the metadata of the old file\n */\nexport function oldHeader(buffer, header) {\n  header.exponentY = buffer.readInt16(); //Word (16 bits) instead of byte\n  header.numberPoints = buffer.readFloat32();\n  header.startingX = buffer.readFloat32();\n  header.endingX = buffer.readFloat32();\n  header.xUnitsType = xzwTypes(buffer.readUint8());\n  header.yUnitsType = yTypes(buffer.readUint8());\n  const date = new Date();\n  const zTypeYear = buffer.readUint16(); //Unrelated to Z axis\n  date.setUTCFullYear(zTypeYear % 4096); // todo might be wrong\n  date.setUTCMonth(Math.max(buffer.readUint8() - 1, 0));\n  date.setUTCDate(buffer.readUint8());\n  date.setUTCHours(buffer.readUint8());\n  date.setUTCMinutes(buffer.readUint8());\n  header.date = date.toISOString();\n  header.resolutionDescription = buffer\n    .readChars(8)\n    .trim()\n    .replace(/\\x00/g, '');\n  header.peakPointNumber = buffer.readUint16();\n  header.scans = buffer.readUint16();\n  header.spare = [];\n  for (let i = 0; i < 7; i++) {\n    header.spare.push(buffer.readFloat32());\n  }\n  header.memo = buffer.readChars(130).trim().replace(/\\x00/g, '');\n  header.xyzLabels = buffer.readChars(30).trim().replace(/\\x00/g, '');\n  return header;\n}\n","import { IOBuffer } from 'iobuffer';\n\nimport { readDataBlock } from './dataBlock';\nimport { readLogBlock } from './logBlock';\nimport { mainHeader } from './mainHeader';\n/**\n * Parses an SPC file\n *\n * @param {object} buffer SPC file buffer\n * @return {object} Object containing every information contained in the SPC file\n */\nexport function parse(buffer) {\n  const ioBuffer = new IOBuffer(buffer);\n  const meta = mainHeader(ioBuffer);\n  const spectra = readDataBlock(ioBuffer, meta);\n  if (meta.logOffset && meta.logOffset !== 0) {\n    return { meta, spectra, logs: readLogBlock(ioBuffer, meta.logOffset) };\n  }\n  return { meta, spectra };\n}\n"],"names":["decoder","TextDecoder","encoder","TextEncoder","IOBuffer","constructor","data","options","dataIsGiven","ArrayBuffer","lastWrittenByte","byteLength","offset","dvOffset","isView","buffer","byteOffset","length","littleEndian","_data","DataView","this","_mark","_marks","available","isLittleEndian","setLittleEndian","isBigEndian","setBigEndian","skip","n","seek","mark","reset","pushMark","push","popMark","pop","undefined","Error","rewind","ensureAvailable","newLength","newArray","Uint8Array","set","readBoolean","readUint8","readInt8","getInt8","getUint8","readByte","readBytes","bytes","i","readInt16","value","getInt16","readUint16","getUint16","readInt32","getInt32","readUint32","getUint32","readFloat32","getFloat32","readFloat64","getFloat64","readChar","String","fromCharCode","readChars","result","readUtf8","decode","writeBoolean","writeUint8","writeInt8","setInt8","_updateLastWrittenByte","setUint8","writeByte","writeBytes","writeInt16","setInt16","writeUint16","setUint16","writeInt32","setInt32","writeUint32","setUint32","writeFloat32","setFloat32","writeFloat64","setFloat64","writeChar","str","charCodeAt","writeChars","writeUtf8","encode","toArray","subHeader","parameters","flag","changed","noPeakTable","modifiedArithmetic","getSubFlagParameters","exponentY","indexNumber","startingZ","endingZ","noiseValue","numberPoints","numberCoAddedScans","wAxisValue","reserved","trim","replace","readDataBlock","mainHeader","x","y","spectrum","spectra","xyxy","xy","Float32Array","minimum","maximum","equidistantArray","Float64Array","step","startingX","endingX","fileVersion","meta","j","yFactor","Math","pow","y16BitPrecision","nbPoints","xAxis","xUnitsType","match","yAxis","yUnitsType","variables","symbol","label","groups","units","type","readLogBlock","logOffset","logHeader","size","memorySize","textOffset","binarySize","diskArea","logData","text","xzwTypes","xzwType","yTypes","yType","header","useExperimentExtension","multiFile","zValuesRandom","zValuesUneven","customAxisLabels","getFlagParameters","date","Date","zTypeYear","setUTCFullYear","setUTCMonth","max","setUTCDate","setUTCHours","setUTCMinutes","toISOString","resolutionDescription","peakPointNumber","scans","spare","memo","xyzLabels","oldHeader","experimentType","code","experimentSettings","zUnitsType","postingDisposition","long","setUTCSeconds","setUTCMilliseconds","longToDate","sourceInstrumentDescription","reverse","modifiedFlag","processingCode","calibrationLevel","subMethodSampleInjectionNumber","concentrationFactor","methodFile","zSubIncrement","wPlanes","wPlaneIncrement","wAxisUnits","substr","ioBuffer","logs"],"mappings":"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"}