@sports-alliance/sports-lib/lib/esm/index.js

A Library to for importing / exporting and processing GPX, TCX, FIT and JSON files from services such as Strava, Movescount, Garmin, Polar etc

// src/data/data.interface.ts
var UnitSystem = /* @__PURE__ */ ((UnitSystem2) => {
  UnitSystem2[UnitSystem2["Metric"] = 0] = "Metric";
  UnitSystem2[UnitSystem2["Imperial"] = 1] = "Imperial";
  return UnitSystem2;
})(UnitSystem || {});

// src/events/utilities/helpers.ts
function isNumberOrString(property) {
  return typeof property === "number" || typeof property === "string";
}
function isNumber(property) {
  return typeof property === "number" && !isNaN(property);
}
function convertSpeedToPace(number) {
  return number === 0 ? Infinity : 1e3 / number;
}
function convertSpeedToSwimPace(number) {
  return number === 0 ? Infinity : 100 / number;
}
function convertSwimPaceToSpeed(number) {
  return number === 0 ? Infinity : 100 / number;
}
function convertSpeedToSpeedInKilometersPerHour(number) {
  return number * 3.6;
}
function convertSpeedToSpeedInMilesPerHour(number) {
  return number * 2.237;
}
function convertSpeedToSpeedInFeetPerSecond(number) {
  return number * 3.28084;
}
function convertSpeedToSpeedInMetersPerMinute(number) {
  return number * 60;
}
function convertSpeedToSpeedInFeetPerMinute(number) {
  return number * 196.85;
}
function convertSpeedToSpeedInFeetPerHour(number) {
  return number * 11811.024;
}
function convertSpeedToSpeedInMetersPerHour(number) {
  return number * 3600;
}
function convertSpeedToSpeedInKnots(number) {
  return number * 1.943844;
}
function convertPaceToPaceInMinutesPerMile(number) {
  return number * 1.60934;
}
function convertMetersToMiles(number) {
  return number === 0 ? 0 : number / 1609;
}
function convertMetersToFeet(number) {
  return number * 3.28084;
}
function convertSwimPaceToSwimPacePer100Yard(number) {
  return number * 0.9144;
}
function getSize(obj) {
  return getSizeWithOptionalFormat(obj, false);
}
function getSizeFormated(obj) {
  return getSizeWithOptionalFormat(obj, true);
}
function getSizeWithOptionalFormat(obj, format = true) {
  let size;
  try {
    size = new Blob([obj]).size;
  } catch {
    size = Buffer.from(obj).length;
  }
  function formatByteSize(bytes) {
    if (bytes < 1024) {
      return bytes + " bytes";
    } else if (bytes < 1048576) {
      return (bytes / 1024).toFixed(4) + " KiB";
    } else if (bytes < 1073741824) {
      return (bytes / 1048576).toFixed(4) + " MiB";
    } else {
      return (bytes / 1073741824).toFixed(4) + " GiB";
    }
  }
  return format ? formatByteSize(size) : size;
}
function fillMissingValuesLinear(array) {
  let i = 0, j, delta;
  while (i < array.length) {
    if (array[i] !== null) {
      i++;
      continue;
    }
    j = i;
    while (array[++j] === null) {
    }
    delta = (array[j] - array[i - 1]) / (j - i + 1);
    do {
      array[i] = delta + array[i - 1];
      i++;
    } while (i < j);
  }
  return array;
}
var mean = (array) => {
  return array.reduce((a, b) => a + b, 0) / array.length;
};
var meanWindowSmoothing = (array, windowSize = 7, roundDecimals = 3) => {
  const roundDecimalsFactor = 10 ** roundDecimals;
  return array.map((value, index) => {
    const window = array.slice(index, index + windowSize);
    return Math.round(mean(window) * roundDecimalsFactor) / roundDecimalsFactor;
  });
};
var median = (inputArray) => {
  const s = inputArray.slice().sort((a, b) => {
    return a - b;
  });
  return s[Math.floor((s.length - 1) / 2)];
};
var medianFilter = (array, window = 11) => {
  if (window % 2 === 0) {
    throw new Error("Window size should be an odd number");
  }
  if (array.length < window) {
    return array;
  }
  const f = [];
  const w = [];
  let i;
  w.push(array[0]);
  for (i = 0; i < array.length; i++) {
    const midWindowIndex = Math.floor(window / 2);
    if (array.length - 1 >= i + midWindowIndex) {
      w.push(array[i + midWindowIndex]);
    }
    f.push(median(w));
    if (i >= midWindowIndex) {
      w.shift();
    }
  }
  return f;
};
var standardDeviation = (stream) => {
  const avg = mean(stream);
  const variance = mean(stream.map((value) => Math.pow(value, 2))) - Math.pow(avg, 2);
  return variance > 0 ? Math.sqrt(variance) : 0;
};

// src/data/data.ts
var Data = class {
  static {
    this.unitSystem = 0 /* Metric */;
  }
  constructor(value) {
    if (!this.getType()) {
      throw new Error("Type not set");
    }
    if (!this.isValueTypeValid(value)) {
      throw new Error("Value is not boolean or number or string or Date or position");
    }
    this.value = value;
  }
  setValue(value) {
    if (!this.isValueTypeValid(value)) {
      throw new Error("Value is not boolean or number or string or Date or position");
    }
    this.value = value;
    return this;
  }
  getValue(_formatForDataType) {
    return this.value;
  }
  getDisplayValue() {
    const value = this.getValue();
    switch (typeof value) {
      case "string":
      case "number":
        return value;
      default:
        return String(value);
    }
  }
  getType() {
    return this.constructor.type;
  }
  getUnit() {
    return this.constructor.unit;
  }
  getDisplayUnit() {
    return this.getUnit();
  }
  getDisplayType() {
    return this.constructor.displayType || this.constructor.type;
  }
  getUnitSystem() {
    return this.constructor.unitSystem;
  }
  isValueTypeValid(value) {
    const position = value;
    return !(typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && !Array.isArray(value) && !isNumber(position?.latitudeDegrees) && !isNumber(position?.longitudeDegrees));
  }
  toJSON() {
    return {
      [this.getType()]: this.getValue()
    };
  }
};

// src/data/data.bare.ts
var DataBare = class extends Data {
  static {
    this.unit = "";
  }
  // Bare data have no unit but empty string
};

// src/data/data.number.ts
var DataNumber = class extends DataBare {
  constructor(value) {
    super(value);
    this.value = value;
  }
  getValue(_formatForDataType) {
    return this.value;
  }
  isValueTypeValid(value) {
    return typeof value === "number";
  }
};

