fit-file-parser 5.2.1 → 6.1.1

package/dist/cjs/raw-message-reader.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FitMessageReaderError = void 0;
+exports.getFitBaseTypeId = getFitBaseTypeId;
+exports.readFitUnsignedField = readFitUnsignedField;
+exports.readFitStringField = readFitStringField;
+exports.readFitMessages = readFitMessages;
+exports.fitTimestampToUnixMilliseconds = fitTimestampToUnixMilliseconds;
+const FIT_EPOCH_MS = 631065600000;
+const FIT_BASE_TYPE_WIDTHS = new Map([
+    [0, 1],
+    [1, 1],
+    [2, 1],
+    [3, 2],
+    [4, 2],
+    [5, 4],
+    [6, 4],
+    [7, 1],
+    [8, 4],
+    [9, 8],
+    [10, 1],
+    [11, 2],
+    [12, 4],
+    [13, 1],
+    [14, 8],
+    [15, 8],
+    [16, 8],
+]);
+const FIT_UNSIGNED_SCALAR_BASE_TYPES = new Set([0, 2, 4, 6, 10, 11, 12, 13]);
+const CRC_TABLE = [
+    0,
+    0xCC01,
+    0xD801,
+    0x1400,
+    0xF001,
+    0x3C00,
+    0x2800,
+    0xE401,
+    0xA001,
+    0x6C00,
+    0x7800,
+    0xB401,
+    0x5000,
+    0x9C01,
+    0x8801,
+    0x4400,
+];
+/** Error thrown when the strict raw-message reader rejects a FIT input. */
+class FitMessageReaderError extends Error {
+    constructor(code) {
+        super(code);
+        this.name = 'FitMessageReaderError';
+        this.code = code;
+    }
+}
+exports.FitMessageReaderError = FitMessageReaderError;
+function calculateCRC(bytes) {
+    let value = 0;
+    for (const byte of bytes) {
+        value = (value >>> 4) ^ CRC_TABLE[value & 15] ^ CRC_TABLE[byte & 15];
+        value = (value >>> 4) ^ CRC_TABLE[value & 15] ^ CRC_TABLE[byte >>> 4];
+    }
+    return value;
+}
+/** Returns the five-bit FIT base-type identifier, or null for reserved/unknown values. */
+function getFitBaseTypeId(baseType) {
+    if (!Number.isInteger(baseType) || baseType < 0 || baseType > 0xFF) {
+        return null;
+    }
+    if (baseType & 0x60) {
+        return null;
+    }
+    const id = baseType & 0x1F;
+    return FIT_BASE_TYPE_WIDTHS.has(id) ? id : null;
+}
+function isValidFieldDefinition(field) {
+    const baseTypeId = getFitBaseTypeId(field.baseType);
+    const width = baseTypeId === null
+        ? undefined
+        : FIT_BASE_TYPE_WIDTHS.get(baseTypeId);
+    return width !== undefined
+        && field.size > 0
+        && (baseTypeId === 7 || field.size % width === 0);
+}
+/** Reads an unsigned one-, two-, or four-byte raw FIT field. */
+function readFitUnsignedField(field, expectedBaseType, size, littleEndian) {
+    if (!field) {
+        return undefined;
+    }
+    const expectedType = getFitBaseTypeId(expectedBaseType);
+    const actualType = getFitBaseTypeId(field.baseType);
+    const compatibleByte = size === 1
+        && expectedType !== null
+        && actualType !== null
+        && [0, 2, 13].includes(expectedType)
+        && [0, 2, 13].includes(actualType);
+    if (expectedType === null
+        || actualType === null
+        || !FIT_UNSIGNED_SCALAR_BASE_TYPES.has(expectedType)
+        || FIT_BASE_TYPE_WIDTHS.get(expectedType) !== size
+        || field.size !== size
+        || !(field.bytes instanceof Uint8Array)
+        || field.bytes.byteLength !== field.size
+        || (actualType !== expectedType && !compatibleByte)) {
+        throw new TypeError('FIT field does not match the expected unsigned type');
+    }
+    const view = new DataView(field.bytes.buffer, field.bytes.byteOffset, field.bytes.byteLength);
+    const value = size === 1
+        ? view.getUint8(0)
+        : size === 2
+            ? view.getUint16(0, littleEndian)
+            : view.getUint32(0, littleEndian);
+    const invalid = [10, 11, 12].includes(expectedType)
+        ? 0
+        : size === 1
+            ? 0xFF
+            : size === 2
+                ? 0xFFFF
+                : 0xFFFFFFFF;
+    return value === invalid ? undefined : value;
+}
+/** Reads UTF-8 bytes, removes trailing NUL padding, and preserves interior NUL separators. */
+function readFitStringField(field) {
+    if (!field) {
+        return undefined;
+    }
+    if (getFitBaseTypeId(field.baseType) !== 7
+        || field.size <= 0
+        || !(field.bytes instanceof Uint8Array)
+        || field.bytes.byteLength !== field.size) {
+        throw new TypeError('FIT field is not a string');
+    }
+    const value = new TextDecoder('utf-8', {
+        fatal: true,
+        ignoreBOM: true,
+    }).decode(field.bytes).replace(/\0+$/, '');
+    return value || undefined;
+}
+function readTimestamp(field, bytes, littleEndian) {
+    if (field.size !== 4 || (field.baseType & 0x1F) !== 6) {
+        throw new FitMessageReaderError('invalid_structure');
+    }
+    const value = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, littleEndian);
+    return value === 0xFFFFFFFF ? undefined : value;
+}
+function validateOptions(options) {
+    var _a;
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new FitMessageReaderError('invalid_input');
+    }
+    const maxInputBytes = (_a = options.maxInputBytes) !== null && _a !== void 0 ? _a : Number.POSITIVE_INFINITY;
+    if (maxInputBytes !== Number.POSITIVE_INFINITY
+        && (!Number.isSafeInteger(maxInputBytes) || maxInputBytes < 0)) {
+        throw new FitMessageReaderError('invalid_input');
+    }
+    if (options.messageNumbers === undefined) {
+        return { maxInputBytes };
+    }
+    if (!Array.isArray(options.messageNumbers)) {
+        throw new FitMessageReaderError('invalid_input');
+    }
+    const selectedMessages = new Set();
+    for (const messageNumber of options.messageNumbers) {
+        if (!Number.isSafeInteger(messageNumber)
+            || messageNumber < 0
+            || messageNumber > 0xFFFF) {
+            throw new FitMessageReaderError('invalid_input');
+        }
+        selectedMessages.add(messageNumber);
+    }
+    return { maxInputBytes, selectedMessages };
+}
+/**
+ * Strictly validates a FIT file and retains raw fields for selected messages.
+ * This entry point does not load the semantic FIT profile or format field values.
+ */
+function readFitMessages(input, options = {}) {
+    var _a;
+    const { maxInputBytes, selectedMessages } = validateOptions(options);
+    if (!(input instanceof ArrayBuffer) && !(input instanceof Uint8Array)) {
+        throw new FitMessageReaderError('invalid_input');
+    }
+    const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    if (bytes.length > maxInputBytes) {
+        throw new FitMessageReaderError('input_limit');
+    }
+    if (bytes.length < 14) {
+        throw new FitMessageReaderError('invalid_header');
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const headerSize = bytes[0];
+    if (headerSize !== 12 && headerSize !== 14) {
+        throw new FitMessageReaderError('invalid_header');
+    }
+    const dataEnd = headerSize + view.getUint32(4, true);
+    const protocolMajorVersion = bytes[1] >>> 4;
+    if ((protocolMajorVersion !== 1 && protocolMajorVersion !== 2)
+        || bytes[8] !== 0x2E
+        || bytes[9] !== 0x46
+        || bytes[10] !== 0x49
+        || bytes[11] !== 0x54
+        || dataEnd + 2 !== bytes.length) {
+        throw new FitMessageReaderError('invalid_header');
+    }
+    if (headerSize === 14
+        && view.getUint16(12, true) !== 0
+        && calculateCRC(bytes.subarray(0, 12)) !== view.getUint16(12, true)) {
+        throw new FitMessageReaderError('invalid_crc');
+    }
+    if (calculateCRC(bytes.subarray(0, dataEnd)) !== view.getUint16(dataEnd, true)) {
+        throw new FitMessageReaderError('invalid_crc');
+    }
+    const definitions = new Map();
+    const messageIndexes = new Map();
+    const messages = [];
+    const issues = [];
+    let cursor = headerSize;
+    let lastTimestamp;
+    const take = (size) => {
+        if (cursor + size > dataEnd) {
+            throw new FitMessageReaderError('invalid_structure');
+        }
+        const value = bytes.subarray(cursor, cursor + size);
+        cursor += size;
+        return value;
+    };
+    // `take` owns bounds checking and advances the shared cursor for every record component.
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (cursor < dataEnd) {
+        const recordHeader = take(1)[0];
+        const compressed = (recordHeader & 0x80) !== 0;
+        const localMessageNumber = compressed
+            ? (recordHeader >> 5) & 3
+            : recordHeader & 15;
+        if (!compressed && (recordHeader & 0x10) !== 0) {
+            throw new FitMessageReaderError('invalid_structure');
+        }
+        if (!compressed && (recordHeader & 0x40) !== 0) {
+            const definitionHeader = take(5);
+            if (definitionHeader[0] !== 0 || definitionHeader[1] > 1) {
+                throw new FitMessageReaderError('invalid_structure');
+            }
+            const littleEndian = definitionHeader[1] === 0;
+            const globalMessageNumber = littleEndian
+                ? definitionHeader[2] | (definitionHeader[3] << 8)
+                : (definitionHeader[2] << 8) | definitionHeader[3];
+            const selected = selectedMessages === undefined
+                || selectedMessages.has(globalMessageNumber);
+            const readFields = (count) => {
+                const fields = [];
+                const fieldNumbers = new Set();
+                for (let index = 0; index < count; index++) {
+                    const raw = take(3);
+                    const field = {
+                        fieldNumber: raw[0],
+                        size: raw[1],
+                        baseType: raw[2],
+                    };
+                    if (fieldNumbers.has(field.fieldNumber)
+                        || field.size === 0
+                        || (selected && !isValidFieldDefinition(field))) {
+                        throw new FitMessageReaderError('invalid_structure');
+                    }
+                    fieldNumbers.add(field.fieldNumber);
+                    fields.push(field);
+                }
+                return fields;
+            };
+            const fields = readFields(definitionHeader[4]);
+            const developerFields = [];
+            if ((recordHeader & 0x20) !== 0) {
+                const developerFieldKeys = new Set();
+                const count = take(1)[0];
+                for (let index = 0; index < count; index++) {
+                    const raw = take(3);
+                    const key = `${raw[2]}:${raw[0]}`;
+                    if (raw[1] === 0 || developerFieldKeys.has(key)) {
+                        throw new FitMessageReaderError('invalid_structure');
+                    }
+                    developerFieldKeys.add(key);
+                    developerFields.push({
+                        fieldNumber: raw[0],
+                        size: raw[1],
+                        developerDataIndex: raw[2],
+                    });
+                }
+            }
+            definitions.set(localMessageNumber, {
+                globalMessageNumber,
+                littleEndian,
+                fields,
+                developerFields,
+            });
+            continue;
+        }
+        if (!compressed && (recordHeader & 0x20) !== 0) {
+            throw new FitMessageReaderError('invalid_structure');
+        }
+        const definition = definitions.get(localMessageNumber);
+        if (!definition) {
+            throw new FitMessageReaderError('invalid_structure');
+        }
+        const messageIndex = (_a = messageIndexes.get(definition.globalMessageNumber)) !== null && _a !== void 0 ? _a : 0;
+        messageIndexes.set(definition.globalMessageNumber, messageIndex + 1);
+        const selected = selectedMessages === undefined
+            || selectedMessages.has(definition.globalMessageNumber);
+        let timestamp;
+        let compressedTimestamp;
+        if (compressed) {
+            const timestampField = definition.fields[0];
+            if (!timestampField
+                || timestampField.fieldNumber !== 253
+                || timestampField.baseType !== 0x86
+                || timestampField.size !== 4
+                || lastTimestamp === undefined) {
+                throw new FitMessageReaderError('invalid_structure');
+            }
+            timestamp = Math.floor(lastTimestamp / 32) * 32 + (recordHeader & 31);
+            if (timestamp < lastTimestamp) {
+                timestamp += 32;
+            }
+            if (timestamp >= 0xFFFFFFFF) {
+                throw new FitMessageReaderError('invalid_structure');
+            }
+            lastTimestamp = timestamp;
+            compressedTimestamp = timestamp;
+        }
+        const fields = [];
+        for (const field of definition.fields) {
+            if (compressed && field.fieldNumber === 253) {
+                continue;
+            }
+            const raw = take(field.size);
+            if (field.fieldNumber === 253) {
+                try {
+                    timestamp = readTimestamp(field, raw, definition.littleEndian);
+                    lastTimestamp = timestamp;
+                }
+                catch (_b) {
+                    lastTimestamp = undefined;
+                    issues.push({
+                        code: 'invalid_timestamp',
+                        globalMessageNumber: definition.globalMessageNumber,
+                        messageIndex,
+                    });
+                }
+            }
+            if (selected) {
+                fields.push(Object.assign(Object.assign({}, field), { bytes: raw.slice() }));
+            }
+        }
+        const developerFields = [];
+        for (const field of definition.developerFields) {
+            const raw = take(field.size);
+            if (selected) {
+                developerFields.push(Object.assign(Object.assign({}, field), { bytes: raw.slice() }));
+            }
+        }
+        if (selected) {
+            messages.push(Object.assign(Object.assign(Object.assign({ globalMessageNumber: definition.globalMessageNumber, messageIndex, littleEndian: definition.littleEndian }, (timestamp === undefined ? {} : { timestamp })), (compressedTimestamp === undefined ? {} : { compressedTimestamp })), { fields,
+                developerFields }));
+        }
+    }
+    return {
+        protocolVersion: bytes[1],
+        profileVersion: view.getUint16(2, true),
+        messages,
+        issues,
+    };
+}
+/** Converts a native FIT timestamp to a JavaScript epoch millisecond value. */
+function fitTimestampToUnixMilliseconds(timestamp) {
+    if (!Number.isSafeInteger(timestamp) || timestamp < 0 || timestamp >= 0xFFFFFFFF) {
+        throw new RangeError('FIT timestamp must be an integer between 0 and 4294967294');
+    }
+    return FIT_EPOCH_MS + timestamp * 1000;
+}

package/dist/cjs/type_generator.js

@@ -285,6 +285,7 @@ function generateFitType() {
         generateProperty('messages', typescript_1.default.factory.createTypeReferenceNode('ParsedMessages')),
         generateArrayProperty('raw_developer_fields', typescript_1.default.factory.createTypeReferenceNode('ParsedRawDeveloperField')),
         generateArrayProperty('raw_messages', typescript_1.default.factory.createTypeReferenceNode('ParsedRawFitMessage')),
+        generateArrayProperty('unmapped_messages', typescript_1.default.factory.createTypeReferenceNode('ParsedRawFitMessage')),
         ...Object.keys(referenceProperties).map(prop => generateProperty(prop, typescript_1.default.factory.createTypeReferenceNode(snakeToCamel(referenceProperties[prop].replace('?', ''))), referenceProperties[prop].startsWith('?'))),
         ...Object.keys(collectionProperties).map(prop => generateArrayProperty(prop, collectionProperties[prop] === 'unknown'
             ? typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.UnknownKeyword)

package/dist/fit-parser.d.ts

@@ -3,6 +3,9 @@ import type { ParsedFit } from './fit_types.js';
 export { FitBaseType, FitEncoder } from './fit-encoder.js';
 export type { FitEncoderField, FitEncoderOptions } from './fit-encoder.js';
 export type { ParsedFit, ParsedRawDeveloperField, ParsedRawFitField, ParsedRawFitMessage, ParsedRawFitMessageDeveloperField, } from './fit_types.js';
+export { getFitCoursePointId, getFitGarminProductDisplayName, getFitGarminProductName, getFitManufacturerName, getFitSportId, getFitSportName, getFitSubSportId, getFitSubSportName, } from './profile-lookup.js';
+export { FitMessageReaderError, fitTimestampToUnixMilliseconds, getFitBaseTypeId, readFitMessages, readFitStringField, readFitUnsignedField, } from './raw-message-reader.js';
+export type { FitMessageReaderErrorCode, FitMessageReaderIssue, FitMessageReaderIssueCode, FitMessageReaderOptions, FitMessageReaderResult, FitRawDeveloperField, FitRawField, FitRawMessage, } from './raw-message-reader.js';
 export interface FitParserOptions {
     force?: boolean;
     speedUnit?: string;
@@ -15,6 +18,8 @@ export interface FitParserOptions {
     includeRawDeveloperFields?: boolean | readonly number[];
     /** Retains exact native and developer fields for all or selected global message numbers. */
     includeRawMessages?: boolean | readonly number[];
+    /** Retains exact bytes for fields that have no semantic profile mapping. */
+    includeUnmappedMessages?: boolean;
     /** Returns only parser metadata and retained raw messages instead of decoded activity collections. */
     rawMessagesOnly?: boolean;
 }

package/dist/fit-parser.js

@@ -1,9 +1,11 @@
 import { calculateCRC, readRecord } from './binary.js';
 import { mapDataIntoLap, mapDataIntoSession } from './helper.js';
 export { FitBaseType, FitEncoder } from './fit-encoder.js';
+export { getFitCoursePointId, getFitGarminProductDisplayName, getFitGarminProductName, getFitManufacturerName, getFitSportId, getFitSportName, getFitSubSportId, getFitSubSportName, } from './profile-lookup.js';
+export { FitMessageReaderError, fitTimestampToUnixMilliseconds, getFitBaseTypeId, readFitMessages, readFitStringField, readFitUnsignedField, } from './raw-message-reader.js';
 export default class FitParser {
     constructor(options = {}) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this.options = {
             force: options.force != null ? options.force : true,
             speedUnit: options.speedUnit || 'm/s',
@@ -14,7 +16,8 @@ export default class FitParser {
             mode: options.mode || 'list',
             includeRawDeveloperFields: (_a = options.includeRawDeveloperFields) !== null && _a !== void 0 ? _a : false,
             includeRawMessages: (_b = options.includeRawMessages) !== null && _b !== void 0 ? _b : false,
-            rawMessagesOnly: (_c = options.rawMessagesOnly) !== null && _c !== void 0 ? _c : false,
+            includeUnmappedMessages: (_c = options.includeUnmappedMessages) !== null && _c !== void 0 ? _c : false,
+            rawMessagesOnly: (_d = options.rawMessagesOnly) !== null && _d !== void 0 ? _d : false,
         };
     }
     parseAsync(content) {
@@ -125,6 +128,7 @@ export default class FitParser {
             || Array.isArray(this.options.includeRawMessages)
             ? []
             : undefined;
+        const unmappedMessages = this.options.includeUnmappedMessages ? [] : undefined;
         const messageCountsByGlobalNumber = new Map();
         let loopIndex = headerLength;
         const messageTypes = [];
@@ -136,7 +140,7 @@ export default class FitParser {
         let lastStopTimestamp;
         let pausedTime = 0;
         while (loopIndex < crcStart) {
-            const { globalMessageNumber, littleEndian, message, messageType, nextIndex, compressedTimestamp, rawFields: recordRawFields, rawDeveloperFields: recordRawDeveloperFields, } = readRecord(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView, decoderState, crcStart);
+            const { globalMessageNumber, littleEndian, message, messageType, nextIndex, compressedTimestamp, rawFields: recordRawFields, rawDeveloperFields: recordRawDeveloperFields, unmappedFields: recordUnmappedFields, unmappedDeveloperFields: recordUnmappedDeveloperFields, } = readRecord(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView, decoderState, crcStart);
             loopIndex = nextIndex;
             if (globalMessageNumber !== undefined) {
                 const messageIndex = (_a = messageCountsByGlobalNumber.get(globalMessageNumber)) !== null && _a !== void 0 ? _a : 0;
@@ -163,6 +167,20 @@ export default class FitParser {
                         raw_value: field.rawValue,
                     });
                 });
+                if (littleEndian !== undefined
+                    && ((recordUnmappedFields === null || recordUnmappedFields === void 0 ? void 0 : recordUnmappedFields.length) || (recordUnmappedDeveloperFields === null || recordUnmappedDeveloperFields === void 0 ? void 0 : recordUnmappedDeveloperFields.length))) {
+                    unmappedMessages === null || unmappedMessages === void 0 ? void 0 : unmappedMessages.push(Object.assign(Object.assign({ global_message_number: globalMessageNumber, message_index: messageIndex, little_endian: littleEndian }, (compressedTimestamp === undefined
+                        ? {}
+                        : { compressed_timestamp: compressedTimestamp })), { fields: (recordUnmappedFields !== null && recordUnmappedFields !== void 0 ? recordUnmappedFields : []).map(field => ({
+                            field_definition_number: field.fieldDefinitionNumber,
+                            base_type: field.baseType,
+                            raw_value: field.rawValue,
+                        })), developer_fields: (recordUnmappedDeveloperFields !== null && recordUnmappedDeveloperFields !== void 0 ? recordUnmappedDeveloperFields : []).map(field => ({
+                            developer_data_index: field.developerDataIndex,
+                            field_definition_number: field.fieldDefinitionNumber,
+                            raw_value: field.rawValue,
+                        })) }));
+                }
             }
             if (this.options.rawMessagesOnly) {
                 continue;
@@ -293,6 +311,9 @@ export default class FitParser {
             if (rawMessages) {
                 fitObj.raw_messages = rawMessages;
             }
+            if (unmappedMessages && unmappedMessages.length > 0) {
+                fitObj.unmapped_messages = unmappedMessages;
+            }
             callback(undefined, fitObj);
             return;
         }
@@ -321,6 +342,9 @@ export default class FitParser {
         if (rawMessages) {
             fitObj.raw_messages = rawMessages;
         }
+        if (unmappedMessages && unmappedMessages.length > 0) {
+            fitObj.unmapped_messages = unmappedMessages;
+        }
         if (isCascadeNeeded) {
             laps = mapDataIntoLap(laps, 'records', records);
             laps = mapDataIntoLap(laps, 'lengths', lengths);

package/dist/fit.d.ts

@@ -37,10 +37,4 @@ export interface FitType {
     messages: Record<number, Message>;
     types: Record<string, Record<number, string | number>>;
 }
-/**
- * Garmin fields observed in the external FIT corpus but absent from the pinned
- * public SDK profile. These additions may not replace standard SDK fields.
- */
-export declare const FIT_VENDOR_MESSAGE_EXTENSIONS: Record<number, Message>;
-export declare const FIT_VENDOR_TYPE_EXTENSIONS: Record<string, Record<number, string>>;
 export declare const FIT: FitType;

package/dist/fit.js

@@ -1,4 +1,4 @@
-import { GARMIN_MESSAGES, GARMIN_TYPES } from './garmin_profile.generated.js';
+import { PROFILE_MESSAGES, PROFILE_TYPES } from './profile.js';
 const metersInOneKilometer = 1000;
 const secondsInOneHour = 3600;
 // according to https://en.wikipedia.org/wiki/Mile
@@ -28,119 +28,9 @@ const options = {
         psi: { multiplier: psiInOneBar, offset: 0 },
     },
 };
-/**
- * Garmin fields observed in the external FIT corpus but absent from the pinned
- * public SDK profile. These additions may not replace standard SDK fields.
- */
-export const FIT_VENDOR_MESSAGE_EXTENSIONS = {
-    18: {
-        name: 'session',
-        178: field('est_sweat_loss', 'uint16', 1, 'ml'),
-        188: field('primary_benefit', 'uint8'),
-        205: field('beginning_potential_stamina', 'uint8', 1, 'percent'),
-        206: field('ending_potential_stamina', 'uint8', 1, 'percent'),
-        207: field('min_stamina', 'uint8', 1, 'percent'),
-    },
-    20: {
-        name: 'record',
-        90: field('garmin_performance_condition', 'sint8'),
-        137: field('potential_stamina', 'uint8', 1, 'percent'),
-        138: field('stamina', 'uint8', 1, 'percent'),
-    },
-    23: {
-        name: 'device_info',
-        24: field('ant_id', 'uint32z'),
-    },
-    // Undocumented Garmin user metrics message observed in activity FIT files.
-    79: {
-        name: 'user_metrics',
-        0: field('vo2_max', 'uint16', 1024 / 3.5, 'ml/kg/min'),
-        1: field('age', 'uint8', 1, 'years'),
-        2: field('height', 'uint8', 100, 'm'),
-        3: field('weight', 'uint16', 10, 'kg'),
-        4: field('gender', 'gender'),
-        6: field('max_heart_rate', 'uint8', 1, 'bpm'),
-        8: field('remaining_recovery_time', 'uint16'),
-        11: field('lthr', 'uint16', 1, 'bpm'),
-        12: field('ltpower', 'uint16', 1, 'watts'),
-        13: field('ltspeed', 'uint16', 1000, 'm/s'),
-        16: field('start_of_activity', 'date_time'),
-        19: field('first_vo2_max', 'uint32', 65536 / 3.5, 'ml/kg/min'),
-        35: field('end_of_previous_activity', 'date_time'),
-        253: field('timestamp', 'date_time'),
-    },
-    // Undocumented Garmin activity metrics message observed in activity FIT files.
-    140: {
-        name: 'activity_metrics',
-        1: field('new_max_heart_rate', 'uint8', 1, 'bpm'),
-        4: field('aerobic_training_effect', 'uint8', 10),
-        7: field('vo2_max', 'uint32', 65536 / 3.5, 'ml/kg/min'),
-        9: field('recovery_time', 'uint16', 1, 'min'),
-        11: field('sport', 'sport'),
-        20: field('anaerobic_training_effect', 'uint8', 10),
-        29: field('first_vo2_max', 'uint32', 65536 / 3.5, 'ml/kg/min'),
-        41: field('primary_benefit', 'uint8'),
-        60: field('total_ascent', 'uint16', 1, 'm'),
-        61: field('total_descent', 'uint16', 1, 'm'),
-        62: field('avg_power', 'uint16', 1, 'watts'),
-        63: field('avg_heart_rate', 'uint8', 1, 'bpm'),
-    },
-    312: {
-        name: 'split',
-        107: field('beginning_potential_stamina', 'uint8', 1, 'percent'),
-        108: field('ending_potential_stamina', 'uint8', 1, 'percent'),
-        109: field('min_stamina', 'uint8', 1, 'percent'),
-    },
-};
-export const FIT_VENDOR_TYPE_EXTENSIONS = {
-    mesg_num: {
-        79: 'user_metrics',
-        140: 'activity_metrics',
-    },
-};
-function field(name, type, scale = 1, units = '', baseType) {
-    return Object.assign(Object.assign({ field: name, type }, (baseType ? { baseType } : {})), { scale, offset: 0, units });
-}
-function mergeVendorMessages() {
-    const messages = Object.assign({}, GARMIN_MESSAGES);
-    Object.entries(FIT_VENDOR_MESSAGE_EXTENSIONS).forEach(([messageIdText, extension]) => {
-        const messageId = Number(messageIdText);
-        const standardMessage = messages[messageId];
-        if (!standardMessage) {
-            messages[messageId] = extension;
-            return;
-        }
-        if (standardMessage.name !== extension.name) {
-            throw new Error(`Vendor message ${messageId} conflicts with the Garmin SDK name`);
-        }
-        Object.keys(extension)
-            .filter(key => key !== 'name')
-            .forEach((fieldId) => {
-            if (standardMessage[Number(fieldId)]) {
-                throw new Error(`Vendor message ${messageId}, field ${fieldId} conflicts with the Garmin SDK profile`);
-            }
-        });
-        messages[messageId] = Object.assign(Object.assign({}, standardMessage), extension);
-    });
-    return messages;
-}
-function mergeVendorTypes() {
-    const types = Object.fromEntries(Object.entries(GARMIN_TYPES).map(([name, values]) => [name, Object.assign({}, values)]));
-    Object.entries(FIT_VENDOR_TYPE_EXTENSIONS).forEach(([name, extension]) => {
-        var _a;
-        const standardValues = (_a = types[name]) !== null && _a !== void 0 ? _a : {};
-        Object.keys(extension).forEach((valueId) => {
-            if (standardValues[Number(valueId)] !== undefined) {
-                throw new Error(`Vendor type ${name}, value ${valueId} conflicts with the Garmin SDK profile`);
-            }
-        });
-        types[name] = Object.assign(Object.assign({}, standardValues), extension);
-    });
-    return types;
-}
 export const FIT = {
     scConst: 180 / Math.pow(2, 31),
     options,
-    messages: mergeVendorMessages(),
-    types: mergeVendorTypes(),
+    messages: PROFILE_MESSAGES,
+    types: PROFILE_TYPES,
 };

package/dist/fit_types.d.ts

@@ -213,7 +213,7 @@ export type SportEvent = 'uncategorized' | 'geocaching' | 'fitness' | 'recreatio
 export type SquatExerciseName = 'leg_press' | 'back_squat_with_body_bar' | 'back_squats' | 'weighted_back_squats' | 'balancing_squat' | 'weighted_balancing_squat' | 'barbell_back_squat' | 'barbell_box_squat' | 'barbell_front_squat' | 'barbell_hack_squat' | 'barbell_hang_squat_snatch' | 'barbell_lateral_step_up' | 'barbell_quarter_squat' | 'barbell_siff_squat' | 'barbell_squat_snatch' | 'barbell_squat_with_heels_raised' | 'barbell_stepover' | 'barbell_step_up' | 'bench_squat_with_rotational_chop' | 'weighted_bench_squat_with_rotational_chop' | 'body_weight_wall_squat' | 'weighted_wall_squat' | 'box_step_squat' | 'weighted_box_step_squat' | 'braced_squat' | 'crossed_arm_barbell_front_squat' | 'crossover_dumbbell_step_up' | 'dumbbell_front_squat' | 'dumbbell_split_squat' | 'dumbbell_squat' | 'dumbbell_squat_clean' | 'dumbbell_stepover' | 'dumbbell_step_up' | 'elevated_single_leg_squat' | 'weighted_elevated_single_leg_squat' | 'figure_four_squats' | 'weighted_figure_four_squats' | 'goblet_squat' | 'kettlebell_squat' | 'kettlebell_swing_overhead' | 'kettlebell_swing_with_flip_to_squat' | 'lateral_dumbbell_step_up' | 'one_legged_squat' | 'overhead_dumbbell_squat' | 'overhead_squat' | 'partial_single_leg_squat' | 'weighted_partial_single_leg_squat' | 'pistol_squat' | 'weighted_pistol_squat' | 'plie_slides' | 'weighted_plie_slides' | 'plie_squat' | 'weighted_plie_squat' | 'prisoner_squat' | 'weighted_prisoner_squat' | 'single_leg_bench_get_up' | 'weighted_single_leg_bench_get_up' | 'single_leg_bench_squat' | 'weighted_single_leg_bench_squat' | 'single_leg_squat_on_swiss_ball' | 'weighted_single_leg_squat_on_swiss_ball' | 'squat' | 'weighted_squat' | 'squats_with_band' | 'staggered_squat' | 'weighted_staggered_squat' | 'step_up' | 'weighted_step_up' | 'suitcase_squats' | 'sumo_squat' | 'sumo_squat_slide_in' | 'weighted_sumo_squat_slide_in' | 'sumo_squat_to_high_pull' | 'sumo_squat_to_stand' | 'weighted_sumo_squat_to_stand' | 'sumo_squat_with_rotation' | 'weighted_sumo_squat_with_rotation' | 'swiss_ball_body_weight_wall_squat' | 'weighted_swiss_ball_wall_squat' | 'thrusters' | 'uneven_squat' | 'weighted_uneven_squat' | 'waist_slimming_squat' | 'wall_ball' | 'wide_stance_barbell_squat' | 'wide_stance_goblet_squat' | 'zercher_squat' | 'kbs_overhead' | 'squat_and_side_kick' | 'squat_jumps_in_n_out' | 'pilates_plie_squats_parallel_turned_out_flat_and_heels' | 'releve_straight_leg_and_knee_bent_with_one_leg_variation' | 'alternating_box_dumbbell_step_ups' | 'dumbbell_overhead_squat_single_arm' | 'dumbbell_squat_snatch' | 'medicine_ball_squat' | 'wall_ball_squat_and_press' | 'squat_american_swing' | 'air_squat' | 'dumbbell_thrusters' | 'overhead_barbell_squat' | number;
 export type StairStepperExerciseName = 'stair_stepper' | number;
 export type StrokeType = 'no_event' | 'other' | 'serve' | 'forehand' | 'backhand' | 'smash' | number;
-export type SubSport = 'generic' | 'treadmill' | 'street' | 'trail' | 'track' | 'spin' | 'indoor_cycling' | 'road' | 'mountain' | 'downhill' | 'recumbent' | 'cyclocross' | 'hand_cycling' | 'track_cycling' | 'indoor_rowing' | 'elliptical' | 'stair_climbing' | 'lap_swimming' | 'open_water' | 'flexibility_training' | 'strength_training' | 'warm_up' | 'match' | 'exercise' | 'challenge' | 'indoor_skiing' | 'cardio_training' | 'indoor_walking' | 'e_bike_fitness' | 'bmx' | 'casual_walking' | 'speed_walking' | 'bike_to_run_transition' | 'run_to_bike_transition' | 'swim_to_bike_transition' | 'atv' | 'motocross' | 'backcountry' | 'resort' | 'rc_drone' | 'wingsuit' | 'whitewater' | 'skate_skiing' | 'yoga' | 'pilates' | 'indoor_running' | 'gravel_cycling' | 'e_bike_mountain' | 'commuting' | 'mixed_surface' | 'navigate' | 'track_me' | 'map' | 'single_gas_diving' | 'multi_gas_diving' | 'gauge_diving' | 'apnea_diving' | 'apnea_hunting' | 'virtual_activity' | 'obstacle' | 'breathing' | 'ccr_diving' | 'sail_race' | 'expedition' | 'ultra' | 'indoor_climbing' | 'bouldering' | 'hiit' | 'indoor_grinding' | 'hunting_with_dogs' | 'amrap' | 'emom' | 'tabata' | 'esport' | 'triathlon' | 'duathlon' | 'brick' | 'swim_run' | 'adventure_race' | 'trucker_workout' | 'pickleball' | 'padel' | 'indoor_wheelchair_walk' | 'indoor_wheelchair_run' | 'indoor_hand_cycling' | 'field' | 'ice' | 'ultimate' | 'platform' | 'squash' | 'badminton' | 'racquetball' | 'table_tennis' | 'overland' | 'trolling_motor' | 'fly_canopy' | 'fly_paraglide' | 'fly_paramotor' | 'fly_pressurized' | 'fly_navigate' | 'fly_timer' | 'fly_altimeter' | 'fly_wx' | 'fly_vfr' | 'fly_ifr' | 'dynamic_apnea' | 'enduro' | 'rucking' | 'rally' | 'pool_triathlon' | 'e_bike_enduro' | 'all' | number;
+export type SubSport = 'generic' | 'treadmill' | 'street' | 'trail' | 'track' | 'spin' | 'indoor_cycling' | 'road' | 'mountain' | 'downhill' | 'recumbent' | 'cyclocross' | 'hand_cycling' | 'track_cycling' | 'indoor_rowing' | 'elliptical' | 'stair_climbing' | 'lap_swimming' | 'open_water' | 'flexibility_training' | 'strength_training' | 'warm_up' | 'match' | 'exercise' | 'challenge' | 'indoor_skiing' | 'cardio_training' | 'indoor_walking' | 'e_bike_fitness' | 'bmx' | 'casual_walking' | 'speed_walking' | 'bike_to_run_transition' | 'run_to_bike_transition' | 'swim_to_bike_transition' | 'atv' | 'motocross' | 'backcountry' | 'resort' | 'rc_drone' | 'wingsuit' | 'whitewater' | 'skate_skiing' | 'yoga' | 'pilates' | 'indoor_running' | 'gravel_cycling' | 'e_bike_mountain' | 'commuting' | 'mixed_surface' | 'navigate' | 'track_me' | 'map' | 'single_gas_diving' | 'multi_gas_diving' | 'gauge_diving' | 'apnea_diving' | 'apnea_hunting' | 'virtual_activity' | 'obstacle' | 'breathing' | 'ccr_diving' | 'sail_race' | 'expedition' | 'ultra' | 'indoor_climbing' | 'bouldering' | 'hiit' | 'indoor_grinding' | 'hunting_with_dogs' | 'amrap' | 'emom' | 'tabata' | 'esport' | 'triathlon' | 'duathlon' | 'brick' | 'swim_run' | 'adventure_race' | 'trucker_workout' | 'pickleball' | 'padel' | 'indoor_wheelchair_walk' | 'indoor_wheelchair_run' | 'indoor_hand_cycling' | 'field' | 'ice' | 'ultimate' | 'platform' | 'squash' | 'badminton' | 'racquetball' | 'table_tennis' | 'overland' | 'trolling_motor' | 'fly_canopy' | 'fly_paraglide' | 'fly_paramotor' | 'fly_pressurized' | 'fly_navigate' | 'fly_timer' | 'fly_altimeter' | 'fly_wx' | 'fly_vfr' | 'fly_ifr' | 'dynamic_apnea' | 'enduro' | 'rucking' | 'rally' | 'pool_triathlon' | 'e_bike_enduro' | 'mountain_enduro' | 'mountain_downhill' | 'all' | number;
 export type SupportedExdScreenLayouts = 'full_screen' | 'half_vertical' | 'half_horizontal' | 'half_vertical_right_split' | 'half_horizontal_bottom_split' | 'full_quarter_split' | 'half_vertical_left_split' | 'half_horizontal_top_split' | number;
 export type SuspensionExerciseName = 'chest_fly' | 'chest_press' | 'crunch' | 'curl' | 'dip' | 'face_pull' | 'glute_bridge' | 'hamstring_curl' | 'hip_drop' | 'inverted_row' | 'knee_drive_jump' | 'knee_to_chest' | 'lat_pullover' | 'lunge' | 'mountain_climber' | 'pendulum' | 'pike' | 'plank' | 'power_pull' | 'pull_up' | 'push_up' | 'reverse_mountain_climber' | 'reverse_plank' | 'rollout' | 'row' | 'side_lunge' | 'side_plank' | 'single_leg_deadlift' | 'single_leg_squat' | 'sit_up' | 'split' | 'squat' | 'squat_jump' | 'tricep_press' | 'y_fly' | number;
 export type SwimStroke = 'freestyle' | 'backstroke' | 'breaststroke' | 'butterfly' | 'drill' | 'mixed' | 'im' | 'im_by_round' | 'rimo' | number;
@@ -2097,6 +2097,7 @@ export interface ParsedFit {
     messages?: ParsedMessages;
     raw_developer_fields?: ParsedRawDeveloperField[];
     raw_messages?: ParsedRawFitMessage[];
+    unmapped_messages?: ParsedRawFitMessage[];
     file_creator: ParsedFileCreator;
     device_settings: ParsedDeviceSettings;
     dive_summary?: ParsedDiveSummary;