fit-file-parser 4.0.1 → 4.1.0

package/dist/binary.js

@@ -3,30 +3,47 @@ import { FIT } from './fit.js';
 import { getFitMessage, getFitMessageBaseType } from './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));
 }
 export function addEndian(littleEndian, bytes) {
     let result = 0;
@@ -37,77 +54,10 @@ export 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.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]) {
@@ -116,18 +66,57 @@ function readData(blob, dataView, fDef, startIndex, options) {
         }
         return 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) {
@@ -154,6 +143,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.types[type];
@@ -212,10 +211,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':
@@ -243,6 +241,27 @@ function isInvalidBaseTypeValue(data, baseTypeNo) {
     const baseType = 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.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.options[unitsList];
     const unit = options[unitName];
@@ -301,8 +320,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':
@@ -333,11 +354,59 @@ function applyGarminProductName(fields) {
         fields.product_name = productName;
     }
 }
-export function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime, dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength)) {
-    var _a, _b, _c, _d, _e;
+function resolveDeveloperFieldDefinition(developerFieldDef, littleEndian, developerFields, options) {
+    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;
+        developerFieldDef.resolvedFrom = undefined;
+        return undefined;
+    }
+    if (developerFieldDef.resolvedFrom === description
+        && developerFieldDef.resolvedFieldDef) {
+        return developerFieldDef.resolvedFieldDef;
+    }
+    const describedBaseType = description.fit_base_type_id;
+    const baseType = typeof describedBaseType === 'number'
+        ? describedBaseType
+        : Number((_b = Object.entries(FIT.types.fit_base_type).find(([, typeName]) => typeName === describedBaseType)) === null || _b === void 0 ? void 0 : _b[0]);
+    const type = FIT.types.fit_base_type[baseType];
+    if (!Number.isInteger(baseType) || type === undefined) {
+        developerFieldDef.resolvedFieldDef = undefined;
+        developerFieldDef.resolvedFrom = undefined;
+        if (options.force) {
+            return undefined;
+        }
+        throw new Error(`Unsupported base type for developer data index ${developerFieldDef.developerDataIndex}, field ${developerFieldDef.fieldDefinitionNumber}`);
+    }
+    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: (_d = description.field_name) !== null && _d !== void 0 ? _d : '',
+        dataType: getFitMessageBaseType(baseType & 15),
+        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,
+    };
+    developerFieldDef.resolvedFieldDef = resolvedFieldDef;
+    developerFieldDef.resolvedFrom = description;
+    return resolvedFieldDef;
+}
+export 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;
     }
@@ -358,63 +427,45 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             ]),
             numberOfFields: numberOfFields + numberOfDeveloperDataFields,
             fieldDefs: [],
+            developerFieldDefs: [],
             rawData: [],
         };
         const message = getFitMessage(mTypeDef.globalMessageNumber);
         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.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: 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);
         }
-        // numberOfDeveloperDataFields = 0 so it wont crash here and wont loop
         for (let i = 0; i < numberOfDeveloperDataFields; i++) {
-            // If we fail to parse then try catch
-            try {
-                const fDefIndex = startIndex + 6 + numberOfFields * 3 + 1 + i * 3;
-                const fieldNum = blob[fDefIndex];
-                const size = blob[fDefIndex + 1];
-                const devDataIndex = blob[fDefIndex + 2];
-                const devDef = developerFields[devDataIndex][fieldNum];
-                const baseType = devDef.fit_base_type_id;
-                const fDef = {
-                    type: FIT.types.fit_base_type[baseType],
-                    fDefNo: fieldNum,
-                    size,
-                    endianAbility: (baseType & 128) === 128,
-                    littleEndian: lEnd,
-                    baseTypeNo: baseType,
-                    name: devDef.field_name,
-                    dataType: getFitMessageBaseType(baseType & 15),
-                    scale: devDef.scale || 1,
-                    offset: devDef.offset || 0,
-                    requiresBoundedDataView: requiresBoundedEndianDataView(FIT.types.fit_base_type[baseType], size),
-                    developerDataIndex: devDataIndex,
-                    isDeveloperField: true,
-                };
-                mTypeDef.fieldDefs.push(fDef);
-            }
-            catch (e) {
-                if (options.force) {
-                    continue;
-                }
-                throw e;
-            }
+            const fDefIndex = startIndex + 6 + numberOfFields * 3 + 1 + i * 3;
+            (_a = mTypeDef.developerFieldDefs) === null || _a === void 0 ? void 0 : _a.push({
+                fieldDefinitionNumber: blob[fDefIndex],
+                size: blob[fDefIndex + 1],
+                developerDataIndex: blob[fDefIndex + 2],
+            });
         }
-        mTypeDef.rawData = Array.from({ length: mTypeDef.fieldDefs.length }, () => InvalidFieldData);
+        mTypeDef.rawData = Array.from({ length: mTypeDef.numberOfFields }, () => InvalidFieldData);
         messageTypes[localMessageType] = mTypeDef;
         const nextIndex = startIndex + 6 + mTypeDef.numberOfFields * 3;
         const nextIndexWithDeveloperData = nextIndex + 1;