// src/data/data.duration.ts
var DataDuration = class extends DataNumber {
  static {
    this.type = "Duration";
  }
  static {
    this.unit = "s";
  }
  /**
   * Converts to hhh:mmm:ss:ms
   * @todo should adopt and round depending if needed to show seconds or not
   * @param showDays
   * @param showSeconds
   * @param showMilliseconds
   * @param useColonFormat when true, returns compact colon-separated format e.g. `1:04:32`
   */
  getDisplayValue(showDays = false, showSeconds = true, showMilliseconds = false, useColonFormat = false) {
    const seconds = this.getValue();
    const h = Math.floor(seconds / 3600);
    const d = Math.floor(h / 24);
    const m = Math.floor(seconds % 3600 / 60);
    const s = Math.floor(seconds % 3600 % 60);
    const ms = (Math.round(seconds % 1 * 10) / 10).toString().substring(1);
    if (useColonFormat) {
      const msStr = showMilliseconds ? ms : "";
      const ss = ("0" + s).slice(-2) + msStr;
      const mm = ("0" + m).slice(-2);
      return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
    }
    if (!m && !h) {
      return showSeconds ? ("0" + s).slice(-2) + (showMilliseconds ? ms : "") + "s" : s + String(showMilliseconds ? ms : "") + `s`;
    } else if (!h) {
      return ("0" + m).slice(-2) + "m" + (showSeconds ? " " + ("0" + s).slice(-2) + (showMilliseconds ? ms : "") + "s" : ``);
    } else {
      if (d) {
        if (showDays) {
          return d + "d " + ("0" + (h - d * 24)).slice(-2) + "h " + ("0" + m).slice(-2) + "m " + (showSeconds ? ("0" + s).slice(-2) + (showMilliseconds ? ms : "") + "s" : ``);
        }
        return h + "h " + ("0" + m).slice(-2) + "m " + (showSeconds ? ("0" + s).slice(-2) + (showMilliseconds ? ms : "") + "s" : ``);
      } else {
        return ("0" + h).slice(-2) + "h " + ("0" + m).slice(-2) + "m " + (showSeconds ? ("0" + s).slice(-2) + (showMilliseconds ? ms : "") + "s" : ``);
      }
    }
  }
  /**
   * Formats an elapsed duration as a stopwatch value, such as `1:36.12`.
   *
   * Uses a single minute digit for sub-hour durations, pads seconds to two
   * digits, and retains trailing zeroes in the fractional part.
   */
  getStopwatchDisplayValue(fractionDigits = 2) {
    const boundedFractionDigits = Math.max(0, Math.min(3, Math.trunc(fractionDigits)));
    const precision = 10 ** boundedFractionDigits;
    const roundedSeconds = Math.round(this.getValue() * precision) / precision;
    const h = Math.floor(roundedSeconds / 3600);
    const m = Math.floor(roundedSeconds % 3600 / 60);
    const s = Math.floor(roundedSeconds % 60);
    const fractionalPart = boundedFractionDigits ? (roundedSeconds % 1).toFixed(boundedFractionDigits).substring(1) : "";
    const seconds = `${("0" + s).slice(-2)}${fractionalPart}`;
    return h > 0 ? `${h}:${("0" + m).slice(-2)}:${seconds}` : `${m}:${seconds}`;
  }
  getDisplayUnit() {
    return "";
  }
};

// src/data/data.pace.ts
var DataPace = class extends DataDuration {
  static {
    this.type = "Pace";
  }
  static {
    this.unit = "min/km";
  }
  getDisplayValue() {
    if (this.getValue() === Infinity || this.getValue() === -Infinity) {
      return "00:00";
    }
    const d = this.getValue();
    const h = Math.floor(d / 3600);
    const m = Math.floor(d % 3600 / 60);
    const s = Math.floor(d % 3600 % 60);
    if (!m && !h) {
      return "00:" + ("0" + s).slice(-2);
    } else if (!h) {
      return ("0" + m).slice(-2) + ":" + ("0" + s).slice(-2);
    } else {
      return ("0" + h).slice(-2) + ":" + ("0" + m).slice(-2) + ":" + ("0" + s).slice(-2);
    }
  }
  getDisplayUnit() {
    return this.getUnit();
  }
  getValue(formatForDataType) {
    switch (formatForDataType) {
      case DataPaceMinutesPerMile.type:
        return convertPaceToPaceInMinutesPerMile(this.value);
      default:
        return super.getValue(formatForDataType);
    }
  }
};
var DataPaceMinutesPerMile = class extends DataPace {
  static {
    this.type = "Pace in minutes per mile";
  }
  static {
    this.displayType = DataPace.type;
  }
  static {
    this.unit = "min/m";
  }
  getValue(formatForDataType) {
    if (formatForDataType) {
      throw new Error(`Not implemented`);
    }
    return super.getValue(formatForDataType);
  }
};

// src/data/data.swim-pace.ts
var DataSwimPace = class extends DataPace {
  static {
    this.type = "Swim Pace";
  }
  static {
    this.unit = "min/100m";
  }
  getValue(formatForDataType) {
    switch (formatForDataType) {
      case DataSwimPaceMinutesPer100Yard.type:
        return convertSwimPaceToSwimPacePer100Yard(this.value);
      default:
        return super.getValue(formatForDataType);
    }
  }
};
var DataSwimPaceMinutesPer100Yard = class extends DataSwimPace {
  static {
    this.type = "Swim Pace in minutes per 100 yard";
  }
  static {
    this.displayType = DataSwimPace.type;
  }
  static {
    this.unit = "min/100yd";
  }
};

