fit-file-parser 4.0.2 → 4.1.0

package/dist/cjs/binary.js

@@ -9,30 +9,47 @@ const fit_js_1 = require("./fit.js");
 const messages_js_1 = require("./messages.js");
 const CompressedLocalMsgNumMask = 0x60;
 const CompressedHeaderMask = 0x80;
+const CompressedTimestampMask = 0x1F;
 const GarminTimeOffset = 631065600000;
-let monitoring_timestamp = 0;
 const InvalidFieldData = Symbol('invalid FIT field data');
 const formatTypeMetadata = new Map();
-function requiresBoundedEndianDataView(type, size) {
+const uint8CompatibleTypes = new Set(['enum', 'uint8', 'byte']);
+function baseTypeSize(type) {
     switch (type) {
+        case 'enum':
+        case 'sint8':
+        case 'uint8':
+        case 'uint8z':
+        case 'byte':
+            return 1;
         case 'sint16':
         case 'uint16':
         case 'uint16z':
-            return size < 2;
+            return 2;
         case 'sint32':
         case 'uint32':
         case 'uint32z':
         case 'float32':
-            return size < 4;
+            return 4;
         case 'float64':
-            return size < 8;
-        case 'uint16_array':
-            return size % 2 !== 0;
-        case 'uint32_array':
-            return size % 4 !== 0;
+            return 8;
         default:
-            return false;
+            return undefined;
+    }
+}
+function requiresBoundedEndianDataView(type, size) {
+    const elementSize = baseTypeSize(type);
+    return elementSize !== undefined && size % elementSize !== 0;
+}
+function areProfileBaseTypesCompatible(profileType, wireType) {
+    if (profileType === undefined || profileType === wireType) {
+        return true;
     }
+    // FIT producers commonly interchange enum, uint8, and byte definitions.
+    // They have the same width and value representation; keeping the semantic
+    // profile type is safe while still rejecting width and sign conflicts.
+    return uint8CompatibleTypes.has(String(profileType))
+        && uint8CompatibleTypes.has(String(wireType));
 }
 function addEndian(littleEndian, bytes) {
     let result = 0;
@@ -43,77 +60,10 @@ function addEndian(littleEndian, bytes) {
     }
     return result;
 }
-function readData(blob, dataView, fDef, startIndex, options) {
-    var _a;
-    if (fDef.type === 'uint8_array') {
-        const array8 = [];
-        for (let i = 0; i < fDef.size; i++) {
-            array8.push(blob[startIndex + i]);
-        }
-        return array8;
-    }
-    if (fDef.endianAbility) {
-        const requiresBoundedDataView = (_a = fDef.requiresBoundedDataView) !== null && _a !== void 0 ? _a : (fDef.requiresBoundedDataView = requiresBoundedEndianDataView(fDef.type, fDef.size));
-        let fieldDataView = dataView;
-        let fieldStartIndex = startIndex;
-        if (startIndex < 0
-            || startIndex + fDef.size > blob.length
-            || startIndex + fDef.size > dataView.byteLength) {
-            const paddedField = new Uint8Array(fDef.size);
-            for (let index = 0; index < fDef.size; index++) {
-                paddedField[index] = blob[startIndex + index];
-            }
-            fieldDataView = new DataView(paddedField.buffer);
-            fieldStartIndex = 0;
-        }
-        else if (requiresBoundedDataView) {
-            fieldDataView = new DataView(dataView.buffer, dataView.byteOffset + startIndex, fDef.size);
-            fieldStartIndex = 0;
-        }
-        try {
-            switch (fDef.type) {
-                case 'sint16':
-                    return fieldDataView.getInt16(fieldStartIndex, fDef.littleEndian);
-                case 'uint16':
-                case 'uint16z':
-                    return fieldDataView.getUint16(fieldStartIndex, fDef.littleEndian);
-                case 'sint32':
-                    return fieldDataView.getInt32(fieldStartIndex, fDef.littleEndian);
-                case 'uint32':
-                case 'uint32z':
-                    return fieldDataView.getUint32(fieldStartIndex, fDef.littleEndian);
-                case 'float32':
-                    return fieldDataView.getFloat32(fieldStartIndex, fDef.littleEndian);
-                case 'float64':
-                    return fieldDataView.getFloat64(fieldStartIndex, fDef.littleEndian);
-                case 'uint32_array': {
-                    const array32 = [];
-                    for (let i = 0; i < fDef.size; i += 4) {
-                        array32.push(fieldDataView.getUint32(fieldStartIndex + i, fDef.littleEndian));
-                    }
-                    return array32;
-                }
-                case 'uint16_array': {
-                    const array16 = [];
-                    for (let i = 0; i < fDef.size; i += 2) {
-                        array16.push(fieldDataView.getUint16(fieldStartIndex + i, fDef.littleEndian));
-                    }
-                    return array16;
-                }
-            }
-        }
-        catch (e) {
-            if (!options.force) {
-                throw e;
-            }
-        }
-        const temp = [];
-        for (let i = 0; i < fDef.size; i++) {
-            temp.push(blob[startIndex + i]);
-        }
-        return addEndian(fDef.littleEndian, temp);
-    }
-    if (fDef.type === 'string') {
+function readData(blob, dataView, fDef, startIndex) {
+    var _a, _b;
+    const rawType = (_b = (_a = fDef.rawType) !== null && _a !== void 0 ? _a : fit_js_1.FIT.types.fit_base_type[fDef.baseTypeNo]) !== null && _b !== void 0 ? _b : fDef.type;
+    if (rawType === 'string') {
         const temp = [];
         for (let i = 0; i < fDef.size; i++) {
             if (blob[startIndex + i]) {
@@ -122,18 +72,57 @@ function readData(blob, dataView, fDef, startIndex, options) {
         }
         return buffer_1.Buffer.from(temp).toString('utf-8');
     }
-    if (fDef.type === 'byte_array') {
-        const temp = [];
-        for (let i = 0; i < fDef.size; i++) {
-            temp.push(blob[startIndex + i]);
-        }
-        return temp;
+    const elementSize = baseTypeSize(rawType);
+    if (elementSize === undefined) {
+        return InvalidFieldData;
+    }
+    if (fDef.size < elementSize
+        || fDef.size % elementSize !== 0
+        || startIndex < 0
+        || startIndex + fDef.size > blob.length
+        || startIndex + fDef.size > dataView.byteLength) {
+        return InvalidFieldData;
     }
-    if (fDef.type === 'sint8') {
-        const val = blob[startIndex];
-        return val > 127 ? val - 256 : val;
+    const isArray = fDef.array === true
+        || String(fDef.type).endsWith('_array')
+        || fDef.type === 'exercise_category_array'
+        || (fDef.isDeveloperField === true && fDef.size > elementSize);
+    const elementCount = isArray ? fDef.size / elementSize : 1;
+    const values = [];
+    for (let elementIndex = 0; elementIndex < elementCount; elementIndex++) {
+        const offset = startIndex + elementIndex * elementSize;
+        switch (rawType) {
+            case 'sint8': {
+                const value = blob[offset];
+                values.push(value > 127 ? value - 256 : value);
+                break;
+            }
+            case 'sint16':
+                values.push(dataView.getInt16(offset, fDef.littleEndian));
+                break;
+            case 'uint16':
+            case 'uint16z':
+                values.push(dataView.getUint16(offset, fDef.littleEndian));
+                break;
+            case 'sint32':
+                values.push(dataView.getInt32(offset, fDef.littleEndian));
+                break;
+            case 'uint32':
+            case 'uint32z':
+                values.push(dataView.getUint32(offset, fDef.littleEndian));
+                break;
+            case 'float32':
+                values.push(dataView.getFloat32(offset, fDef.littleEndian));
+                break;
+            case 'float64':
+                values.push(dataView.getFloat64(offset, fDef.littleEndian));
+                break;
+            default:
+                values.push(blob[offset]);
+                break;
+        }
     }
-    return blob[startIndex];
+    return isArray ? values : values[0];
 }
 function formatByType(data, type, scale, offset) {
     switch (type) {
@@ -160,6 +149,16 @@ function formatByType(data, type, scale, offset) {
                 });
             }
             return scale ? data / scale + offset : data;
+        case 'exercise_category_array':
+            if (Array.isArray(data)) {
+                return data.map((dataItem) => {
+                    if (isInvalidValue(dataItem, 'uint16')) {
+                        return null;
+                    }
+                    return formatByType(dataItem, 'exercise_category', scale, offset);
+                });
+            }
+            return formatByType(data, 'exercise_category', scale, offset);
         default:
             {
                 const typeMap = fit_js_1.FIT.types[type];
@@ -218,10 +217,9 @@ function isInvalidValue(data, type) {
         case 'string':
             return data === 0x00;
         case 'float32':
-            return data === 0xFFFFFFFF;
+            return Number.isNaN(data);
         case 'float64':
-            // eslint-disable-next-line no-loss-of-precision
-            return data === 0xFFFFFFFFFFFFFFFF;
+            return Number.isNaN(data);
         case 'uint8z':
             return data === 0x00;
         case 'uint16z':
@@ -249,6 +247,27 @@ function isInvalidBaseTypeValue(data, baseTypeNo) {
     const baseType = fit_js_1.FIT.types.fit_base_type[baseTypeNo];
     return typeof baseType === 'string' ? isInvalidValue(data, baseType) : false;
 }
+function formatFieldValue(data, fDef, options, fields) {
+    var _a, _b, _c;
+    const field = fDef.name;
+    const scale = (_a = fDef.scale) !== null && _a !== void 0 ? _a : null;
+    const offset = (_b = fDef.offset) !== null && _b !== void 0 ? _b : 0;
+    if (Array.isArray(data)
+        && !String(fDef.type).endsWith('_array')
+        && fDef.type !== 'exercise_category_array') {
+        const rawType = (_c = fDef.rawType) !== null && _c !== void 0 ? _c : fit_js_1.FIT.types.fit_base_type[fDef.baseTypeNo];
+        return data.map((item) => {
+            if (isInvalidValue(item, rawType)) {
+                return null;
+            }
+            return applyOptions(formatByType(item, fDef.type, scale, offset), field, options, fields);
+        });
+    }
+    return applyOptions(formatByType(data, fDef.type, scale, offset), field, options, fields);
+}
+function isOutputFieldName(field) {
+    return field !== 'unknown' && field !== '' && field !== undefined;
+}
 function convertTo(data, unitsList, unitName) {
     const options = fit_js_1.FIT.options[unitsList];
     const unit = options[unitName];
@@ -307,8 +326,10 @@ function applyOptions(data, field, options, fields) {
             return convertTo(data, 'lengthUnits', options.lengthUnit);
         case 'temperature':
         case 'min_temperature':
+        case 'temperature_min':
         case 'avg_temperature':
         case 'max_temperature':
+        case 'temperature_max':
             return convertTo(data, 'temperatureUnits', options.temperatureUnit);
         case 'pressure':
         case 'start_pressure':
@@ -340,7 +361,7 @@ function applyGarminProductName(fields) {
     }
 }
 function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, developerFields, options) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const description = (_a = developerFields[developerFieldDef.developerDataIndex]) === null || _a === void 0 ? void 0 : _a[developerFieldDef.fieldDefinitionNumber];
     if (!description) {
         developerFieldDef.resolvedFieldDef = undefined;
@@ -351,9 +372,12 @@ function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, develo
         && developerFieldDef.resolvedFieldDef) {
         return developerFieldDef.resolvedFieldDef;
     }
-    const baseType = description.fit_base_type_id;
+    const describedBaseType = description.fit_base_type_id;
+    const baseType = typeof describedBaseType === 'number'
+        ? describedBaseType
+        : Number((_b = Object.entries(fit_js_1.FIT.types.fit_base_type).find(([, typeName]) => typeName === describedBaseType)) === null || _b === void 0 ? void 0 : _b[0]);
     const type = fit_js_1.FIT.types.fit_base_type[baseType];
-    if (typeof baseType !== 'number' || type === undefined) {
+    if (!Number.isInteger(baseType) || type === undefined) {
         developerFieldDef.resolvedFieldDef = undefined;
         developerFieldDef.resolvedFrom = undefined;
         if (options.force) {
@@ -363,15 +387,18 @@ function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, develo
     }
     const resolvedFieldDef = {
         type,
+        rawType: type,
         fDefNo: developerFieldDef.fieldDefinitionNumber,
         size: developerFieldDef.size,
+        array: type !== 'string'
+            && developerFieldDef.size > ((_c = baseTypeSize(type)) !== null && _c !== void 0 ? _c : developerFieldDef.size),
         endianAbility: (baseType & 128) === 128,
         littleEndian,
         baseTypeNo: baseType,
-        name: (_b = description.field_name) !== null && _b !== void 0 ? _b : '',
+        name: (_d = description.field_name) !== null && _d !== void 0 ? _d : '',
         dataType: (0, messages_js_1.getFitMessageBaseType)(baseType & 15),
-        scale: (_c = description.scale) !== null && _c !== void 0 ? _c : 1,
-        offset: (_d = description.offset) !== null && _d !== void 0 ? _d : 0,
+        scale: (_e = description.scale) !== null && _e !== void 0 ? _e : 1,
+        offset: (_f = description.offset) !== null && _f !== void 0 ? _f : 0,
         requiresBoundedDataView: requiresBoundedEndianDataView(type, developerFieldDef.size),
         developerDataIndex: developerFieldDef.developerDataIndex,
         isDeveloperField: true,
@@ -380,11 +407,12 @@ function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, develo
     developerFieldDef.resolvedFrom = description;
     return resolvedFieldDef;
 }
-function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime, dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength)) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime, dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength), decoderState = {}) {
+    var _a, _b, _c;
     const recordHeader = blob[startIndex];
     let localMessageType = recordHeader & 15;
-    if ((recordHeader & CompressedHeaderMask) === CompressedHeaderMask) {
+    const isCompressedTimestamp = (recordHeader & CompressedHeaderMask) === CompressedHeaderMask;
+    if (isCompressedTimestamp) {
         // compressed timestamp
         localMessageType = (recordHeader & CompressedLocalMsgNumMask) >> 5;
     }
@@ -412,19 +440,26 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
         for (let i = 0; i < numberOfFields; i++) {
             const fDefIndex = startIndex + 6 + i * 3;
             const baseType = blob[fDefIndex + 2];
-            const { field, type, scale, offset } = message.getAttributes(blob[fDefIndex]);
+            const wireType = fit_js_1.FIT.types.fit_base_type[baseType];
+            const { field, type, baseType: profileBaseType, array, scale, offset, aliases, } = message.getAttributes(blob[fDefIndex]);
+            const profileCompatible = areProfileBaseTypesCompatible(profileBaseType, wireType);
             const fDef = {
-                type,
+                type: profileCompatible ? type : wireType,
+                rawType: wireType,
                 fDefNo: blob[fDefIndex],
                 size: blob[fDefIndex + 1],
+                array: profileCompatible
+                    ? array === true || String(type).endsWith('_array')
+                    : false,
                 endianAbility: (baseType & 128) === 128,
                 littleEndian: lEnd,
                 baseTypeNo: baseType,
-                name: field,
+                name: profileCompatible ? field : '',
                 dataType: (0, messages_js_1.getFitMessageBaseType)(baseType & 15),
-                scale,
-                offset,
-                requiresBoundedDataView: requiresBoundedEndianDataView(type, blob[fDefIndex + 1]),
+                scale: profileCompatible ? scale : null,
+                offset: profileCompatible ? offset : 0,
+                requiresBoundedDataView: requiresBoundedEndianDataView(wireType, blob[fDefIndex + 1]),
+                aliases: profileCompatible ? aliases : undefined,
             };
             mTypeDef.fieldDefs.push(fDef);
         }
@@ -446,8 +481,6 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
         };
     }
     const messageType = messageTypes[localMessageType] || messageTypes[0];
-    // TODO: handle compressed header ((recordHeader & 128) == 128)
-    // uncompressed header
     let messageSize = 0;
     let readDataFromIndex = startIndex + 1;
     const fields = {};
@@ -458,10 +491,15 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
     let validFieldCount = 0;
     for (let i = 0; i < messageType.fieldDefs.length; i++) {
         const fDef = messageType.fieldDefs[i];
-        const data = readData(blob, dataView, fDef, readDataFromIndex, options);
-        if (!isInvalidValue(data, fDef.type) && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
+        const data = readData(blob, dataView, fDef, readDataFromIndex);
+        if (data !== InvalidFieldData
+            && !isInvalidValue(data, fDef.type)
+            && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
             rawData[i] = data;
             validFieldCount++;
+            if (!isCompressedTimestamp && fDef.fDefNo === 253 && typeof data === 'number') {
+                decoderState.lastTimestamp = data;
+            }
         }
         else {
             rawData[i] = InvalidFieldData;
@@ -474,8 +512,10 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
         const rawDataIndex = messageType.fieldDefs.length + i;
         const fDef = resolveDeveloperFieldDefinition(developerFieldDef, messageType.littleEndian, developerFields, options);
         if (fDef) {
-            const data = readData(blob, dataView, fDef, readDataFromIndex, options);
-            if (!isInvalidValue(data, fDef.type) && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
+            const data = readData(blob, dataView, fDef, readDataFromIndex);
+            if (data !== InvalidFieldData
+                && !isInvalidValue(data, fDef.type)
+                && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
                 rawData[rawDataIndex] = data;
                 validFieldCount++;
             }
@@ -495,9 +535,15 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
             continue;
         }
         const fDef = messageType.fieldDefs[i];
-        const field = fDef.name;
-        if (field !== 'unknown' && field !== '' && field !== undefined) {
-            fields[field] = data;
+        if (isOutputFieldName(fDef.name)) {
+            fields[fDef.name] = data;
+        }
+        if (fDef.aliases) {
+            for (const alias of fDef.aliases) {
+                if (isOutputFieldName(alias.field)) {
+                    fields[alias.field] = data;
+                }
+            }
         }
     }
     for (let i = 0; i < developerFieldDefs.length; i++) {
@@ -517,19 +563,14 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
             continue;
         }
         const fDef = messageType.fieldDefs[i];
-        if (fDef.isDeveloperField) {
-            const field = fDef.name;
-            const { type } = fDef;
-            const scale = (_d = fDef.scale) !== null && _d !== void 0 ? _d : null;
-            const offset = (_e = fDef.offset) !== null && _e !== void 0 ? _e : 0;
-            fields[fDef.name] = applyOptions(formatByType(data, type, scale, offset), field, options, fields);
+        if (isOutputFieldName(fDef.name)) {
+            fields[fDef.name] = formatFieldValue(data, fDef, options, fields);
         }
-        else {
-            const { name: field, type } = fDef;
-            const scale = (_f = fDef.scale) !== null && _f !== void 0 ? _f : null;
-            const offset = (_g = fDef.offset) !== null && _g !== void 0 ? _g : 0;
-            if (field !== 'unknown' && field !== '' && field !== undefined) {
-                fields[field] = applyOptions(formatByType(data, type, scale, offset), field, options, fields);
+        if (fDef.aliases) {
+            for (const alias of fDef.aliases) {
+                if (isOutputFieldName(alias.field)) {
+                    fields[alias.field] = formatFieldValue(data, Object.assign(Object.assign(Object.assign({}, fDef), alias), { name: alias.field, aliases: undefined }), options, fields);
+                }
             }
         }
     }
@@ -541,7 +582,24 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
         }
         const field = fDef.name;
         if (field !== 'unknown' && field !== '') {
-            fields[field] = applyOptions(formatByType(data, fDef.type, (_h = fDef.scale) !== null && _h !== void 0 ? _h : null, (_j = fDef.offset) !== null && _j !== void 0 ? _j : 0), field, options, fields);
+            fields[field] = formatFieldValue(data, fDef, options, fields);
+        }
+    }
+    if (isCompressedTimestamp) {
+        const previousTimestamp = decoderState.lastTimestamp;
+        if (previousTimestamp === undefined) {
+            if (!options.force) {
+                throw new Error('Compressed timestamp requires a previous timestamp');
+            }
+        }
+        else {
+            const timeOffset = recordHeader & CompressedTimestampMask;
+            const previousOffset = previousTimestamp & CompressedTimestampMask;
+            const rollover = timeOffset < previousOffset ? 0x20 : 0;
+            const timestamp = (previousTimestamp & ~CompressedTimestampMask) + timeOffset + rollover;
+            decoderState.lastTimestamp = timestamp;
+            fields.timestamp = new Date(timestamp * 1000 + GarminTimeOffset);
+            validFieldCount++;
         }
     }
     applyGarminProductName(fields);
@@ -555,17 +613,20 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
         developerFields[fields.developer_data_index][fields.field_definition_number] = fields;
     }
     if (message.name === 'monitoring') {
-        // TODO weirdly uses global variables?
-        // we need to keep the raw timestamp value so we can calculate subsequent timestamp16 fields
-        if (fields.timestamp) {
-            monitoring_timestamp = fields.timestamp;
-            fields.timestamp = new Date(fields.timestamp * 1000 + GarminTimeOffset);
+        const timestampFieldIndex = messageType.fieldDefs.findIndex(fieldDefinition => fieldDefinition.fDefNo === 253);
+        const rawTimestamp = timestampFieldIndex >= 0
+            ? rawData[timestampFieldIndex]
+            : InvalidFieldData;
+        if (rawTimestamp !== InvalidFieldData && typeof rawTimestamp === 'number') {
+            decoderState.monitoringTimestamp = rawTimestamp;
+            fields.timestamp = new Date(rawTimestamp * 1000 + GarminTimeOffset);
         }
-        if (fields.timestamp16 && !fields.timestamp) {
-            monitoring_timestamp
-                += (fields.timestamp16 - (monitoring_timestamp & 0xFFFF)) & 0xFFFF;
-            // fields.timestamp = monitoring_timestamp;
-            fields.timestamp = new Date(monitoring_timestamp * 1000 + GarminTimeOffset);
+        else if (fields.timestamp16
+            && decoderState.monitoringTimestamp !== undefined
+            && !fields.timestamp) {
+            decoderState.monitoringTimestamp
+                += (fields.timestamp16 - (decoderState.monitoringTimestamp & 0xFFFF)) & 0xFFFF;
+            fields.timestamp = new Date(decoderState.monitoringTimestamp * 1000 + GarminTimeOffset);
         }
     }
     return {

package/dist/cjs/fit-parser.js

@@ -31,23 +31,23 @@ class FitParser {
         });
     }
     parse(content, callback) {
-        var _a;
+        var _a, _b;
         const blob = content instanceof ArrayBuffer
             ? new Uint8Array(content)
             : new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
         const dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength);
         if (blob.length < 12) {
             callback('File to small to be a FIT file', undefined);
-            if (!this.options.force) {
-                return;
-            }
+            return;
         }
         const headerLength = blob[0];
         if (headerLength !== 14 && headerLength !== 12) {
             callback('Incorrect header size', undefined);
-            if (!this.options.force) {
-                return;
-            }
+            return;
+        }
+        if (blob.length < headerLength) {
+            callback('File to small to be a FIT file', undefined);
+            return;
         }
         let fileTypeString = '';
         for (let i = 8; i < 12; i++) {
@@ -55,29 +55,33 @@ class FitParser {
         }
         if (fileTypeString !== '.FIT') {
             callback('Missing \'.FIT\' in header', undefined);
-            if (!this.options.force) {
-                return;
-            }
+            return;
         }
         if (headerLength === 14 && !this.options.force) {
             const crcHeader = blob[12] + (blob[13] << 8);
             const crcHeaderCalc = (0, binary_js_1.calculateCRC)(blob, 0, 12);
-            if (crcHeader !== crcHeaderCalc) {
-                // callback('Header CRC mismatch', {});
-                // TODO: fix Header CRC check
+            if (crcHeader !== 0 && crcHeader !== crcHeaderCalc) {
+                callback('Header CRC mismatch', undefined);
                 return;
             }
         }
         const protocolVersion = blob[1];
         const profileVersion = blob[2] + (blob[3] << 8);
-        const dataLength = blob[4] + (blob[5] << 8) + (blob[6] << 16) + (blob[7] << 24);
+        const dataLength = dataView.getUint32(4, true);
         const crcStart = dataLength + headerLength;
+        if (crcStart > blob.length) {
+            callback('File data exceeds input length', undefined);
+            return;
+        }
+        if (!this.options.force && crcStart + 2 > blob.length) {
+            callback('File CRC missing', undefined);
+            return;
+        }
         if (!this.options.force) {
             const crcFile = blob[crcStart] + (blob[crcStart + 1] << 8);
-            const crcFileCalc = (0, binary_js_1.calculateCRC)(blob, headerLength === 12 ? 0 : headerLength, crcStart);
+            const crcFileCalc = (0, binary_js_1.calculateCRC)(blob, 0, crcStart);
             if (crcFile !== crcFileCalc) {
-                // callback('File CRC mismatch', {});
-                // TODO: fix File CRC check
+                callback('File CRC mismatch', undefined);
                 return;
             }
         }
@@ -85,6 +89,7 @@ class FitParser {
             profileVersion,
             protocolVersion,
         };
+        const messages = {};
         let sessions = [];
         let laps = [];
         const records = [];
@@ -107,6 +112,7 @@ class FitParser {
         const tank_updates = [];
         const tank_summaries = [];
         const jumps = [];
+        const sets = [];
         const splits = [];
         const split_summaries = [];
         const time_in_zone = [];
@@ -115,14 +121,20 @@ class FitParser {
         let loopIndex = headerLength;
         const messageTypes = [];
         const developerFields = [];
+        const decoderState = {};
         const isModeCascade = this.options.mode === 'cascade';
         const isCascadeNeeded = isModeCascade || this.options.mode === 'both';
         let startDate;
         let lastStopTimestamp;
         let pausedTime = 0;
         while (loopIndex < crcStart) {
-            const { nextIndex, messageType, message } = (0, binary_js_1.readRecord)(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView);
+            const { nextIndex, messageType, message } = (0, binary_js_1.readRecord)(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView, decoderState);
             loopIndex = nextIndex;
+            if (messageType !== ''
+                && messageType !== 'definition'
+                && message !== undefined) {
+                ((_a = messages[messageType]) !== null && _a !== void 0 ? _a : (messages[messageType] = [])).push(message);
+            }
             switch (messageType) {
                 case 'lap':
                     laps.push(message);
@@ -210,6 +222,9 @@ class FitParser {
                 case 'jump':
                     jumps.push(message);
                     break;
+                case 'set':
+                    sets.push(message);
+                    break;
                 case 'split':
                     splits.push(message);
                     break;
@@ -250,15 +265,17 @@ class FitParser {
         fitObj.time_in_zone = time_in_zone;
         fitObj.activity_metrics = activity_metrics;
         fitObj.user_metrics = user_metrics;
+        fitObj.messages = messages;
         if (isCascadeNeeded) {
             laps = (0, helper_js_1.mapDataIntoLap)(laps, 'records', records);
             laps = (0, helper_js_1.mapDataIntoLap)(laps, 'lengths', lengths);
             sessions = (0, helper_js_1.mapDataIntoSession)(sessions, laps);
-            fitObj.activity = Object.assign(Object.assign({}, ((_a = fitObj.activity) !== null && _a !== void 0 ? _a : {})), { // ugly but we assume the activity was parsed correctly with all other members correctly
+            fitObj.activity = Object.assign(Object.assign({}, ((_b = fitObj.activity) !== null && _b !== void 0 ? _b : {})), { // ugly but we assume the activity was parsed correctly with all other members correctly
                 sessions,
                 events,
                 hrv,
                 device_infos, developer_data_ids: applications, field_descriptions: fieldDescriptions, sports,
+                sets,
                 splits,
                 split_summaries });
         }
@@ -272,6 +289,7 @@ class FitParser {
             fitObj.developer_data_ids = applications;
             fitObj.field_descriptions = fieldDescriptions;
             fitObj.hrv = hrv;
+            fitObj.sets = sets;
         }
         callback(undefined, fitObj);
     }