@@ -424,20 +475,25 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         };
     }
     const messageType = messageTypes[localMessageType] || messageTypes[0];
-    // TODO: handle compressed header ((recordHeader & 128) == 128)
-    // uncompressed header
     let messageSize = 0;
     let readDataFromIndex = startIndex + 1;
     const fields = {};
     const message = getFitMessage(messageType.globalMessageNumber);
-    const rawData = (_a = messageType.rawData) !== null && _a !== void 0 ? _a : (messageType.rawData = Array.from({ length: messageType.fieldDefs.length }, () => InvalidFieldData));
+    const developerFieldDefs = (_b = messageType.developerFieldDefs) !== null && _b !== void 0 ? _b : [];
+    const totalFieldCount = messageType.fieldDefs.length + developerFieldDefs.length;
+    const rawData = (_c = messageType.rawData) !== null && _c !== void 0 ? _c : (messageType.rawData = Array.from({ length: totalFieldCount }, () => InvalidFieldData));
     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;
@@ -445,14 +501,53 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         readDataFromIndex += fDef.size;
         messageSize += fDef.size;
     }
+    for (let i = 0; i < developerFieldDefs.length; i++) {
+        const developerFieldDef = developerFieldDefs[i];
+        const rawDataIndex = messageType.fieldDefs.length + i;
+        const fDef = resolveDeveloperFieldDefinition(developerFieldDef, messageType.littleEndian, developerFields, options);
+        if (fDef) {
+            const data = readData(blob, dataView, fDef, readDataFromIndex);
+            if (data !== InvalidFieldData
+                && !isInvalidValue(data, fDef.type)
+                && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
+                rawData[rawDataIndex] = data;
+                validFieldCount++;
+            }
+            else {
+                rawData[rawDataIndex] = InvalidFieldData;
+            }
+        }
+        else {
+            rawData[rawDataIndex] = InvalidFieldData;
+        }
+        readDataFromIndex += developerFieldDef.size;
+        messageSize += developerFieldDef.size;
+    }
     for (let i = 0; i < messageType.fieldDefs.length; i++) {
         const data = rawData[i];
         if (data === InvalidFieldData) {
             continue;
         }
         const fDef = messageType.fieldDefs[i];
+        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++) {
+        const data = rawData[messageType.fieldDefs.length + i];
+        const fDef = developerFieldDefs[i].resolvedFieldDef;
+        if (data === InvalidFieldData || !fDef) {
+            continue;
+        }
         const field = fDef.name;
-        if (field !== 'unknown' && field !== '' && field !== undefined) {
+        if (field !== 'unknown' && field !== '') {
             fields[field] = data;
         }
     }
@@ -462,21 +557,44 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             continue;
         }
         const fDef = messageType.fieldDefs[i];
-        if (fDef.isDeveloperField) {
-            const field = fDef.name;
-            const { type } = fDef;
-            const scale = (_b = fDef.scale) !== null && _b !== void 0 ? _b : null;
-            const offset = (_c = fDef.offset) !== null && _c !== void 0 ? _c : 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 = (_d = fDef.scale) !== null && _d !== void 0 ? _d : null;
-            const offset = (_e = fDef.offset) !== null && _e !== void 0 ? _e : 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);
+                }
+            }
+        }
+    }
+    for (let i = 0; i < developerFieldDefs.length; i++) {
+        const data = rawData[messageType.fieldDefs.length + i];
+        const fDef = developerFieldDefs[i].resolvedFieldDef;
+        if (data === InvalidFieldData || !fDef) {
+            continue;
+        }
+        const field = fDef.name;
+        if (field !== 'unknown' && field !== '') {
+            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);
     if (validFieldCount > 0 && message.name === 'record' && options.elapsedRecordField) {
@@ -489,17 +607,20 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
         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/binary.d.ts

@@ -7,10 +7,22 @@ export interface MessageTypeDefinition {
     globalMessageNumber: number;
     numberOfFields: number;
     fieldDefs: FieldDefinition[];
+    developerFieldDefs?: DeveloperFieldDefinition[];
     rawData?: any[];
 }
+export interface DeveloperFieldDefinition {
+    developerDataIndex: number;
+    fieldDefinitionNumber: number;
+    size: number;
+    resolvedFieldDef?: FieldDefinition;
+    resolvedFrom?: unknown;
+}
+export interface DecoderState {
+    lastTimestamp?: number;
+    monitoringTimestamp?: number;
+}
 export declare function addEndian(littleEndian: boolean, bytes: number[]): number;
-export declare function readRecord(blob: Uint8Array, messageTypes: MessageTypeDefinition[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number, dataView?: DataView): {
+export declare function readRecord(blob: Uint8Array, messageTypes: MessageTypeDefinition[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number, dataView?: DataView, decoderState?: DecoderState): {
     messageType: MesgNum | '';
     nextIndex: number;
     message?: any;