// src/data/data.speed.ts
var DataSpeed = class extends DataNumber {
  static {
    this.type = "Speed";
  }
  static {
    this.unit = "m/s";
  }
  getDisplayValue() {
    return this.getValue().toFixed(2);
  }
  getValue(formatForDataType) {
    switch (formatForDataType) {
      // Speed cases conversions
      case DataSpeedKilometersPerHour.type:
        return convertSpeedToSpeedInKilometersPerHour(this.value);
      case DataSpeedMilesPerHour.type:
        return convertSpeedToSpeedInMilesPerHour(this.value);
      case DataSpeedFeetPerSecond.type:
        return convertSpeedToSpeedInFeetPerSecond(this.value);
      case DataSpeedMetersPerMinute.type:
        return convertSpeedToSpeedInMetersPerMinute(this.value);
      case DataSpeedFeetPerMinute.type:
        return convertSpeedToSpeedInFeetPerMinute(this.value);
      case DataSpeedKnots.type:
        return convertSpeedToSpeedInKnots(this.value);
      // Pace
      case DataPace.type:
        return convertSpeedToPace(this.value);
      case DataPaceMinutesPerMile.type:
        return convertPaceToPaceInMinutesPerMile(convertSpeedToPace(this.value));
      // Swim pace
      case DataSwimPace.type:
        return convertSpeedToSwimPace(this.value);
      case DataSwimPaceMinutesPer100Yard.type:
        return convertSwimPaceToSwimPacePer100Yard(convertSpeedToSwimPace(this.value));
      default:
        return super.getValue(formatForDataType);
    }
  }
};
var DataSpeedKilometersPerHour = class extends DataSpeed {
  static {
    this.type = "Speed in kilometers per hour";
  }
  static {
    this.displayType = DataSpeed.type;
  }
  static {
    this.unit = "km/h";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedMilesPerHour = class extends DataSpeed {
  static {
    this.type = "Speed in miles per hour";
  }
  static {
    this.displayType = DataSpeed.type;
  }
  static {
    this.unit = "mph";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedFeetPerSecond = class extends DataSpeed {
  static {
    this.type = "Speed in feet per second";
  }
  static {
    this.displayType = DataSpeed.type;
  }
  static {
    this.unit = "ft/s";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedMetersPerMinute = class extends DataSpeed {
  static {
    this.type = "Speed in meters per minute";
  }
  static {
    this.displayType = DataSpeed.type;
  }
  static {
    this.unit = "m/min";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedFeetPerMinute = class extends DataSpeed {
  static {
    this.type = "Speed in feet per minute";
  }
  static {
    this.displayType = DataSpeed.type;
  }
  static {
    this.unit = "ft/min";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedKnots = class extends DataSpeed {
  static {
    this.type = "Speed in knots";
  }
  static {
    this.displayType = DataSpeed.type;
  }
  static {
    this.unit = "kn";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};

// src/data/data.speed-avg.ts
var DataSpeedAvg = class extends DataSpeed {
  static {
    this.type = "Average Speed";
  }
};
var DataSpeedAvgKilometersPerHour = class extends DataSpeedKilometersPerHour {
  static {
    this.type = "Average speed in kilometers per hour";
  }
  static {
    this.displayType = DataSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedAvgMilesPerHour = class extends DataSpeedMilesPerHour {
  static {
    this.type = "Average speed in miles per hour";
  }
  static {
    this.displayType = DataSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedAvgFeetPerSecond = class extends DataSpeedFeetPerSecond {
  static {
    this.type = "Average speed in feet per second";
  }
  static {
    this.displayType = DataSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedAvgMetersPerMinute = class extends DataSpeedMetersPerMinute {
  static {
    this.type = "Average speed in meters per minute";
  }
  static {
    this.displayType = DataSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedAvgFeetPerMinute = class extends DataSpeedFeetPerMinute {
  static {
    this.type = "Average speed in feet per minute";
  }
  static {
    this.displayType = DataSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataSpeedAvgKnots = class extends DataSpeedKnots {
  static {
    this.type = "Average speed in knots";
  }
  static {
    this.displayType = DataSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};

// src/data/data.pace-avg.ts
var DataPaceAvg = class extends DataPace {
  static {
    this.type = "Average Pace";
  }
};
var DataPaceAvgMinutesPerMile = class extends DataPaceMinutesPerMile {
  static {
    this.type = "Average pace in minutes per mile";
  }
  static {
    this.displayType = DataPaceAvg.type;
  }
};

// src/data/data.swim-pace-avg.ts
var DataSwimPaceAvg = class extends DataSwimPace {
  static {
    this.type = "Average Swim Pace";
  }
};
var DataSwimPaceAvgMinutesPer100Yard = class extends DataSwimPaceMinutesPer100Yard {
  static {
    this.type = "Average swim pace in minutes per 100 yard";
  }
  static {
    this.displayType = DataSwimPaceAvg.type;
  }
};

// src/data/data.grade-adjusted-pace.ts
var DataGradeAdjustedPace = class extends DataPace {
  static {
    this.type = "Grade Adjusted Pace";
  }
  static {
    this.unit = "min/km";
  }
  getValue(formatForDataType) {
    switch (formatForDataType) {
      case DataGradeAdjustedPaceMinutesPerMile.type:
        return convertPaceToPaceInMinutesPerMile(this.value);
      default:
        return super.getValue(formatForDataType);
    }
  }
};
var DataGradeAdjustedPaceMinutesPerMile = class extends DataGradeAdjustedPace {
  static {
    this.type = "Grade Adjusted Pace in minutes per mile";
  }
  static {
    this.displayType = DataGradeAdjustedPace.type;
  }
  static {
    this.unit = "min/m";
  }
  getValue(formatForDataType) {
    if (formatForDataType) {
      throw new Error(`Not implemented`);
    }
    return super.getValue(formatForDataType);
  }
};

// src/data/data.grade-adjusted-pace-avg.ts
var DataGradeAdjustedPaceAvg = class extends DataGradeAdjustedPace {
  static {
    this.type = "Average Grade Adjusted Pace";
  }
};
var DataGradeAdjustedPaceAvgMinutesPerMile = class extends DataGradeAdjustedPaceMinutesPerMile {
  static {
    this.type = "Average Grade Adjusted Pace in minutes per mile";
  }
  static {
    this.displayType = DataGradeAdjustedPaceAvg.type;
  }
  static {
    this.unit = "min/m";
  }
  getValue(formatForDataType) {
    if (formatForDataType) {
      throw new Error(`Not implemented`);
    }
    return super.getValue(formatForDataType);
  }
};

// src/data/data.grade-adjusted-speed.ts
var DataGradeAdjustedSpeed = class extends DataSpeed {
  static {
    this.type = "Grade Adjusted Speed";
  }
  getValue(formatForDataType) {
    switch (formatForDataType) {
      // Speed cases conversions
      case DataGradeAdjustedSpeedKilometersPerHour.type:
        return convertSpeedToSpeedInKilometersPerHour(this.value);
      case DataGradeAdjustedSpeedMilesPerHour.type:
        return convertSpeedToSpeedInMilesPerHour(this.value);
      case DataGradeAdjustedSpeedFeetPerSecond.type:
        return convertSpeedToSpeedInFeetPerSecond(this.value);
      case DataGradeAdjustedSpeedMetersPerMinute.type:
        return convertSpeedToSpeedInMetersPerMinute(this.value);
      case DataGradeAdjustedSpeedFeetPerMinute.type:
        return convertSpeedToSpeedInFeetPerMinute(this.value);
      case DataGradeAdjustedSpeedKnots.type:
        return convertSpeedToSpeedInKnots(this.value);
      // Pace
      case DataGradeAdjustedPace.type:
        return convertSpeedToPace(this.value);
      case DataGradeAdjustedPaceMinutesPerMile.type:
        return convertPaceToPaceInMinutesPerMile(convertSpeedToPace(this.value));
      default:
        return super.getValue(formatForDataType);
    }
  }
};
var DataGradeAdjustedSpeedKilometersPerHour = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Grade Adjusted Speed in kilometers per hour";
  }
  static {
    this.displayType = DataGradeAdjustedSpeed.type;
  }
  static {
    this.unit = "km/h";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedMilesPerHour = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Grade Adjusted Speed in miles per hour";
  }
  static {
    this.displayType = DataGradeAdjustedSpeed.type;
  }
  static {
    this.unit = "mph";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedFeetPerSecond = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Grade Adjusted Speed in feet per second";
  }
  static {
    this.displayType = DataGradeAdjustedSpeed.type;
  }
  static {
    this.unit = "ft/s";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedMetersPerMinute = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Grade Adjusted Speed in meters per minute";
  }
  static {
    this.displayType = DataGradeAdjustedSpeed.type;
  }
  static {
    this.unit = "m/min";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedFeetPerMinute = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Grade Adjusted Speed in feet per minute";
  }
  static {
    this.displayType = DataGradeAdjustedSpeed.type;
  }
  static {
    this.unit = "ft/min";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedKnots = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Grade Adjusted Speed in knots";
  }
  static {
    this.displayType = DataGradeAdjustedSpeed.type;
  }
  static {
    this.unit = "kn";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};

// src/data/data.grade-adjusted-speed-avg.ts
var DataGradeAdjustedSpeedAvg = class extends DataGradeAdjustedSpeed {
  static {
    this.type = "Average Grade Adjusted Speed";
  }
};
var DataGradeAdjustedSpeedAvgKilometersPerHour = class extends DataGradeAdjustedSpeedKilometersPerHour {
  static {
    this.type = "Average Grade Adjusted Speed in kilometers per hour";
  }
  static {
    this.displayType = DataGradeAdjustedSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedAvgMilesPerHour = class extends DataGradeAdjustedSpeedMilesPerHour {
  static {
    this.type = "Average Grade Adjusted Speed in miles per hour";
  }
  static {
    this.displayType = DataGradeAdjustedSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedAvgFeetPerSecond = class extends DataGradeAdjustedSpeedFeetPerSecond {
  static {
    this.type = "Average Grade Adjusted Speed in feet per second";
  }
  static {
    this.displayType = DataGradeAdjustedSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedAvgMetersPerMinute = class extends DataGradeAdjustedSpeedMetersPerMinute {
  static {
    this.type = "Average Grade Adjusted Speed in meters per minute";
  }
  static {
    this.displayType = DataGradeAdjustedSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedAvgFeetPerMinute = class extends DataGradeAdjustedSpeedFeetPerMinute {
  static {
    this.type = "Average Grade Adjusted Speed in feet per minute";
  }
  static {
    this.displayType = DataGradeAdjustedSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataGradeAdjustedSpeedAvgKnots = class extends DataGradeAdjustedSpeedKnots {
  static {
    this.type = "Average Grade Adjusted Speed in knots";
  }
  static {
    this.displayType = DataGradeAdjustedSpeedAvg.type;
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};

// src/data/data.vertical-speed.ts
var DataVerticalSpeed = class extends DataNumber {
  static {
    this.type = "Vertical Speed";
  }
  static {
    this.unit = "m/s";
  }
  getValue(formatForDataType) {
    switch (formatForDataType) {
      case DataVerticalSpeedKilometerPerHour.type:
        return convertSpeedToSpeedInKilometersPerHour(this.value);
      case DataVerticalSpeedMilesPerHour.type:
        return convertSpeedToSpeedInMilesPerHour(this.value);
      case DataVerticalSpeedFeetPerSecond.type:
        return convertSpeedToSpeedInFeetPerSecond(this.value);
      case DataVerticalSpeedMetersPerMinute.type:
        return convertSpeedToSpeedInMetersPerMinute(this.value);
      case DataVerticalSpeedFeetPerMinute.type:
        return convertSpeedToSpeedInFeetPerMinute(this.value);
      case DataVerticalSpeedFeetPerHour.type:
        return convertSpeedToSpeedInFeetPerHour(this.value);
      case DataVerticalSpeedMetersPerHour.type:
        return convertSpeedToSpeedInMetersPerHour(this.value);
      default:
        return super.getValue(formatForDataType);
    }
  }
  getDisplayValue() {
    return this.getValue().toFixed(2);
  }
};
var DataVerticalSpeedFeetPerSecond = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in feet per second";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "ft/s";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
};
var DataVerticalSpeedMetersPerMinute = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in meters per minute";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "m/min";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
  getDisplayValue() {
    return this.getValue().toFixed(1);
  }
};
var DataVerticalSpeedFeetPerMinute = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in feet per minute";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "ft/min";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
  getDisplayValue() {
    return this.getValue().toFixed(1);
  }
};
var DataVerticalSpeedMetersPerHour = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in meters per hour";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "m/h";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
  getDisplayValue() {
    return this.getValue().toFixed(0);
  }
};
var DataVerticalSpeedFeetPerHour = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in feet per hour";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "ft/h";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
  getDisplayValue() {
    return this.getValue().toFixed(0);
  }
};
var DataVerticalSpeedKilometerPerHour = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in kilometers per hour";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "km/h";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
  getDisplayValue() {
    return this.getValue().toFixed(2);
  }
};
var DataVerticalSpeedMilesPerHour = class extends DataVerticalSpeed {
  static {
    this.type = "Vertical speed in miles per hour";
  }
  static {
    this.displayType = DataVerticalSpeed.type;
  }
  static {
    this.unit = "mph";
  }
  getDisplayType() {
    return super.getDisplayType();
  }
  getDisplayValue() {
    return this.getValue().toFixed(2);
  }
};

// src/activities/activity.types.ts
var ActivityTypesHelper = class _ActivityTypesHelper {
  static normalizeActivityTypeLookupKey(value) {
    return value.toLowerCase().replace(/[\s_-]/g, "");
  }
  static resolveActivityType(value) {
    if (value === null || value === void 0) {
      return null;
    }
    const raw = String(value).trim();
    if (!raw) {
      return null;
    }
    const exactMatch = ActivityTypes[raw];
    if (exactMatch) {
      return exactMatch;
    }
    const normalizedRaw = this.normalizeActivityTypeLookupKey(raw);
    for (const enumKey of Object.keys(ActivityTypes)) {
      if (this.normalizeActivityTypeLookupKey(enumKey) === normalizedRaw) {
        return ActivityTypes[enumKey];
      }
    }
    for (const enumValue of Object.values(ActivityTypes)) {
      if (this.normalizeActivityTypeLookupKey(enumValue) === normalizedRaw) {
        return enumValue;
      }
    }
    return null;
  }
  static getActivityTypesAsUniqueArray() {
    return Array.from(
      new Set(
        Object.keys(ActivityTypes).reduce((array, key) => {
          array.push(ActivityTypes[key]);
          return array;
        }, [])
      )
    ).sort((left, right) => {
      if (left < right) {
        return -1;
      }
      if (left > right) {
        return 1;
      }
      return 0;
    });
  }
  static getActivityTypeGroupsAsUniqueArray() {
    const activityTypeGroups = Array.from(
      new Set(Object.values(ActivityTypeGroups))
    );
    return activityTypeGroups.sort((left, right) => {
      if (left < right) {
        return -1;
      }
      if (left > right) {
        return 1;
      }
      return 0;
    });
  }
  static getActivityTypesForActivityGroup(activityTypeGroup) {
    return [...ActivityTypesGroupMapping.map[activityTypeGroup] || []];
  }
  static averageSpeedDerivedDataTypesToUseForActivityType(activityType) {
    switch (_ActivityTypesHelper.getActivityGroupForActivityType(activityType)) {
      case ActivityTypeGroups.RunningGroup:
        return [DataPaceAvg.type, DataGradeAdjustedPaceAvg.type];
      case ActivityTypeGroups.TrailRunningGroup:
        return [DataPaceAvg.type, DataGradeAdjustedPaceAvg.type, DataSpeedAvg.type, DataGradeAdjustedSpeedAvg.type];
      case ActivityTypeGroups.OutdoorAdventuresGroup:
        return [DataPaceAvg.type, DataSpeedAvg.type];
      case ActivityTypeGroups.WaterSportsGroup:
      case ActivityTypeGroups.SwimmingGroup:
        return [DataSpeedAvg.type, DataSwimPaceAvg.type];
      default:
        return [DataSpeedAvg.type];
    }
  }
  static speedDerivedDataTypesToUseForActivityType(activityType) {
    switch (_ActivityTypesHelper.getActivityGroupForActivityType(activityType)) {
      case ActivityTypeGroups.RunningGroup:
        return [DataPace.type, DataSpeed.type];
      case ActivityTypeGroups.TrailRunningGroup:
        return [DataPace.type, DataSpeed.type];
      case ActivityTypeGroups.OutdoorAdventuresGroup:
        return [DataPace.type, DataSpeed.type];
      case ActivityTypeGroups.WaterSportsGroup:
      case ActivityTypeGroups.SwimmingGroup:
        return [DataSpeed.type, DataSwimPace.type];
      default:
        return [DataSpeed.type];
    }
  }
  static altiDistanceSpeedDerivedDataTypesToUseForActivityType(activityType) {
    switch (_ActivityTypesHelper.getActivityGroupForActivityType(activityType)) {
      case ActivityTypeGroups.RunningGroup:
        return [DataGradeAdjustedPace.type];
      case ActivityTypeGroups.TrailRunningGroup:
        return [DataGradeAdjustedPace.type, DataGradeAdjustedSpeed.type];
      default:
        return [];
    }
  }
  static verticalSpeedDerivedDataTypesToUseForActivityType(activityType) {
    switch (_ActivityTypesHelper.getActivityGroupForActivityType(activityType)) {
      case ActivityTypeGroups.RunningGroup:
      case ActivityTypeGroups.TrailRunningGroup:
      case ActivityTypeGroups.CyclingGroup:
      case ActivityTypeGroups.MountainBikingGroup:
      case ActivityTypeGroups.OutdoorAdventuresGroup:
      case ActivityTypeGroups.PerformanceGroup:
        return [DataVerticalSpeed.type];
      default:
        return [];
    }
  }
  /**
   * Identifies activities where ascent should be ignored/excluded (e.g. assisted ascent)
   * @param activityType
   */
  static shouldExcludeDescent(activityType) {
    return ACTIVITIES_EXCLUDED_FROM_DESCENT.includes(activityType);
  }
  static shouldExcludeAscent(activityType) {
    return ACTIVITIES_EXCLUDED_FROM_ASCENT.includes(activityType);
  }
  /**
   * Returns metric display families that consumers may hide by default for a given activity type.
   * This is a presentation hint only and must not be used to suppress imported/raw metrics.
   */
  static hiddenDisplayDataTypesToUseForActivityType(activityType) {
    if (ACTIVITIES_WITH_SPEED_METRICS_HIDDEN_BY_DEFAULT.includes(activityType)) {
      return [DataSpeed.type, DataPace.type];
    }
    return [];
  }
  /**
   * Get's back the activity group an activity belongs to or returns unspecified activity group
   * @param activityType
   * This function can also be called: Fighting with a non functional language
   */
  static getActivityGroupForActivityType(activityType) {
    return Object.entries(ActivityTypesGroupMapping.map).find(([, activityTypes]) => activityTypes.includes(activityType))?.[0] || ActivityTypeGroups.UnspecifiedGroup;
  }
  static isIndoorActivityType(activityType) {
    return EXPLICIT_INDOOR_ACTIVITY_TYPES.includes(activityType);
  }
};
var ActivityTypes = /* @__PURE__ */ ((ActivityTypes3) => {
  ActivityTypes3["unknown"] = "Unknown Sport";
  ActivityTypes3["Unknown sport"] = "Unknown Sport";
  ActivityTypes3["Unknown Sport"] = "Unknown Sport";
  ActivityTypes3["UnknownSport"] = "Unknown Sport";
  ActivityTypes3["undefined"] = "Unknown Sport";
  ActivityTypes3["Not specified sport"] = "Unknown Sport";
  ActivityTypes3["Other"] = "Other";
  ActivityTypes3["generic"] = "Generic";
  ActivityTypes3["hiit"] = "HIIT";
  ActivityTypes3["HIIT"] = "HIIT";
  ActivityTypes3["generic_exercise"] = "Generic";
  ActivityTypes3["generic_track_me"] = "Generic";
  ActivityTypes3["Generic"] = "Generic";
  ActivityTypes3["transition"] = "Transition";
  ActivityTypes3["Transition"] = "Transition";
  ActivityTypes3["fitness_equipment"] = "Fitness Equipment";
  ActivityTypes3["Fitness Equipment"] = "Fitness Equipment";
  ActivityTypes3["FitnessEquipment"] = "Fitness Equipment";
  ActivityTypes3["Multisport"] = "Multisport";
  ActivityTypes3["MultiSport"] = "Multisport";
  ActivityTypes3["multisport"] = "Multisport";
  ActivityTypes3["running_virtual_activity"] = "Virtual Running";
  ActivityTypes3["VirtualRun"] = "Virtual Running";
  ActivityTypes3["Virtual running"] = "Virtual Running";
  ActivityTypes3["Virtual Running"] = "Virtual Running";
  ActivityTypes3["VirtualRunning"] = "Virtual Running";
  ActivityTypes3["Run"] = "Running";
  ActivityTypes3["run"] = "Running";
  ActivityTypes3["running_track"] = "Running";
  ActivityTypes3["running_trail"] = "Trail Running";
  ActivityTypes3["Running"] = "Running";
  ActivityTypes3["running"] = "Running";
  ActivityTypes3["running_street"] = "Running";
  ActivityTypes3["running_road"] = "Running";
  ActivityTypes3["TrailRunning"] = "Trail Running";
  ActivityTypes3["Trail Running"] = "Trail Running";
  ActivityTypes3["Trail running"] = "Trail Running";
  ActivityTypes3["trail_running"] = "Trail Running";
  ActivityTypes3["Indoor running"] = "Indoor Running";
  ActivityTypes3["Indoor Running"] = "Indoor Running";
  ActivityTypes3["IndoorRunning"] = "Indoor Running";
  ActivityTypes3["running_indoor"] = "Indoor Running";
  ActivityTypes3["running_indoor_running"] = "Indoor Running";
  ActivityTypes3["training_indoor_running"] = "Indoor Running";
  ActivityTypes3["Cycling"] = "Cycling";
  ActivityTypes3["cycling"] = "Cycling";
  ActivityTypes3["cycling_road"] = "Cycling";
  ActivityTypes3["road_biking"] = "Cycling";
  ActivityTypes3["cycling_track_cycling"] = "Cycling";
  ActivityTypes3["cycling_gravel_cycling"] = "Cycling";
  ActivityTypes3["Biking"] = "Cycling";
  ActivityTypes3["biking"] = "Cycling";
  ActivityTypes3["Ride"] = "Cycling";
  ActivityTypes3["cycling_commuting"] = "Cycling";
  ActivityTypes3["cycling_mixed_surface"] = "Cycling";
  ActivityTypes3["cycling_indoor_cycling"] = "Indoor Cycling";
  ActivityTypes3["Indoorcycling"] = "Indoor Cycling";
  ActivityTypes3["indoor_cycling"] = "Indoor Cycling";
  ActivityTypes3["Indoor cycling"] = "Indoor Cycling";
  ActivityTypes3["IndoorCycling"] = "Indoor Cycling";
  ActivityTypes3["Indoor Cycling"] = "Indoor Cycling";
  ActivityTypes3["cycling_virtual_activity"] = "Virtual Cycling";
  ActivityTypes3["VirtualRide"] = "Virtual Cycling";
  ActivityTypes3["Virtual Cycling"] = "Virtual Cycling";
  ActivityTypes3["VirtualCycling"] = "Virtual Cycling";
  ActivityTypes3["e_biking"] = "E-Biking";
  ActivityTypes3["E Biking"] = "E-Biking";
  ActivityTypes3["EBiking"] = "E-Biking";
  ActivityTypes3["E biking"] = "E-Biking";
  ActivityTypes3["EBikeRide"] = "E-Biking";
  ActivityTypes3["E-Biking"] = "E-Biking";
  ActivityTypes3["cycling_mountain"] = "Mountain Biking";
  ActivityTypes3["MountainBiking"] = "Mountain Biking";
  ActivityTypes3["Mountain Biking"] = "Mountain Biking";
  ActivityTypes3["cycling_cyclocross"] = "Mountain Biking";
  ActivityTypes3["mountain"] = "Mountain Biking";
  ActivityTypes3["Mountain biking"] = "Mountain Biking";
  ActivityTypes3["cycling_mountain_enduro"] = "Enduro MTB";
  ActivityTypes3["Enduro MTB"] = "Enduro MTB";
  ActivityTypes3["cycling_downhill"] = "Downhill Cycling";
  ActivityTypes3["cycling_mountain_downhill"] = "Downhill Cycling";
  ActivityTypes3["DownhillCycling"] = "Downhill Cycling";
  ActivityTypes3["Downhill Cycling"] = "Downhill Cycling";
  ActivityTypes3["motorcycling"] = "Motorcycling";
  ActivityTypes3["Motorcycling"] = "Motorcycling";
  ActivityTypes3["boating"] = "Boating";
  ActivityTypes3["Boating"] = "Boating";
  ActivityTypes3["driving"] = "Driving";
  ActivityTypes3["Driving"] = "Driving";
  ActivityTypes3["Circuit training"] = "Circuit Training";
  ActivityTypes3["Circuit Training"] = "Circuit Training";
  ActivityTypes3["Swimming"] = "Swimming";
  ActivityTypes3["swimming"] = "Swimming";
  ActivityTypes3["Swim"] = "Swimming";
  ActivityTypes3["swim"] = "Swimming";
  ActivityTypes3["swimming_lap_swimming"] = "Swimming";
  ActivityTypes3["swimming_open_water"] = "Open Water Swimming";
  ActivityTypes3["Open water swimming"] = "Open Water Swimming";
  ActivityTypes3["open water swimming"] = "Open Water Swimming";
  ActivityTypes3["Open Water Swimming"] = "Open Water Swimming";
  ActivityTypes3["OpenWaterSwimming"] = "Open Water Swimming";
  ActivityTypes3["open_water"] = "Open Water Swimming";
  ActivityTypes3["basketball"] = "Basketball";
  ActivityTypes3["soccer"] = "Soccer";
  ActivityTypes3["Soccer"] = "Soccer";
  ActivityTypes3["american_football"] = "American Football";
  ActivityTypes3["American footBall"] = "American Football";
  ActivityTypes3["American Football"] = "American Football";
  ActivityTypes3["AmericanFootball"] = "American Football";
  ActivityTypes3["Skating"] = "Skating";
  ActivityTypes3["Aerobics"] = "Aerobics";
  ActivityTypes3["training_yoga"] = "Yoga";
  ActivityTypes3["yoga"] = "Yoga";
  ActivityTypes3["Yoga"] = "Yoga";
  ActivityTypes3["YogaPilates"] = "Yoga";
  ActivityTypes3["fitness_equipment_pilates"] = "Pilates";
  ActivityTypes3["Pilates"] = "Pilates";
  ActivityTypes3["pilates"] = "Pilates";
  ActivityTypes3["Trekking"] = "Trekking";
  ActivityTypes3["Trek"] = "Trekking";
  ActivityTypes3["Walking"] = "Walking";
  ActivityTypes3["walking"] = "Walking";
  ActivityTypes3["walking_indoor"] = "Walking";
  ActivityTypes3["Walk"] = "Walking";
  ActivityTypes3["walk"] = "Walking";
  ActivityTypes3["walking_casual_walking"] = "Walking";
  ActivityTypes3["walking_indoor_walking"] = "Walking";
  ActivityTypes3["Sailing"] = "Sailing";
  ActivityTypes3["sailing"] = "Sailing";
  ActivityTypes3["Kayaking"] = "Kayaking";
  ActivityTypes3["kayaking"] = "Kayaking";
  ActivityTypes3["rafting"] = "Rafting";
  ActivityTypes3["Rafting"] = "Rafting";
  ActivityTypes3["rowing"] = "Rowing";
  ActivityTypes3["Rowing"] = "Rowing";
  ActivityTypes3["fitness_equipment_indoor_rowing"] = "Indoor Rowing";
  ActivityTypes3["IndoorRowing"] = "Indoor Rowing";
  ActivityTypes3["Indoor Rowing"] = "Indoor Rowing";
  ActivityTypes3["indoor_rowing"] = "Indoor Rowing";
  ActivityTypes3["rowing_indoor"] = "Indoor Rowing";
  ActivityTypes3["rowing_indoor_rowing"] = "Indoor Rowing";
  ActivityTypes3["Climbing"] = "Climbing";
  ActivityTypes3["Triathlon"] = "Triathlon";
  ActivityTypes3["Duathlon"] = "Duathlon";
  ActivityTypes3["Aquathlon"] = "Aquathlon";
  ActivityTypes3["Alpine skiing"] = "Alpine Skiing";
  ActivityTypes3["Alpine Skiing"] = "Alpine Skiing";
  ActivityTypes3["AlpineSkiing"] = "Alpine Skiing";
  ActivityTypes3["alpine_skiing"] = "Alpine Skiing";
  ActivityTypes3["AlpineSki"] = "Alpine Skiing";
  ActivityTypes3["downhill"] = "Alpine Skiing";
  ActivityTypes3["Downhill skiing"] = "Alpine Skiing";
  ActivityTypes3["DownhillSkiing"] = "Alpine Skiing";
  ActivityTypes3["Crosscountry Skiing"] = "Crosscountry Skiing";
  ActivityTypes3["Crosscountry skiing"] = "Crosscountry Skiing";
  ActivityTypes3["CrosscountrySkiing"] = "Crosscountry Skiing";
  ActivityTypes3["CrossCountrySkiing"] = "Crosscountry Skiing";
  ActivityTypes3["cross_country_skiing"] = "Crosscountry Skiing";
  ActivityTypes3["cross_country_skiing_skate_skiing"] = "Crosscountry Skiing";
  ActivityTypes3["NordicSki"] = "Nordic Skiing";
  ActivityTypes3["Nordic skiing"] = "Nordic Skiing";
  ActivityTypes3["Nordic Skiing"] = "Nordic Skiing";
  ActivityTypes3["Backcountry skiing"] = "Backcountry Skiing";
  ActivityTypes3["Backcountry Skiing"] = "Backcountry Skiing";
  ActivityTypes3["BackCountrySkiing"] = "Backcountry Skiing";
  ActivityTypes3["BackcountrySkiing"] = "Backcountry Skiing";
  ActivityTypes3["BackcountrySki"] = "Backcountry Skiing";
  ActivityTypes3["cross_country_skiing_backcountry"] = "Backcountry Skiing";
  ActivityTypes3["alpine_skiing_backcountry"] = "Backcountry Skiing";
  ActivityTypes3["backcountry"] = "Backcountry Skiing";
  ActivityTypes3["BackCountrySki"] = "Backcountry Skiing";
  ActivityTypes3["Ski Touring"] = "Ski Touring";
  ActivityTypes3["SkiTouring"] = "Ski Touring";
  ActivityTypes3["Telemark skiing"] = "Telemark Skiing";
  ActivityTypes3["TelemarkSkiing"] = "Telemark Skiing";
  ActivityTypes3["Telemark Skiing"] = "Telemark Skiing";
  ActivityTypes3["cross_country_skiing_downhill"] = "Telemark Skiing";
  ActivityTypes3["alpine_skiing_downhill"] = "Alpine Skiing";
  ActivityTypes3["Roller skiing"] = "Roller Skiing";
  ActivityTypes3["RollerSki"] = "Roller Skiing";
  ActivityTypes3["Roller Skiing"] = "Roller Skiing";
  ActivityTypes3["Snowboarding"] = "Snowboarding";
  ActivityTypes3["snowboarding"] = "Snowboarding";
  ActivityTypes3["Snowboard"] = "Snowboarding";
  ActivityTypes3["Weight Training"] = "Weight Training";
  ActivityTypes3["Weight training"] = "Weight Training";
  ActivityTypes3["WeightTraining"] = "Weight Training";
  ActivityTypes3["Basketball"] = "Basketball";
  ActivityTypes3["Ice Hockey"] = "Ice Hockey";
  ActivityTypes3["IceHockey"] = "Ice Hockey";
  ActivityTypes3["Volleyball"] = "Volleyball";
  ActivityTypes3["Football"] = "Football";
  ActivityTypes3["Softball"] = "Softball";
  ActivityTypes3["Handball"] = "Handball";
  ActivityTypes3["Cheerleading"] = "Cheerleading";
  ActivityTypes3["Baseball"] = "Baseball";
  ActivityTypes3["tennis"] = "Tennis";
  ActivityTypes3["Tennis"] = "Tennis";
  ActivityTypes3["tennis_match"] = "Tennis";
  ActivityTypes3["Badminton"] = "Badminton";
  ActivityTypes3["Table tennis"] = "Table Tennis";
  ActivityTypes3["Table Tennis"] = "Table Tennis";
  ActivityTypes3["TableTennis"] = "Table Tennis";
  ActivityTypes3["racket"] = "Racquet Ball";
  ActivityTypes3["racquet_ball"] = "Racquet Ball";
  ActivityTypes3["Racquet Ball"] = "Racquet Ball";
  ActivityTypes3["RacquetBall"] = "Racquet Ball";
  ActivityTypes3["Racquet ball"] = "Racquet Ball";
  ActivityTypes3["Squash"] = "Squash";
  ActivityTypes3["Combat sport"] = "Combat";
  ActivityTypes3["Combat"] = "Combat";
  ActivityTypes3["Boxing"] = "Boxing";
  ActivityTypes3["Floorball"] = "Floorball";
  ActivityTypes3["Scuba diving"] = "Scuba Diving";
  ActivityTypes3["Scuba Diving"] = "Scuba Diving";
  ActivityTypes3["ScubaDiving"] = "Scuba Diving";
  ActivityTypes3["Free diving"] = "Free Diving";
  ActivityTypes3["Free Diving"] = "Free Diving";
  ActivityTypes3["FreeDiving"] = "Free Diving";
  ActivityTypes3["diving"] = "Diving";
  ActivityTypes3["Diving"] = "Diving";
  ActivityTypes3["diving_apnea_hunting"] = "Diving";
  ActivityTypes3["Snorkeling"] = "Snorkeling";
  ActivityTypes3["Swimrun"] = "Swimrun";
  ActivityTypes3["Adventure Racing"] = "Adventure Racing";
  ActivityTypes3["Bowling"] = "Bowling";
  ActivityTypes3["Cricket"] = "Cricket";
  ActivityTypes3["Crosstrainer"] = "Crosstrainer";
  ActivityTypes3["Dancing"] = "Dancing";
  ActivityTypes3["Golf"] = "Golf";
  ActivityTypes3["golf"] = "Golf";
  ActivityTypes3["hang_gliding"] = "Hang Gliding";
  ActivityTypes3["Hang gliding"] = "Hang Gliding";
  ActivityTypes3["HangGliding"] = "Hang Gliding";
  ActivityTypes3["Hang Gliding"] = "Hang Gliding";
  ActivityTypes3["horseback_riding"] = "Horseback Riding";
  ActivityTypes3["Horseback Riding"] = "Horseback Riding";
  ActivityTypes3["HorsebackRiding"] = "Horseback Riding";
  ActivityTypes3["Horseback riding"] = "Horseback Riding";
  ActivityTypes3["Gymnastics"] = "Gymnastics";
  ActivityTypes3["Ice Skating"] = "Ice Skating";
  ActivityTypes3["IceSkating"] = "Ice Skating";
  ActivityTypes3["ice_skating"] = "Ice Skating";
  ActivityTypes3["ice skating"] = "Ice Skating";
  ActivityTypes3["Ice skating"] = "Ice Skating";
  ActivityTypes3["IceSkate"] = "Ice Skating";
  ActivityTypes3["Ice Skate"] = "Ice Skating";
  ActivityTypes3["Canoeing"] = "Canoeing";
  ActivityTypes3["Motorsports"] = "Motorsports";
  ActivityTypes3["Mountaineering"] = "Mountaineering";
  ActivityTypes3["mountaineering"] = "Mountaineering";
  ActivityTypes3["Orienteering"] = "Orienteering";
  ActivityTypes3["running_navigate"] = "Orienteering";
  ActivityTypes3["generic_navigate"] = "Orienteering";
  ActivityTypes3["Rugby"] = "Rugby";
  ActivityTypes3["Stretching"] = "Stretching";
  ActivityTypes3["training_strength_training"] = "Strength Training";
  ActivityTypes3["fitness_equipment_strength_training"] = "Strength Training";
  ActivityTypes3["strength_training"] = "Strength Training";
  ActivityTypes3["Strength training"] = "Strength Training";
  ActivityTypes3["strength training"] = "Strength Training";
  ActivityTypes3["Strength Training"] = "Strength Training";
  ActivityTypes3["StrengthTraining"] = "Strength Training";
  ActivityTypes3["generic_strength_training"] = "Strength Training";
  ActivityTypes3["TrackAndField"] = "Track and Field";
  ActivityTypes3["Track and Field"] = "Track and Field";
  ActivityTypes3["NordicWalking"] = "Nordic Walking";
  ActivityTypes3["Nordic Walking"] = "Nordic Walking";
  ActivityTypes3["Nordic walking"] = "Nordic Walking";
  ActivityTypes3["Snow shoeing"] = "Snowshoeing";
  ActivityTypes3["Windsurfing/Surfing"] = "Windsurfing";
  ActivityTypes3["windsurfing"] = "Windsurfing";
  ActivityTypes3["Windsurfing"] = "Windsurfing";
  ActivityTypes3["Windsurf"] = "Windsurfing";
  ActivityTypes3["Kettlebell"] = "Kettlebell";
  ActivityTypes3["paddling"] = "Paddling";
  ActivityTypes3["Paddling"] = "Paddling";
  ActivityTypes3["flying"] = "Flying";
  ActivityTypes3["Flying"] = "Flying";
  ActivityTypes3["Cross fit"] = "Crossfit";
  ActivityTypes3["Cross Fit"] = "Crossfit";
  ActivityTypes3["cross_fit"] = "Crossfit";
  ActivityTypes3["Crossfit"] = "Crossfit";
  ActivityTypes3["Kitesurfing/Kiting"] = "Kitesurfing";
  ActivityTypes3["kitesurfing"] = "Kitesurfing";
  ActivityTypes3["Kitesurfing"] = "Kitesurfing";
  ActivityTypes3["Kitesurf"] = "Kitesurfing";
  ActivityTypes3["tactical"] = "Tactical";
  ActivityTypes3["Tactical"] = "Tactical";
  ActivityTypes3["jumpmaster"] = "Jumpmaster";
  ActivityTypes3["Jumpmaster"] = "Jumpmaster";
  ActivityTypes3["boxing"] = "Boxing";
  ActivityTypes3["floor_climbing"] = "Floor Climbing";
  ActivityTypes3["Floor climbing"] = "Floor Climbing";
  ActivityTypes3["Floor Climbing"] = "Floor Climbing";
  ActivityTypes3["FloorClimbing"] = "Floor Climbing";
  ActivityTypes3["Paragliding"] = "Paragliding";
  ActivityTypes3["fitness_equipment_treadmill"] = "Treadmill";
  ActivityTypes3["running_treadmill"] = "Treadmill";
  ActivityTypes3["Treadmill"] = "Treadmill";
  ActivityTypes3["treadmill"] = "Treadmill";
  ActivityTypes3["Frisbee"] = "Frisbee";
  ActivityTypes3["Indoor training"] = "Indoor Training";
  ActivityTypes3["Indoor Training"] = "Indoor Training";
  ActivityTypes3["IndoorTraining"] = "Indoor Training";
  ActivityTypes3["Hiking"] = "Hiking";
  ActivityTypes3["hiking_trail"] = "Hiking";
  ActivityTypes3["hiking"] = "Hiking";
  ActivityTypes3["hike"] = "Hiking";
  ActivityTypes3["Hike"] = "Hiking";
  ActivityTypes3["canyoning"] = "Canyoning";
  ActivityTypes3["Canyoning"] = "Canyoning";
  ActivityTypes3["ViaFerrata"] = "Via Ferrata";
  ActivityTypes3["Via Ferrata"] = "Via Ferrata";
  ActivityTypes3["via Ferrata"] = "Via Ferrata";
  ActivityTypes3["via ferrata"] = "Via Ferrata";
  ActivityTypes3["Fishing"] = "Fishing";
  ActivityTypes3["fishing"] = "Fishing";
  ActivityTypes3["Hunting"] = "Hunting";
  ActivityTypes3["hunting"] = "Hunting";
  ActivityTypes3["route"] = "Route";
  ActivityTypes3["Route"] = "Route";
  ActivityTypes3["inline_skating"] = "Inline Skating";
  ActivityTypes3["InlineSkating"] = "Inline Skating";
  ActivityTypes3["Inline Skating"] = "Inline Skating";
  ActivityTypes3["Inline skating"] = "Inline Skating";
  ActivityTypes3["InlineSkate"] = "Inline Skating";
  ActivityTypes3["rock_climbing"] = "Rock Climbing";
  ActivityTypes3["Rock Climbing"] = "Rock Climbing";
  ActivityTypes3["Rock climbing"] = "Rock Climbing";
  ActivityTypes3["RockClimbing"] = "Rock Climbing";
  ActivityTypes3["indoor_climbing"] = "Indoor Climbing";
  ActivityTypes3["IndoorClimbing"] = "Indoor Climbing";
  ActivityTypes3["Indoor Climbing"] = "Indoor Climbing";
  ActivityTypes3["rock_climbing_indoor_climbing"] = "Indoor Climbing";
  ActivityTypes3["bouldering"] = "Bouldering";
  ActivityTypes3["Bouldering"] = "Bouldering";
  ActivityTypes3["rock_climbing_bouldering"] = "Bouldering";
  ActivityTypes3["sky_diving"] = "Sky Diving";
  ActivityTypes3["Sky Diving"] = "Sky Diving";
  ActivityTypes3["Sky diving"] = "Sky Diving";
  ActivityTypes3["sky diving"] = "Sky Diving";
  ActivityTypes3["SkyDiving"] = "Sky Diving";
  ActivityTypes3["snowshoeing"] = "Snowshoeing";
  ActivityTypes3["Snowshoeing"] = "Snowshoeing";
  ActivityTypes3["Snowshoe"] = "Snowshoeing";
  ActivityTypes3["snowmobiling"] = "Snowmobiling";
  ActivityTypes3["Snowmobiling"] = "Snowmobiling";
  ActivityTypes3["stand_up_paddleboarding"] = "Stand Up Paddling";
  ActivityTypes3["Standup paddling (SUP)"] = "Stand Up Paddling";
  ActivityTypes3["Stand up paddling"] = "Stand Up Paddling";
  ActivityTypes3["stand up paddling"] = "Stand Up Paddling";
  ActivityTypes3["Stand