tods-competition-factory 0.48.1 → 0.48.2

package/dist/tods-competition-factory.cjs.development.js

@@ -3602,7 +3602,7 @@ function generateTieMatchUpScore({
   tieFormat,
   matchUp
 }) {
-  var _matchUp$tieFormat;
+  var _tieFormat;
 
   if (!Array.isArray(sideAdjustments) || sideAdjustments.length !== 2 || isNaN(sideAdjustments.reduce((a, b) => a + b))) {
     return {
@@ -3613,9 +3613,10 @@ function generateTieMatchUpScore({
   if (!matchUp) return {
     error: MISSING_MATCHUP
   };
+  tieFormat = matchUp.tieFormat || tieFormat;
   const sidePoints = [0, 0];
   const tieMatchUps = (matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieMatchUps) || [];
-  const collectionDefinitions = (matchUp === null || matchUp === void 0 ? void 0 : (_matchUp$tieFormat = matchUp.tieFormat) === null || _matchUp$tieFormat === void 0 ? void 0 : _matchUp$tieFormat.collectionDefinitions) || [];
+  const collectionDefinitions = ((_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : _tieFormat.collectionDefinitions) || [];
   collectionDefinitions.forEach(collectionDefinition => {
     const collectionMatchUps = tieMatchUps.filter(matchUp => matchUp.collectionId === collectionDefinition.collectionId);
 
@@ -3656,12 +3657,11 @@ function generateTieMatchUpScore({
   const scoreStringSide2 = sideScores.slice().reverse().join(separator); // now calculate if there is a winningSide
 
   let winningSide;
-  const format = matchUp.tieFormat || tieFormat;
 
-  if (format) {
-    var _format$winCriteria;
+  if (tieFormat) {
+    var _tieFormat$winCriteri;
 
-    const valueGoal = (_format$winCriteria = format.winCriteria) === null || _format$winCriteria === void 0 ? void 0 : _format$winCriteria.valueGoal;
+    const valueGoal = (_tieFormat$winCriteri = tieFormat.winCriteria) === null || _tieFormat$winCriteri === void 0 ? void 0 : _tieFormat$winCriteri.valueGoal;
 
     if (valueGoal) {
       const sideThatWon = sideScores.map((points, sideIndex) => ({
@@ -3956,600 +3956,11 @@ function checkTieFormat(tieFormat) {
   };
 }
 
-/**
- *
- * @param {object[]} - sets - TODS sets object
- * @param {string} - matchUpStatus - TODS matchUpStatus ENUM
- * @param {number || string} - winningSide - TODS side declaration: 1 or 2
- * @param {boolean} - winnerFirst - generate string with winner on left side
- * @param {boolean} - autoComplete - whether to convert undefined values to 0
- *
- */
-
-function generateScoreString(params) {
-  const {
-    sets,
-    winningSide,
-    autoComplete,
-    matchUpStatus,
-    reversed = false,
-    winnerFirst = true,
-    addOutcomeString
-  } = params;
-  if (!sets) return {
-    error: MISSING_VALUE
-  };
-  const scoresInSideOrder = !winnerFirst || !winningSide || winningSide === 1;
-  const reverseScores = reversed || !scoresInSideOrder;
-  const outcomeString = addOutcomeString ? getOutcomeString({
-    matchUpStatus
-  }) : '';
-  const setScores = (sets === null || sets === void 0 ? void 0 : sets.sort(setSort).map(setString).filter(Boolean) // handle situation where there are multiple empty set objects
-  .join(' ')) || '';
-  if (!outcomeString) return setScores;
-  if (winningSide === 2) return `${outcomeString} ${setScores}`;
-  return `${setScores} ${outcomeString}`;
-
-  function setString(currentSet) {
-    const hasGameScores = set => isNumeric(set === null || set === void 0 ? void 0 : set.side1Score) || isNumeric(set === null || set === void 0 ? void 0 : set.side2Score);
-
-    const hasTiebreakScores = set => isNumeric(set === null || set === void 0 ? void 0 : set.side1TiebreakScore) || isNumeric(set === null || set === void 0 ? void 0 : set.side2TiebreakScore);
-
-    const isTiebreakSet = !hasGameScores(currentSet) && hasTiebreakScores(currentSet);
-    const {
-      side1Score,
-      side2Score,
-      side1TiebreakScore,
-      side2TiebreakScore
-    } = currentSet;
-    const t1 = side1TiebreakScore || (isNumeric(side1TiebreakScore) || autoComplete ? 0 : '');
-    const t2 = side2TiebreakScore || (isNumeric(side2TiebreakScore) || autoComplete ? 0 : '');
-
-    if (isTiebreakSet) {
-      const tiebreakScore = reverseScores ? [t2, t1] : [t1, t2];
-      return `[${tiebreakScore.join('-')}]`;
-    }
-
-    const lowTiebreakScore = Math.min(t1, t2);
-    const tiebreak = lowTiebreakScore ? `(${lowTiebreakScore})` : '';
-    const s1 = side1Score || (isNumeric(side1Score) || autoComplete ? 0 : '');
-    const s2 = side2Score || (isNumeric(side2Score) || autoComplete ? 0 : '');
-    let scoreString = reverseScores ? `${[s2, s1].join('-')}${tiebreak}` : `${[s1, s2].join('-')}${tiebreak}`;
-    if (['-', ' '].includes(scoreString)) scoreString = '';
-    return scoreString;
-  }
-}
-
-function getOutcomeString({
-  matchUpStatus
-}) {
-  const outcomeStrings = {
-    [RETIRED]: 'RET',
-    [WALKOVER$1]: 'WO',
-    [DOUBLE_WALKOVER]: 'WO/WO',
-    [SUSPENDED]: 'SUS',
-    [ABANDONED]: 'ABN',
-    [DEFAULTED]: 'DEF',
-    [DEAD_RUBBER]: 'DR'
-  };
-  return matchUpStatus && outcomeStrings[matchUpStatus] || '';
-}
-
-function setSort(a, b) {
-  return a.setNumber - b.setNumber;
-}
-
-function getSetWinningSide({
-  matchUpScoringFormat,
-  isDecidingSet,
-  isTiebreakSet,
-  setObject
-}) {
-  if (!setObject) return undefined;
-  const leadingSide = getLeadingSide$1({
-    set: setObject
-  });
-  const setIsComplete = checkSetIsComplete$1({
-    matchUpScoringFormat,
-    isDecidingSet,
-    isTiebreakSet,
-    set: setObject
-  });
-  return setIsComplete && leadingSide || undefined;
-}
-function checkSetIsComplete$1({
-  ignoreTiebreak = false,
-  matchUpScoringFormat,
-  isTiebreakSet,
-  isDecidingSet,
-  set
-}) {
-  if (!set) return {
-    error: MISSING_VALUE
-  };
-  const setFormat = isDecidingSet && matchUpScoringFormat.finalSetFormat || (matchUpScoringFormat === null || matchUpScoringFormat === void 0 ? void 0 : matchUpScoringFormat.setFormat) || {};
-  const {
-    side1Score,
-    side2Score
-  } = set;
-  const {
-    setTo,
-    tiebreakAt,
-    tiebreakFormat
-  } = setFormat;
-  const NoAD = tiebreakFormat === null || tiebreakFormat === void 0 ? void 0 : tiebreakFormat.NoAd;
-  const leadingSide = getLeadingSide$1({
-    set
-  });
-  const scoreDiff = Math.abs(side1Score - side2Score);
-  const containsSetTo = side1Score >= setTo || side2Score >= setTo;
-  const requiresTiebreak = isTiebreakSet || side1Score >= setTo && side2Score >= setTo || tiebreakAt && tiebreakAt < setTo && (side1Score === tiebreakAt || side2Score === tiebreakAt);
-  const tiebreakIsValid = ignoreTiebreak || requiresTiebreak && (leadingSide === 1 && set.side1TiebreakScore > set.side2TiebreakScore || leadingSide === 2 && set.side2TiebreakScore > set.side1TiebreakScore);
-  const winMargin = requiresTiebreak && (tiebreakAt && !isTiebreakSet || isTiebreakSet && NoAD) ? 1 : 2;
-  const hasWinMargin = scoreDiff >= winMargin;
-  const validNormalSetScore = containsSetTo && (hasWinMargin || requiresTiebreak);
-  return (validNormalSetScore || isTiebreakSet) && (!requiresTiebreak || tiebreakIsValid);
-}
-function getLeadingSide$1({
-  set
-}) {
-  if (set.side1Score || set.side2Score) {
-    if (set.side1Score > set.side2Score) return 1;
-    if (set.side2Score > set.side1Score) return 2;
-  } else if (set.side1TiebreakScore || set.side2TiebreakScore) {
-    if (set.side1TiebreakScore > set.side2TiebreakScore) return 1;
-    if (set.side2TiebreakScore > set.side1TiebreakScore) return 2;
-  }
-
-  return undefined;
-}
-
-function analyzeSet(params) {
-  const {
-    setObject,
-    matchUpScoringFormat
-  } = params;
-  if (!setObject) return {
-    error: MISSING_SET_OBJECT
-  };
-  const {
-    setNumber
-  } = setObject || {};
-  const {
-    bestOf
-  } = matchUpScoringFormat || {};
-  const isDecidingSet = !!(setNumber && setNumber === bestOf);
-  const setFormat = isDecidingSet && (matchUpScoringFormat === null || matchUpScoringFormat === void 0 ? void 0 : matchUpScoringFormat.finalSetFormat) || (matchUpScoringFormat === null || matchUpScoringFormat === void 0 ? void 0 : matchUpScoringFormat.setFormat);
-  const expectTiebreakSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.tiebreakSet);
-  const expectTimedSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.timed);
-  const expectStandardSet = !expectTiebreakSet && !expectTimedSet;
-  const isValidSetNumber = !!(setNumber && bestOf && setNumber <= bestOf);
-  const sideGameScores = [setObject === null || setObject === void 0 ? void 0 : setObject.side1Score, setObject === null || setObject === void 0 ? void 0 : setObject.side2Score];
-  const sidePointScores = [setObject === null || setObject === void 0 ? void 0 : setObject.side1PointScore, setObject === null || setObject === void 0 ? void 0 : setObject.side2PointScore];
-  const sideTiebreakScores = [setObject === null || setObject === void 0 ? void 0 : setObject.side1TiebreakScore, setObject === null || setObject === void 0 ? void 0 : setObject.side2TiebreakScore];
-  const sideGameScoresCount = sideGameScores.filter(sideScore => sideScore !== undefined).length;
-  const sidePointScoresCount = sidePointScores.filter(sideScore => sideScore !== undefined).length;
-  const sideTiebreakScoresCount = sideTiebreakScores.filter(tiebreakScore => tiebreakScore !== undefined).length;
-  const gameScoresCount = sideGameScores === null || sideGameScores === void 0 ? void 0 : sideGameScores.filter(s => !isNaN(s)).length;
-  const tiebreakScoresCount = sideTiebreakScores === null || sideTiebreakScores === void 0 ? void 0 : sideTiebreakScores.filter(s => !isNaN(s)).length;
-  const {
-    tiebreakAt
-  } = setFormat || {};
-  const hasTiebreakCondition = tiebreakAt && sideGameScores.filter(gameScore => gameScore >= tiebreakAt).length === 2;
-  const leadingSide = hasTiebreakCondition && (sideGameScores[0] > sideGameScores[1] ? 1 : sideGameScores[1] > sideGameScores[0] ? 2 : undefined);
-  const isTiebreakSet = !!(tiebreakScoresCount && !gameScoresCount);
-  const isCompletedSet = !!(setObject && setObject !== null && setObject !== void 0 && setObject.winningSide);
-  const {
-    error: standardSetError,
-    result: isValidStandardSetOutcome
-  } = checkValidStandardSetOutcome({
-    setObject,
-    setFormat,
-    sideGameScores,
-    sideTiebreakScores
-  });
-  const {
-    error: tiebreakSetError,
-    result: isValidTiebreakSetOutcome
-  } = checkValidTiebreakSetOutcome({
-    setObject,
-    setFormat,
-    sideTiebreakScores
-  });
-  const isValidSetOutcome = expectStandardSet && !isTiebreakSet && isValidStandardSetOutcome || expectTiebreakSet && isTiebreakSet && isValidTiebreakSetOutcome;
-  const isValidSet = isValidSetNumber && !(expectTiebreakSet && !isTiebreakSet) && !(expectStandardSet && isTiebreakSet) && (!isCompletedSet || isValidSetOutcome);
-  const winningSide = getSetWinningSide({
-    isDecidingSet,
-    isTiebreakSet,
-    matchUpScoringFormat,
-    setObject
-  });
-  const analysis = {
-    expectTiebreakSet,
-    expectTimedSet,
-    hasTiebreakCondition,
-    isCompletedSet,
-    isDecidingSet,
-    isTiebreakSet,
-    isValidSet,
-    isValidSetNumber,
-    isValidSetOutcome,
-    leadingSide,
-    setFormat,
-    sideGameScores,
-    sideGameScoresCount,
-    sidePointScores,
-    sidePointScoresCount,
-    sideTiebreakScores,
-    sideTiebreakScoresCount,
-    winningSide
-  };
-
-  if ((setObject === null || setObject === void 0 ? void 0 : setObject.winningSide) !== undefined) {
-    if (isTiebreakSet) {
-      analysis.isValidTiebreakSetOutcome = isValidTiebreakSetOutcome;
-
-      if (!isValidTiebreakSetOutcome) {
-        analysis.tiebreakSetError = tiebreakSetError;
-      }
-    } else {
-      analysis.isValidStandardSetOutcome = isValidStandardSetOutcome;
-
-      if (!isValidStandardSetOutcome) {
-        analysis.standardSetError = standardSetError;
-      }
-    }
-  }
-
-  return analysis;
-}
-
-function checkValidStandardSetOutcome({
-  setObject,
-  setFormat,
-  sideGameScores,
-  sideTiebreakScores
-}) {
-  if (!setObject) {
-    return {
-      result: false,
-      error: MISSING_SET_OBJECT
-    };
-  }
-
-  const expectTiebreakSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.tiebreakSet);
-  const expectTimedSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.timed);
-
-  if (!setFormat || expectTiebreakSet || expectTimedSet) {
-    return {
-      result: false,
-      error: 'not standard set'
-    };
-  }
-
-  const validGameScores = (sideGameScores === null || sideGameScores === void 0 ? void 0 : sideGameScores.filter(s => !isNaN(s)).length) === 2;
-  if (!validGameScores) return {
-    result: false,
-    error: INVALID_GAME_SCORES
-  };
-  const {
-    setTo,
-    tiebreakAt,
-    tiebreakFormat,
-    NoAD
-  } = setFormat || {};
-  const meetsSetTo = !!(setTo && sideGameScores !== null && sideGameScores !== void 0 && sideGameScores.find(gameScore => gameScore >= setTo));
-  if (!meetsSetTo) return {
-    result: false,
-    error: INVALID_GAME_SCORES
-  };
-  const isValidWinningSide = [1, 2].includes(setObject === null || setObject === void 0 ? void 0 : setObject.winningSide);
-  if (!setObject || !isValidWinningSide) return {
-    result: false,
-    error: INVALID_WINNING_SIDE
-  };
-  const winningSideIndex = (setObject === null || setObject === void 0 ? void 0 : setObject.winningSide) - 1;
-  const losingSideIndex = 1 - winningSideIndex;
-  const winningSideGameScore = sideGameScores[winningSideIndex];
-  const losingSideGameScore = sideGameScores[losingSideIndex];
-  const gamesDifference = winningSideGameScore - losingSideGameScore;
-  const winningSideIsHighGameValue = winningSideGameScore > losingSideGameScore;
-
-  if (!winningSideIsHighGameValue) {
-    return {
-      result: false,
-      error: 'winningSide game scoreString is not high'
-    };
-  }
-
-  const setTiebreakDefined = tiebreakAt && tiebreakFormat;
-  const validTiebreakScores = (sideTiebreakScores === null || sideTiebreakScores === void 0 ? void 0 : sideTiebreakScores.filter(s => !isNaN(s)).length) === 2;
-  const winningSideTiebreakScore = sideTiebreakScores && sideTiebreakScores[winningSideIndex];
-  const losingSideTiebreakScore = sideTiebreakScores && sideTiebreakScores[losingSideIndex];
-  const hasTiebreakCondition = tiebreakAt && sideGameScores.filter(gameScore => gameScore >= tiebreakAt).length === 2;
-
-  if (setTiebreakDefined) {
-    const {
-      NoAD: tiebreakNoAD,
-      tiebreakTo
-    } = tiebreakFormat;
-
-    if (hasTiebreakCondition) {
-      if (gamesDifference > 1) {
-        return {
-          result: false,
-          error: 'invalid winning game scoreString (5)'
-        };
-      }
-
-      if (!validTiebreakScores) {
-        return {
-          result: false,
-          error: 'invalid tiebreak scores (1)'
-        };
-      }
-
-      if (isNaN(tiebreakTo)) {
-        return {
-          result: false,
-          error: 'tiebreakTo error'
-        }; // TODO: test this
-      }
-
-      const meetsTiebreakTo = !!(tiebreakTo && sideTiebreakScores !== null && sideTiebreakScores !== void 0 && sideTiebreakScores.find(tiebreakScore => tiebreakScore >= tiebreakTo));
-
-      if (!meetsTiebreakTo) {
-        return {
-          result: false,
-          error: 'invalid tiebreak scores (2)'
-        };
-      }
-
-      const maxGameScore = tiebreakAt < setTo ? setTo : setTo + 1;
-
-      if (winningSideGameScore > maxGameScore) {
-        return {
-          result: false,
-          error: 'invalid winning game scoreString (1)'
-        };
-      }
-
-      if (!winningSideTiebreakScore || !losingSideTiebreakScore || winningSideTiebreakScore < losingSideTiebreakScore) {
-        return {
-          result: false,
-          error: 'winningSide tiebreak value is not high'
-        };
-      }
-
-      const minimumTiebreakWinMargin = tiebreakNoAD ? 1 : 2;
-      const tiebreakDifference = winningSideTiebreakScore - losingSideTiebreakScore;
-      const losingSideGameScoreAtTiebreakToThreshold = losingSideTiebreakScore >= tiebreakTo - 1;
-      const invalidTiebreakScore = tiebreakDifference && losingSideGameScoreAtTiebreakToThreshold && tiebreakDifference < minimumTiebreakWinMargin;
-
-      if (invalidTiebreakScore) {
-        return {
-          result: false,
-          error: 'invalid tiebreak scores (3)'
-        };
-      }
-    }
-
-    const hasTiebreakGameScore = winningSideGameScore > setTo;
-
-    if (hasTiebreakGameScore && (!setTiebreakDefined || !hasTiebreakCondition)) {
-      return {
-        result: false,
-        error: 'invalid winning game scoreString (2)'
-      };
-    }
-  }
-
-  const minimumGamesWinMargin = NoAD ? 1 : 2;
-  const losingSideGameScoreAtSetToThreshold = losingSideGameScore >= setTo - 1;
-  const invalidWinningScore = gamesDifference && losingSideGameScoreAtSetToThreshold && !hasTiebreakCondition && gamesDifference < minimumGamesWinMargin;
-
-  if (invalidWinningScore) {
-    return {
-      result: false,
-      error: 'invalid winning game scoreString (3)'
-    };
-  }
-
-  if (gamesDifference > minimumGamesWinMargin && winningSideGameScore > setTo) {
-    return {
-      result: false,
-      error: 'invalid winning game scoreString (4)'
-    };
-  }
-
-  return {
-    result: true
-  };
-}
-
-function checkValidTiebreakSetOutcome({
-  setObject,
-  setFormat,
-  sideTiebreakScores
-}) {
-  if (!setObject) {
-    return {
-      result: false,
-      error: MISSING_SET_OBJECT
-    };
-  }
-
-  const expectTiebreakSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.tiebreakSet);
-  const expectTimedSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.timed);
-
-  if (!setFormat || !expectTiebreakSet || expectTimedSet) {
-    return {
-      result: false,
-      error: 'not tiebreak set'
-    };
-  }
-
-  const isValidWinningSide = [1, 2].includes(setObject === null || setObject === void 0 ? void 0 : setObject.winningSide);
-  if (!setObject || !isValidWinningSide) return {
-    result: false,
-    error: INVALID_WINNING_SIDE
-  };
-  const {
-    tiebreakSet
-  } = setFormat || {};
-  const {
-    NoAD,
-    tiebreakTo
-  } = tiebreakSet || {};
-  const validTiebreakScores = (sideTiebreakScores === null || sideTiebreakScores === void 0 ? void 0 : sideTiebreakScores.filter(s => !isNaN(s)).length) === 2;
-
-  if (!validTiebreakScores) {
-    return {
-      result: false,
-      error: 'invalid tiebreak scores (1)'
-    };
-  }
-
-  if (isNaN(tiebreakTo)) {
-    return {
-      result: false,
-      error: 'tiebreakTo error'
-    }; // TODO: test this
-  }
-
-  const meetsTiebreakTo = !!(sideTiebreakScores !== null && sideTiebreakScores !== void 0 && sideTiebreakScores.find(tiebreakScore => tiebreakScore >= tiebreakTo));
-
-  if (!meetsTiebreakTo) {
-    return {
-      result: false,
-      error: 'invalid tiebreak scores (2)'
-    };
-  }
-
-  const winningSideIndex = (setObject === null || setObject === void 0 ? void 0 : setObject.winningSide) - 1;
-  const losingSideIndex = 1 - winningSideIndex;
-  const winningSideTiebreakScore = sideTiebreakScores[winningSideIndex];
-  const losingSideTiebreakScore = sideTiebreakScores[losingSideIndex];
-
-  if (!winningSideTiebreakScore || !losingSideTiebreakScore || winningSideTiebreakScore < losingSideTiebreakScore) {
-    return {
-      result: false,
-      error: 'winningSide tiebreak value is not high'
-    };
-  }
-
-  const minimumTiebreakWinMargin = NoAD ? 1 : 2;
-  const tiebreakDifference = winningSideTiebreakScore - losingSideTiebreakScore;
-  const losingSideGameScoreAtTiebreakToThreshold = losingSideTiebreakScore >= tiebreakTo - 1;
-  const invalidTiebreakScore = tiebreakDifference && losingSideGameScoreAtTiebreakToThreshold && tiebreakDifference < minimumTiebreakWinMargin;
-
-  if (invalidTiebreakScore) {
-    return {
-      result: false,
-      error: 'invalid tiebreak scores (3)'
-    };
-  }
-
-  return {
-    result: true
-  };
-}
-
-function analyzeMatchUp(params) {
-  var _matchUp$score;
-
-  const {
-    matchUp,
-    sideNumber,
-    setNumber,
-    isTiebreakValue,
-    isPointValue
-  } = params || {};
-  let {
-    matchUpFormat
-  } = params || {};
-  if (!matchUp) return {
-    error: MISSING_MATCHUP
-  };
-  matchUpFormat = matchUpFormat || (matchUp === null || matchUp === void 0 ? void 0 : matchUp.matchUpFormat);
-  const matchUpScoringFormat = dist.exports.matchUpFormatCode === null || dist.exports.matchUpFormatCode === void 0 ? void 0 : dist.exports.matchUpFormatCode.parse(matchUpFormat);
-  const isCompletedMatchUp = !!(matchUp !== null && matchUp !== void 0 && matchUp.winningSide);
-  const sets = (_matchUp$score = matchUp.score) === null || _matchUp$score === void 0 ? void 0 : _matchUp$score.sets;
-  const setsCount = sets === null || sets === void 0 ? void 0 : sets.length;
-  const setIndex = setNumber && setNumber - 1;
-  const isExistingSet = !!(sets !== null && sets !== void 0 && sets.find((set, index) => set.setNumber === setNumber && index === setIndex));
-  const completedSets = (sets === null || sets === void 0 ? void 0 : sets.filter(set => set === null || set === void 0 ? void 0 : set.winningSide)) || [];
-  const completedSetsCount = (completedSets === null || completedSets === void 0 ? void 0 : completedSets.length) || 0;
-  const setsFollowingCurrent = setNumber && (sets === null || sets === void 0 ? void 0 : sets.slice(setNumber)) || [];
-  const isLastSetWithValues = !!(setsCount && setNumber && // EVERY: is this a candidate for .every?
-  setsFollowingCurrent !== null && setsFollowingCurrent !== void 0 && setsFollowingCurrent.reduce((noValues, set) => {
-    return (!set || !set.side1Score && !set.side2Score && !set.side1TiebreakScore && !set.side2TiebreakScore && !set.side1PointScore && !set.side2PointScore) && noValues;
-  }, true));
-  const setObject = setNumber <= setsCount && sets.find(set => set.setNumber === setNumber);
-  const specifiedSetAnalysis = setObject && analyzeSet({
-    setObject,
-    matchUpScoringFormat
-  });
-  const {
-    isCompletedSet,
-    sideGameScores,
-    // sidePointScores,
-    sideTiebreakScores
-  } = specifiedSetAnalysis || {};
-  const isActiveSet = !!(setObject && !isCompletedSet && isLastSetWithValues || setNumber && setNumber === setsCount + 1 && !isCompletedMatchUp);
-  const isValidSideNumber = [1, 2].includes(sideNumber);
-  const sideIndex = isValidSideNumber ? sideNumber - 1 : 0;
-  const existingValue = setObject && isValidSideNumber && (!isTiebreakValue && !isPointValue && sideGameScores[sideIndex] !== undefined && sideGameScores[sideIndex] || isTiebreakValue && sideTiebreakScores[sideIndex] !== undefined && sideTiebreakScores[sideIndex]);
-  const hasExistingValue = !!existingValue;
-  const completedSetsHaveValidOutcomes = completedSets && completedSets.map(setObject => analyzeSet({
-    setObject,
-    matchUpScoringFormat
-  }).isValidSetOutcome).reduce((valid, validOutcome) => valid && validOutcome, true);
-  const setsWinCounts = completedSets.reduce((counts, set) => {
-    const {
-      winningSide
-    } = set;
-    const winningSideIndex = winningSide - 1;
-    counts[winningSideIndex]++;
-    return counts;
-  }, [0, 0]);
-  const matchUpWinningSide = matchUp === null || matchUp === void 0 ? void 0 : matchUp.winningSide;
-  const matchUpWinningSideIndex = matchUpWinningSide && matchUpWinningSide - 1;
-  const matchUpLosingSideIndex = 1 - matchUpWinningSideIndex;
-  const winningSideSetsCount = setsWinCounts[matchUpWinningSideIndex];
-  const losingSideSetsCount = setsWinCounts[matchUpLosingSideIndex];
-  const maxSetsCount = Math.max(...setsWinCounts);
-  const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
-  const {
-    bestOf
-  } = matchUpScoringFormat || {};
-  const setsToWin = bestOf && Math.ceil(bestOf / 2) || 1;
-  const calculatedWinningSide = maxSetsCount === setsToWin && maxSetsInstances === 1 && setsWinCounts.indexOf(maxSetsCount) + 1 || undefined;
-  const validMatchUpWinningSide = winningSideSetsCount > losingSideSetsCount && matchUpWinningSide === calculatedWinningSide;
-  const validMatchUpOutcome = calculatedWinningSide && completedSetsHaveValidOutcomes && validMatchUpWinningSide;
-  return {
-    isActiveSet,
-    isExistingSet,
-    existingValue,
-    hasExistingValue,
-    isValidSideNumber,
-    completedSetsCount,
-    isCompletedMatchUp,
-    isLastSetWithValues,
-    validMatchUpOutcome,
-    matchUpScoringFormat,
-    calculatedWinningSide,
-    validMatchUpWinningSide,
-    completedSetsHaveValidOutcomes,
-    ...specifiedSetAnalysis
-  };
-}
-
 function getWinningSide({
   analysis,
   set
 }) {
-  const leadingSide = getLeadingSide({
+  const leadingSide = getLeadingSide$1({
     set
   });
   const {
@@ -4557,7 +3968,7 @@ function getWinningSide({
     isTiebreakSet,
     matchUpScoringFormat
   } = analysis;
-  const setIsComplete = checkSetIsComplete({
+  const setIsComplete = checkSetIsComplete$1({
     matchUpScoringFormat,
     isDecidingSet,
     isTiebreakSet,
@@ -4565,17 +3976,21 @@ function getWinningSide({
   });
   return setIsComplete && leadingSide;
 }
-function checkSetIsComplete({
+function checkSetIsComplete$1({
   ignoreTiebreak = false,
   matchUpScoringFormat,
+  matchUpFormat,
   isTiebreakSet,
   isDecidingSet,
   set
 }) {
+  var _matchUpScoringFormat;
+
   if (!set) return {
     error: MISSING_VALUE
   };
-  const setFormat = isDecidingSet && matchUpScoringFormat.finalSetFormat || (matchUpScoringFormat === null || matchUpScoringFormat === void 0 ? void 0 : matchUpScoringFormat.setFormat);
+  matchUpScoringFormat = matchUpScoringFormat || matchUpFormat;
+  const setFormat = isDecidingSet && matchUpScoringFormat.finalSetFormat || ((_matchUpScoringFormat = matchUpScoringFormat) === null || _matchUpScoringFormat === void 0 ? void 0 : _matchUpScoringFormat.setFormat);
   const {
     side1Score,
     side2Score
@@ -4587,7 +4002,7 @@ function checkSetIsComplete({
     tiebreakFormat
   } = setFormat;
   const tiebreakNoAd = tiebreakFormat === null || tiebreakFormat === void 0 ? void 0 : tiebreakFormat.NoAd;
-  const leadingSide = getLeadingSide({
+  const leadingSide = getLeadingSide$1({
     set
   });
   const scoreDiff = Math.abs(side1Score - side2Score);
@@ -4599,7 +4014,7 @@ function checkSetIsComplete({
   const validNormalSetScore = containsSetTo && (hasWinMargin || requiresTiebreak);
   return (validNormalSetScore || isTiebreakSet) && (!requiresTiebreak || tiebreakIsValid);
 }
-function getLeadingSide({
+function getLeadingSide$1({
   set
 }) {
   if (set.side1Score || set.side2Score) {
@@ -5736,148 +5151,741 @@ function keyValueScore(params) {
       tiebreakFormat
     } = analysis.setFormat;
     const {
-      tiebreakTo,
-      NoAD
-    } = tiebreakFormat || {};
-    const leadingSide = getLeadingSide({
-      set
-    });
+      tiebreakTo,
+      NoAD
+    } = tiebreakFormat || {};
+    const leadingSide = getLeadingSide$1({
+      set
+    });
+
+    if (!analysis.isTiebreakSet) {
+      const lowTiebreakScore = parseInt(scoreString.split(open).reverse()[0]);
+      const highTiebreakScore = getHighTiebreakValue({
+        lowValue: lowTiebreakScore,
+        tiebreakTo,
+        NoAD
+      });
+
+      if (leadingSide === 1) {
+        set.side1TiebreakScore = highTiebreakScore;
+        set.side2TiebreakScore = lowTiebreakScore;
+      } else {
+        set.side1TiebreakScore = lowTiebreakScore;
+        set.side2TiebreakScore = highTiebreakScore;
+      }
+    }
+
+    scoreString = (scoreString || '') + close;
+    if (!analysis.isDecidingSet) scoreString += SPACE_CHARACTER;
+    const winningSide = getWinningSide({
+      analysis,
+      set
+    });
+    set.winningSide = winningSide || undefined;
+    updated = true;
+  } else if (analysis.isTiebreakSetValue) {
+    ({
+      message,
+      scoreString,
+      sets,
+      updated
+    } = processTiebreakSet({
+      analysis,
+      auto,
+      lowSide,
+      scoreString,
+      sets,
+      value
+    }));
+  } else if (analysis.isSetTiebreakEntry) {
+    const [open] = SET_TIEBREAK_BRACKETS.split('');
+    const lastOpenBracketIndex = Math.max(...indices(open, scoreString.split('')));
+    const tiebreakValue = scoreString.slice(lastOpenBracketIndex + 1);
+    const hasZeroStart = tiebreakValue && parseInt(tiebreakValue) === ZERO;
+    const newTiebreakValue = parseInt(tiebreakValue ? tiebreakValue + value : value);
+    const {
+      tiebreakFormat
+    } = analysis.setFormat;
+    const {
+      tiebreakTo,
+      NoAD
+    } = tiebreakFormat || {};
+
+    if (!hasZeroStart && tiebreakValue.length < 2) {
+      if (NoAD && newTiebreakValue > tiebreakTo - 1) {
+        message = 'invalid low value for NoAD tiebreak';
+      } else {
+        updated = true;
+        scoreString = (scoreString || '') + value;
+      }
+    } else {
+      message = hasZeroStart ? 'tiebreak begins with zero' : 'tiebreak digit limit';
+    }
+  } else if (analysis.isCloser) {
+    message = `invalid key: ${value}`;
+  } else if (analysis.isGameScoreEntry) {
+    message = 'game scoreString entry';
+  } else {
+    if (analysis.lastSetIsComplete || !sets.length) {
+      var _sets, _sets2;
+
+      updated = true;
+      const {
+        scoreString: newScore,
+        set
+      } = keyValueSetScore({
+        analysis,
+        lowSide,
+        scoreString,
+        value: parseInt(value)
+      });
+      if (set) set.setNumber = ((_sets = sets) === null || _sets === void 0 ? void 0 : _sets.length) + 1 || 1;
+      sets = ((_sets2 = sets) === null || _sets2 === void 0 ? void 0 : _sets2.concat(set).filter(Boolean)) || [set];
+      scoreString = newScore || undefined;
+    } else {
+      console.log('error: unknown outcome');
+    }
+  }
+
+  if (updated) {
+    var _sets3;
+
+    sets = (_sets3 = sets) === null || _sets3 === void 0 ? void 0 : _sets3.filter(Boolean);
+    const {
+      matchUpWinningSide
+    } = getMatchUpWinner({
+      sets,
+      winningSide,
+      matchUpStatus,
+      matchUpFormat
+    });
+    winningSide = matchUpWinningSide;
+
+    if (matchUpWinningSide && (!matchUpStatus || [TO_BE_PLAYED, INCOMPLETE].includes(matchUpStatus))) {
+      matchUpStatus = OUTCOME_COMPLETE;
+      sets = sets.filter(set => {
+        const {
+          side1Score,
+          side2Score,
+          side1TiebreakScore,
+          side2TiebreakScore
+        } = set;
+        return side1Score || side2Score || side1TiebreakScore || side2TiebreakScore;
+      });
+    } else if (scoreString && !winningSide && ![STATUS_SUSPENDED, STATUS_ABANDONED, STATUS_INTERRUPTED].includes(matchUpStatus)) {
+      matchUpStatus = undefined;
+    }
+
+    return {
+      updated,
+      scoreString,
+      sets,
+      winningSide,
+      matchUpStatus,
+      message
+    };
+  }
+
+  return {
+    updated,
+    scoreString,
+    sets,
+    winningSide,
+    matchUpStatus,
+    message
+  };
+}
+
+/**
+ *
+ * @param {object[]} - sets - TODS sets object
+ * @param {string} - matchUpStatus - TODS matchUpStatus ENUM
+ * @param {number || string} - winningSide - TODS side declaration: 1 or 2
+ * @param {boolean} - winnerFirst - generate string with winner on left side
+ * @param {boolean} - autoComplete - whether to convert undefined values to 0
+ *
+ */
+
+function generateScoreString(params) {
+  const {
+    sets,
+    winningSide,
+    autoComplete,
+    matchUpStatus,
+    reversed = false,
+    winnerFirst = true,
+    addOutcomeString
+  } = params;
+  if (!sets) return {
+    error: MISSING_VALUE
+  };
+  const scoresInSideOrder = !winnerFirst || !winningSide || winningSide === 1;
+  const reverseScores = reversed || !scoresInSideOrder;
+  const outcomeString = addOutcomeString ? getOutcomeString({
+    matchUpStatus
+  }) : '';
+  const setScores = (sets === null || sets === void 0 ? void 0 : sets.sort(setSort).map(setString).filter(Boolean) // handle situation where there are multiple empty set objects
+  .join(' ')) || '';
+  if (!outcomeString) return setScores;
+  if (winningSide === 2) return `${outcomeString} ${setScores}`;
+  return `${setScores} ${outcomeString}`;
+
+  function setString(currentSet) {
+    const hasGameScores = set => isNumeric(set === null || set === void 0 ? void 0 : set.side1Score) || isNumeric(set === null || set === void 0 ? void 0 : set.side2Score);
+
+    const hasTiebreakScores = set => isNumeric(set === null || set === void 0 ? void 0 : set.side1TiebreakScore) || isNumeric(set === null || set === void 0 ? void 0 : set.side2TiebreakScore);
+
+    const isTiebreakSet = !hasGameScores(currentSet) && hasTiebreakScores(currentSet);
+    const {
+      side1Score,
+      side2Score,
+      side1TiebreakScore,
+      side2TiebreakScore
+    } = currentSet;
+    const t1 = side1TiebreakScore || (isNumeric(side1TiebreakScore) || autoComplete ? 0 : '');
+    const t2 = side2TiebreakScore || (isNumeric(side2TiebreakScore) || autoComplete ? 0 : '');
+
+    if (isTiebreakSet) {
+      const tiebreakScore = reverseScores ? [t2, t1] : [t1, t2];
+      return `[${tiebreakScore.join('-')}]`;
+    }
+
+    const lowTiebreakScore = Math.min(t1, t2);
+    const tiebreak = lowTiebreakScore ? `(${lowTiebreakScore})` : '';
+    const s1 = side1Score || (isNumeric(side1Score) || autoComplete ? 0 : '');
+    const s2 = side2Score || (isNumeric(side2Score) || autoComplete ? 0 : '');
+    let scoreString = reverseScores ? `${[s2, s1].join('-')}${tiebreak}` : `${[s1, s2].join('-')}${tiebreak}`;
+    if (['-', ' '].includes(scoreString)) scoreString = '';
+    return scoreString;
+  }
+}
+
+function getOutcomeString({
+  matchUpStatus
+}) {
+  const outcomeStrings = {
+    [RETIRED]: 'RET',
+    [WALKOVER$1]: 'WO',
+    [DOUBLE_WALKOVER]: 'WO/WO',
+    [SUSPENDED]: 'SUS',
+    [ABANDONED]: 'ABN',
+    [DEFAULTED]: 'DEF',
+    [DEAD_RUBBER]: 'DR'
+  };
+  return matchUpStatus && outcomeStrings[matchUpStatus] || '';
+}
+
+function setSort(a, b) {
+  return a.setNumber - b.setNumber;
+}
+
+function getSetWinningSide({
+  matchUpScoringFormat,
+  isDecidingSet,
+  isTiebreakSet,
+  setObject
+}) {
+  if (!setObject) return undefined;
+  const leadingSide = getLeadingSide({
+    set: setObject
+  });
+  const setIsComplete = checkSetIsComplete({
+    matchUpScoringFormat,
+    isDecidingSet,
+    isTiebreakSet,
+    set: setObject
+  });
+  return setIsComplete && leadingSide || undefined;
+}
+function checkSetIsComplete({
+  ignoreTiebreak = false,
+  matchUpScoringFormat,
+  matchUpFormat,
+  isTiebreakSet,
+  isDecidingSet,
+  set
+}) {
+  var _matchUpScoringFormat;
+
+  if (!set) return {
+    error: MISSING_VALUE
+  };
+  matchUpScoringFormat = matchUpScoringFormat || matchUpFormat;
+  const setFormat = isDecidingSet && matchUpScoringFormat.finalSetFormat || ((_matchUpScoringFormat = matchUpScoringFormat) === null || _matchUpScoringFormat === void 0 ? void 0 : _matchUpScoringFormat.setFormat) || {};
+  const {
+    side1Score,
+    side2Score
+  } = set;
+  const {
+    setTo,
+    tiebreakAt,
+    tiebreakFormat
+  } = setFormat;
+  const NoAD = tiebreakFormat === null || tiebreakFormat === void 0 ? void 0 : tiebreakFormat.NoAd;
+  const leadingSide = getLeadingSide({
+    set
+  });
+  const scoreDiff = Math.abs(side1Score - side2Score);
+  const containsSetTo = side1Score >= setTo || side2Score >= setTo;
+  const requiresTiebreak = isTiebreakSet || side1Score >= setTo && side2Score >= setTo || tiebreakAt && tiebreakAt < setTo && (side1Score === tiebreakAt || side2Score === tiebreakAt);
+  const tiebreakIsValid = ignoreTiebreak || requiresTiebreak && (leadingSide === 1 && set.side1TiebreakScore > set.side2TiebreakScore || leadingSide === 2 && set.side2TiebreakScore > set.side1TiebreakScore);
+  const winMargin = requiresTiebreak && (tiebreakAt && !isTiebreakSet || isTiebreakSet && NoAD) ? 1 : 2;
+  const hasWinMargin = scoreDiff >= winMargin;
+  const validNormalSetScore = containsSetTo && (hasWinMargin || requiresTiebreak);
+  return (validNormalSetScore || isTiebreakSet) && (!requiresTiebreak || tiebreakIsValid);
+}
+function getLeadingSide({
+  set
+}) {
+  if (set.side1Score || set.side2Score) {
+    if (set.side1Score > set.side2Score) return 1;
+    if (set.side2Score > set.side1Score) return 2;
+  } else if (set.side1TiebreakScore || set.side2TiebreakScore) {
+    if (set.side1TiebreakScore > set.side2TiebreakScore) return 1;
+    if (set.side2TiebreakScore > set.side1TiebreakScore) return 2;
+  }
+
+  return undefined;
+}
+
+function analyzeSet(params) {
+  const {
+    setObject,
+    matchUpScoringFormat
+  } = params;
+  if (!setObject) return {
+    error: MISSING_SET_OBJECT
+  };
+  const {
+    setNumber
+  } = setObject || {};
+  const {
+    bestOf
+  } = matchUpScoringFormat || {};
+  const isDecidingSet = !!(setNumber && setNumber === bestOf);
+  const setFormat = isDecidingSet && (matchUpScoringFormat === null || matchUpScoringFormat === void 0 ? void 0 : matchUpScoringFormat.finalSetFormat) || (matchUpScoringFormat === null || matchUpScoringFormat === void 0 ? void 0 : matchUpScoringFormat.setFormat);
+  const expectTiebreakSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.tiebreakSet);
+  const expectTimedSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.timed);
+  const expectStandardSet = !expectTiebreakSet && !expectTimedSet;
+  const isValidSetNumber = !!(setNumber && bestOf && setNumber <= bestOf);
+  const sideGameScores = [setObject === null || setObject === void 0 ? void 0 : setObject.side1Score, setObject === null || setObject === void 0 ? void 0 : setObject.side2Score];
+  const sidePointScores = [setObject === null || setObject === void 0 ? void 0 : setObject.side1PointScore, setObject === null || setObject === void 0 ? void 0 : setObject.side2PointScore];
+  const sideTiebreakScores = [setObject === null || setObject === void 0 ? void 0 : setObject.side1TiebreakScore, setObject === null || setObject === void 0 ? void 0 : setObject.side2TiebreakScore];
+  const sideGameScoresCount = sideGameScores.filter(sideScore => sideScore !== undefined).length;
+  const sidePointScoresCount = sidePointScores.filter(sideScore => sideScore !== undefined).length;
+  const sideTiebreakScoresCount = sideTiebreakScores.filter(tiebreakScore => tiebreakScore !== undefined).length;
+  const gameScoresCount = sideGameScores === null || sideGameScores === void 0 ? void 0 : sideGameScores.filter(s => !isNaN(s)).length;
+  const tiebreakScoresCount = sideTiebreakScores === null || sideTiebreakScores === void 0 ? void 0 : sideTiebreakScores.filter(s => !isNaN(s)).length;
+  const {
+    tiebreakAt
+  } = setFormat || {};
+  const hasTiebreakCondition = tiebreakAt && sideGameScores.filter(gameScore => gameScore >= tiebreakAt).length === 2;
+  const leadingSide = hasTiebreakCondition && (sideGameScores[0] > sideGameScores[1] ? 1 : sideGameScores[1] > sideGameScores[0] ? 2 : undefined);
+  const isTiebreakSet = !!(tiebreakScoresCount && !gameScoresCount);
+  const isCompletedSet = !!(setObject && setObject !== null && setObject !== void 0 && setObject.winningSide);
+  const {
+    error: standardSetError,
+    result: isValidStandardSetOutcome
+  } = checkValidStandardSetOutcome({
+    setObject,
+    setFormat,
+    sideGameScores,
+    sideTiebreakScores
+  });
+  const {
+    error: tiebreakSetError,
+    result: isValidTiebreakSetOutcome
+  } = checkValidTiebreakSetOutcome({
+    setObject,
+    setFormat,
+    sideTiebreakScores
+  });
+  const isValidSetOutcome = expectStandardSet && !isTiebreakSet && isValidStandardSetOutcome || expectTiebreakSet && isTiebreakSet && isValidTiebreakSetOutcome;
+  const isValidSet = isValidSetNumber && !(expectTiebreakSet && !isTiebreakSet) && !(expectStandardSet && isTiebreakSet) && (!isCompletedSet || isValidSetOutcome);
+  const winningSide = getSetWinningSide({
+    isDecidingSet,
+    isTiebreakSet,
+    matchUpScoringFormat,
+    setObject
+  });
+  const analysis = {
+    expectTiebreakSet,
+    expectTimedSet,
+    hasTiebreakCondition,
+    isCompletedSet,
+    isDecidingSet,
+    isTiebreakSet,
+    isValidSet,
+    isValidSetNumber,
+    isValidSetOutcome,
+    leadingSide,
+    setFormat,
+    sideGameScores,
+    sideGameScoresCount,
+    sidePointScores,
+    sidePointScoresCount,
+    sideTiebreakScores,
+    sideTiebreakScoresCount,
+    winningSide
+  };
+
+  if ((setObject === null || setObject === void 0 ? void 0 : setObject.winningSide) !== undefined) {
+    if (isTiebreakSet) {
+      analysis.isValidTiebreakSetOutcome = isValidTiebreakSetOutcome;
+
+      if (!isValidTiebreakSetOutcome) {
+        analysis.tiebreakSetError = tiebreakSetError;
+      }
+    } else {
+      analysis.isValidStandardSetOutcome = isValidStandardSetOutcome;
+
+      if (!isValidStandardSetOutcome) {
+        analysis.standardSetError = standardSetError;
+      }
+    }
+  }
+
+  return analysis;
+}
+
+function checkValidStandardSetOutcome({
+  setObject,
+  setFormat,
+  sideGameScores,
+  sideTiebreakScores
+}) {
+  if (!setObject) {
+    return {
+      result: false,
+      error: MISSING_SET_OBJECT
+    };
+  }
+
+  const expectTiebreakSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.tiebreakSet);
+  const expectTimedSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.timed);
+
+  if (!setFormat || expectTiebreakSet || expectTimedSet) {
+    return {
+      result: false,
+      error: 'not standard set'
+    };
+  }
+
+  const validGameScores = (sideGameScores === null || sideGameScores === void 0 ? void 0 : sideGameScores.filter(s => !isNaN(s)).length) === 2;
+  if (!validGameScores) return {
+    result: false,
+    error: INVALID_GAME_SCORES
+  };
+  const {
+    setTo,
+    tiebreakAt,
+    tiebreakFormat,
+    NoAD
+  } = setFormat || {};
+  const meetsSetTo = !!(setTo && sideGameScores !== null && sideGameScores !== void 0 && sideGameScores.find(gameScore => gameScore >= setTo));
+  if (!meetsSetTo) return {
+    result: false,
+    error: INVALID_GAME_SCORES
+  };
+  const isValidWinningSide = [1, 2].includes(setObject === null || setObject === void 0 ? void 0 : setObject.winningSide);
+  if (!setObject || !isValidWinningSide) return {
+    result: false,
+    error: INVALID_WINNING_SIDE
+  };
+  const winningSideIndex = (setObject === null || setObject === void 0 ? void 0 : setObject.winningSide) - 1;
+  const losingSideIndex = 1 - winningSideIndex;
+  const winningSideGameScore = sideGameScores[winningSideIndex];
+  const losingSideGameScore = sideGameScores[losingSideIndex];
+  const gamesDifference = winningSideGameScore - losingSideGameScore;
+  const winningSideIsHighGameValue = winningSideGameScore > losingSideGameScore;
+
+  if (!winningSideIsHighGameValue) {
+    return {
+      result: false,
+      error: 'winningSide game scoreString is not high'
+    };
+  }
+
+  const setTiebreakDefined = tiebreakAt && tiebreakFormat;
+  const validTiebreakScores = (sideTiebreakScores === null || sideTiebreakScores === void 0 ? void 0 : sideTiebreakScores.filter(s => !isNaN(s)).length) === 2;
+  const winningSideTiebreakScore = sideTiebreakScores && sideTiebreakScores[winningSideIndex];
+  const losingSideTiebreakScore = sideTiebreakScores && sideTiebreakScores[losingSideIndex];
+  const hasTiebreakCondition = tiebreakAt && sideGameScores.filter(gameScore => gameScore >= tiebreakAt).length === 2;
+
+  if (setTiebreakDefined) {
+    const {
+      NoAD: tiebreakNoAD,
+      tiebreakTo
+    } = tiebreakFormat;
 
-    if (!analysis.isTiebreakSet) {
-      const lowTiebreakScore = parseInt(scoreString.split(open).reverse()[0]);
-      const highTiebreakScore = getHighTiebreakValue({
-        lowValue: lowTiebreakScore,
-        tiebreakTo,
-        NoAD
-      });
+    if (hasTiebreakCondition) {
+      if (gamesDifference > 1) {
+        return {
+          result: false,
+          error: 'invalid winning game scoreString (5)'
+        };
+      }
 
-      if (leadingSide === 1) {
-        set.side1TiebreakScore = highTiebreakScore;
-        set.side2TiebreakScore = lowTiebreakScore;
-      } else {
-        set.side1TiebreakScore = lowTiebreakScore;
-        set.side2TiebreakScore = highTiebreakScore;
+      if (!validTiebreakScores) {
+        return {
+          result: false,
+          error: 'invalid tiebreak scores (1)'
+        };
       }
-    }
 
-    scoreString = (scoreString || '') + close;
-    if (!analysis.isDecidingSet) scoreString += SPACE_CHARACTER;
-    const winningSide = getWinningSide({
-      analysis,
-      set
-    });
-    set.winningSide = winningSide || undefined;
-    updated = true;
-  } else if (analysis.isTiebreakSetValue) {
-    ({
-      message,
-      scoreString,
-      sets,
-      updated
-    } = processTiebreakSet({
-      analysis,
-      auto,
-      lowSide,
-      scoreString,
-      sets,
-      value
-    }));
-  } else if (analysis.isSetTiebreakEntry) {
-    const [open] = SET_TIEBREAK_BRACKETS.split('');
-    const lastOpenBracketIndex = Math.max(...indices(open, scoreString.split('')));
-    const tiebreakValue = scoreString.slice(lastOpenBracketIndex + 1);
-    const hasZeroStart = tiebreakValue && parseInt(tiebreakValue) === ZERO;
-    const newTiebreakValue = parseInt(tiebreakValue ? tiebreakValue + value : value);
-    const {
-      tiebreakFormat
-    } = analysis.setFormat;
-    const {
-      tiebreakTo,
-      NoAD
-    } = tiebreakFormat || {};
+      if (isNaN(tiebreakTo)) {
+        return {
+          result: false,
+          error: 'tiebreakTo error'
+        }; // TODO: test this
+      }
 
-    if (!hasZeroStart && tiebreakValue.length < 2) {
-      if (NoAD && newTiebreakValue > tiebreakTo - 1) {
-        message = 'invalid low value for NoAD tiebreak';
-      } else {
-        updated = true;
-        scoreString = (scoreString || '') + value;
+      const meetsTiebreakTo = !!(tiebreakTo && sideTiebreakScores !== null && sideTiebreakScores !== void 0 && sideTiebreakScores.find(tiebreakScore => tiebreakScore >= tiebreakTo));
+
+      if (!meetsTiebreakTo) {
+        return {
+          result: false,
+          error: 'invalid tiebreak scores (2)'
+        };
+      }
+
+      const maxGameScore = tiebreakAt < setTo ? setTo : setTo + 1;
+
+      if (winningSideGameScore > maxGameScore) {
+        return {
+          result: false,
+          error: 'invalid winning game scoreString (1)'
+        };
+      }
+
+      if (!winningSideTiebreakScore || !losingSideTiebreakScore || winningSideTiebreakScore < losingSideTiebreakScore) {
+        return {
+          result: false,
+          error: 'winningSide tiebreak value is not high'
+        };
+      }
+
+      const minimumTiebreakWinMargin = tiebreakNoAD ? 1 : 2;
+      const tiebreakDifference = winningSideTiebreakScore - losingSideTiebreakScore;
+      const losingSideGameScoreAtTiebreakToThreshold = losingSideTiebreakScore >= tiebreakTo - 1;
+      const invalidTiebreakScore = tiebreakDifference && losingSideGameScoreAtTiebreakToThreshold && tiebreakDifference < minimumTiebreakWinMargin;
+
+      if (invalidTiebreakScore) {
+        return {
+          result: false,
+          error: 'invalid tiebreak scores (3)'
+        };
       }
-    } else {
-      message = hasZeroStart ? 'tiebreak begins with zero' : 'tiebreak digit limit';
     }
-  } else if (analysis.isCloser) {
-    message = `invalid key: ${value}`;
-  } else if (analysis.isGameScoreEntry) {
-    message = 'game scoreString entry';
-  } else {
-    if (analysis.lastSetIsComplete || !sets.length) {
-      var _sets, _sets2;
 
-      updated = true;
-      const {
-        scoreString: newScore,
-        set
-      } = keyValueSetScore({
-        analysis,
-        lowSide,
-        scoreString,
-        value: parseInt(value)
-      });
-      if (set) set.setNumber = ((_sets = sets) === null || _sets === void 0 ? void 0 : _sets.length) + 1 || 1;
-      sets = ((_sets2 = sets) === null || _sets2 === void 0 ? void 0 : _sets2.concat(set).filter(Boolean)) || [set];
-      scoreString = newScore || undefined;
-    } else {
-      console.log('error: unknown outcome');
+    const hasTiebreakGameScore = winningSideGameScore > setTo;
+
+    if (hasTiebreakGameScore && (!setTiebreakDefined || !hasTiebreakCondition)) {
+      return {
+        result: false,
+        error: 'invalid winning game scoreString (2)'
+      };
     }
   }
 
-  if (updated) {
-    var _sets3;
+  const minimumGamesWinMargin = NoAD ? 1 : 2;
+  const losingSideGameScoreAtSetToThreshold = losingSideGameScore >= setTo - 1;
+  const invalidWinningScore = gamesDifference && losingSideGameScoreAtSetToThreshold && !hasTiebreakCondition && gamesDifference < minimumGamesWinMargin;
 
-    sets = (_sets3 = sets) === null || _sets3 === void 0 ? void 0 : _sets3.filter(Boolean);
-    const {
-      matchUpWinningSide
-    } = getMatchUpWinner({
-      sets,
-      winningSide,
-      matchUpStatus,
-      matchUpFormat
-    });
-    winningSide = matchUpWinningSide;
+  if (invalidWinningScore) {
+    return {
+      result: false,
+      error: 'invalid winning game scoreString (3)'
+    };
+  }
 
-    if (matchUpWinningSide && (!matchUpStatus || [TO_BE_PLAYED, INCOMPLETE].includes(matchUpStatus))) {
-      matchUpStatus = OUTCOME_COMPLETE;
-      sets = sets.filter(set => {
-        const {
-          side1Score,
-          side2Score,
-          side1TiebreakScore,
-          side2TiebreakScore
-        } = set;
-        return side1Score || side2Score || side1TiebreakScore || side2TiebreakScore;
-      });
-    } else if (scoreString && !winningSide && ![STATUS_SUSPENDED, STATUS_ABANDONED, STATUS_INTERRUPTED].includes(matchUpStatus)) {
-      matchUpStatus = undefined;
-    }
+  if (gamesDifference > minimumGamesWinMargin && winningSideGameScore > setTo) {
+    return {
+      result: false,
+      error: 'invalid winning game scoreString (4)'
+    };
+  }
+
+  return {
+    result: true
+  };
+}
 
+function checkValidTiebreakSetOutcome({
+  setObject,
+  setFormat,
+  sideTiebreakScores
+}) {
+  if (!setObject) {
     return {
-      updated,
-      scoreString,
-      sets,
-      winningSide,
-      matchUpStatus,
-      message
+      result: false,
+      error: MISSING_SET_OBJECT
+    };
+  }
+
+  const expectTiebreakSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.tiebreakSet);
+  const expectTimedSet = !!(setFormat !== null && setFormat !== void 0 && setFormat.timed);
+
+  if (!setFormat || !expectTiebreakSet || expectTimedSet) {
+    return {
+      result: false,
+      error: 'not tiebreak set'
+    };
+  }
+
+  const isValidWinningSide = [1, 2].includes(setObject === null || setObject === void 0 ? void 0 : setObject.winningSide);
+  if (!setObject || !isValidWinningSide) return {
+    result: false,
+    error: INVALID_WINNING_SIDE
+  };
+  const {
+    tiebreakSet
+  } = setFormat || {};
+  const {
+    NoAD,
+    tiebreakTo
+  } = tiebreakSet || {};
+  const validTiebreakScores = (sideTiebreakScores === null || sideTiebreakScores === void 0 ? void 0 : sideTiebreakScores.filter(s => !isNaN(s)).length) === 2;
+
+  if (!validTiebreakScores) {
+    return {
+      result: false,
+      error: 'invalid tiebreak scores (1)'
+    };
+  }
+
+  if (isNaN(tiebreakTo)) {
+    return {
+      result: false,
+      error: 'tiebreakTo error'
+    }; // TODO: test this
+  }
+
+  const meetsTiebreakTo = !!(sideTiebreakScores !== null && sideTiebreakScores !== void 0 && sideTiebreakScores.find(tiebreakScore => tiebreakScore >= tiebreakTo));
+
+  if (!meetsTiebreakTo) {
+    return {
+      result: false,
+      error: 'invalid tiebreak scores (2)'
+    };
+  }
+
+  const winningSideIndex = (setObject === null || setObject === void 0 ? void 0 : setObject.winningSide) - 1;
+  const losingSideIndex = 1 - winningSideIndex;
+  const winningSideTiebreakScore = sideTiebreakScores[winningSideIndex];
+  const losingSideTiebreakScore = sideTiebreakScores[losingSideIndex];
+
+  if (!winningSideTiebreakScore || !losingSideTiebreakScore || winningSideTiebreakScore < losingSideTiebreakScore) {
+    return {
+      result: false,
+      error: 'winningSide tiebreak value is not high'
+    };
+  }
+
+  const minimumTiebreakWinMargin = NoAD ? 1 : 2;
+  const tiebreakDifference = winningSideTiebreakScore - losingSideTiebreakScore;
+  const losingSideGameScoreAtTiebreakToThreshold = losingSideTiebreakScore >= tiebreakTo - 1;
+  const invalidTiebreakScore = tiebreakDifference && losingSideGameScoreAtTiebreakToThreshold && tiebreakDifference < minimumTiebreakWinMargin;
+
+  if (invalidTiebreakScore) {
+    return {
+      result: false,
+      error: 'invalid tiebreak scores (3)'
     };
   }
 
   return {
-    updated,
-    scoreString,
-    sets,
-    winningSide,
-    matchUpStatus,
-    message
+    result: true
+  };
+}
+
+function analyzeMatchUp(params) {
+  var _matchUp$score;
+
+  const {
+    matchUp,
+    sideNumber,
+    setNumber,
+    isTiebreakValue,
+    isPointValue
+  } = params || {};
+  let {
+    matchUpFormat
+  } = params || {};
+  if (!matchUp) return {
+    error: MISSING_MATCHUP
+  };
+  matchUpFormat = matchUpFormat || (matchUp === null || matchUp === void 0 ? void 0 : matchUp.matchUpFormat);
+  const matchUpScoringFormat = dist.exports.matchUpFormatCode === null || dist.exports.matchUpFormatCode === void 0 ? void 0 : dist.exports.matchUpFormatCode.parse(matchUpFormat);
+  const isCompletedMatchUp = !!(matchUp !== null && matchUp !== void 0 && matchUp.winningSide);
+  const sets = (_matchUp$score = matchUp.score) === null || _matchUp$score === void 0 ? void 0 : _matchUp$score.sets;
+  const setsCount = sets === null || sets === void 0 ? void 0 : sets.length;
+  const setIndex = setNumber && setNumber - 1;
+  const isExistingSet = !!(sets !== null && sets !== void 0 && sets.find((set, index) => set.setNumber === setNumber && index === setIndex));
+  const completedSets = (sets === null || sets === void 0 ? void 0 : sets.filter(set => set === null || set === void 0 ? void 0 : set.winningSide)) || [];
+  const completedSetsCount = (completedSets === null || completedSets === void 0 ? void 0 : completedSets.length) || 0;
+  const setsFollowingCurrent = setNumber && (sets === null || sets === void 0 ? void 0 : sets.slice(setNumber)) || [];
+  const isLastSetWithValues = !!(setsCount && setNumber && // EVERY: is this a candidate for .every?
+  setsFollowingCurrent !== null && setsFollowingCurrent !== void 0 && setsFollowingCurrent.reduce((noValues, set) => {
+    return (!set || !set.side1Score && !set.side2Score && !set.side1TiebreakScore && !set.side2TiebreakScore && !set.side1PointScore && !set.side2PointScore) && noValues;
+  }, true));
+  const setObject = setNumber <= setsCount && sets.find(set => set.setNumber === setNumber);
+  const specifiedSetAnalysis = setObject && analyzeSet({
+    setObject,
+    matchUpScoringFormat
+  });
+  const {
+    isCompletedSet,
+    sideGameScores,
+    // sidePointScores,
+    sideTiebreakScores
+  } = specifiedSetAnalysis || {};
+  const isActiveSet = !!(setObject && !isCompletedSet && isLastSetWithValues || setNumber && setNumber === setsCount + 1 && !isCompletedMatchUp);
+  const isValidSideNumber = [1, 2].includes(sideNumber);
+  const sideIndex = isValidSideNumber ? sideNumber - 1 : 0;
+  const existingValue = setObject && isValidSideNumber && (!isTiebreakValue && !isPointValue && sideGameScores[sideIndex] !== undefined && sideGameScores[sideIndex] || isTiebreakValue && sideTiebreakScores[sideIndex] !== undefined && sideTiebreakScores[sideIndex]);
+  const hasExistingValue = !!existingValue;
+  const completedSetsHaveValidOutcomes = completedSets && completedSets.map(setObject => analyzeSet({
+    setObject,
+    matchUpScoringFormat
+  }).isValidSetOutcome).reduce((valid, validOutcome) => valid && validOutcome, true);
+  const setsWinCounts = completedSets.reduce((counts, set) => {
+    const {
+      winningSide
+    } = set;
+    const winningSideIndex = winningSide - 1;
+    counts[winningSideIndex]++;
+    return counts;
+  }, [0, 0]);
+  const matchUpWinningSide = matchUp === null || matchUp === void 0 ? void 0 : matchUp.winningSide;
+  const matchUpWinningSideIndex = matchUpWinningSide && matchUpWinningSide - 1;
+  const matchUpLosingSideIndex = 1 - matchUpWinningSideIndex;
+  const winningSideSetsCount = setsWinCounts[matchUpWinningSideIndex];
+  const losingSideSetsCount = setsWinCounts[matchUpLosingSideIndex];
+  const maxSetsCount = Math.max(...setsWinCounts);
+  const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
+  const {
+    bestOf
+  } = matchUpScoringFormat || {};
+  const setsToWin = bestOf && Math.ceil(bestOf / 2) || 1;
+  const calculatedWinningSide = maxSetsCount === setsToWin && maxSetsInstances === 1 && setsWinCounts.indexOf(maxSetsCount) + 1 || undefined;
+  const validMatchUpWinningSide = winningSideSetsCount > losingSideSetsCount && matchUpWinningSide === calculatedWinningSide;
+  const validMatchUpOutcome = calculatedWinningSide && completedSetsHaveValidOutcomes && validMatchUpWinningSide;
+  return {
+    isActiveSet,
+    isExistingSet,
+    existingValue,
+    hasExistingValue,
+    isValidSideNumber,
+    completedSetsCount,
+    isCompletedMatchUp,
+    isLastSetWithValues,
+    validMatchUpOutcome,
+    matchUpScoringFormat,
+    calculatedWinningSide,
+    validMatchUpWinningSide,
+    completedSetsHaveValidOutcomes,
+    ...specifiedSetAnalysis
   };
 }
 
@@ -5889,6 +5897,7 @@ const scoreGovernor = {
   tallyParticipantResults,
   getTiebreakComplement,
   generateScoreString,
+  checkSetIsComplete: checkSetIsComplete$1,
   validateTieFormat,
   getSetComplement,
   analyzeMatchUp,
@@ -13430,7 +13439,8 @@ function findMatchUp({
     contextProfile,
     nextMatchUps,
     matchUpId,
-    inContext
+    inContext,
+    event
   });
   return {
     matchUp,
@@ -13586,6 +13596,7 @@ function getProjectedDualWinningSide({
   winningSide,
   dualMatchUp,
   tieFormat,
+  structure,
   matchUp,
   event
 }) {
@@ -13610,7 +13621,7 @@ function getProjectedDualWinningSide({
     }
   }
 
-  tieFormat = tieFormat || (matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
+  tieFormat = tieFormat || (matchUp === null || matchUp === void 0 ? void 0 : matchUp.tieFormat) || (structure === null || structure === void 0 ? void 0 : structure.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
   const {
     winningSide: projectedWinningSide
   } = generateTieMatchUpScore({
@@ -15660,18 +15671,6 @@ function updateAssignmentParticipantResults({
   };
 }
 
-const toBePlayed = {
-  matchUpStatus: TO_BE_PLAYED,
-  matchUpStatusCodes: [],
-  score: {
-    scoreStringSide1: '',
-    scoreStringSide2: '',
-    sets: undefined
-  },
-  matchUpFormat: undefined,
-  winningSide: undefined
-};
-
 /**
  *
  * @param {string} eventId - indicates that invocation is via tournamentEngine
@@ -15717,6 +15716,18 @@ function getFlightProfile({
   };
 }
 
+const toBePlayed = {
+  matchUpStatus: TO_BE_PLAYED,
+  matchUpStatusCodes: [],
+  score: {
+    scoreStringSide1: '',
+    scoreStringSide2: '',
+    sets: undefined
+  },
+  matchUpFormat: undefined,
+  winningSide: undefined
+};
+
 /**
  *
  * Single place where matchUp.score can be modified.
@@ -15787,9 +15798,10 @@ function modifyMatchUpScore({
       matchUpId,
       event
     }));
-  }
+  } // if the matchUp has a collectionId it is a tieMatchUp contained in a dual matchUp
+
 
-  if (((_structure = structure) === null || _structure === void 0 ? void 0 : _structure.structureType) === CONTAINER) {
+  if (((_structure = structure) === null || _structure === void 0 ? void 0 : _structure.structureType) === CONTAINER && !matchUp.collectionId) {
     var _structure2;
 
     matchUpFormat = matchUpFormat || matchUp.matchUpFormat || ((_structure2 = structure) === null || _structure2 === void 0 ? void 0 : _structure2.matchUpFormat) || drawDefinition.matchUpFormat || (event === null || event === void 0 ? void 0 : event.matchUpFormat);
@@ -15847,8 +15859,9 @@ function modifyMatchUpScore({
 
 function updateTieMatchUpScore({
   drawDefinition,
-  event,
-  matchUpId
+  matchUpId,
+  structure,
+  event
 }) {
   if (!drawDefinition) return {
     error: MISSING_DRAW_DEFINITION
@@ -15856,7 +15869,6 @@ function updateTieMatchUpScore({
   if (!matchUpId) return {
     error: MISSING_MATCHUP
   };
-  if (!event) console.log('noe');
   const {
     matchUp,
     error
@@ -15871,7 +15883,7 @@ function updateTieMatchUpScore({
   if (!matchUp) return {
     error: MATCHUP_NOT_FOUND
   };
-  const tieFormat = matchUp.tieFormat || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
+  const tieFormat = matchUp.tieFormat || (structure === null || structure === void 0 ? void 0 : structure.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
   const {
     winningSide,
     set,
@@ -15970,6 +15982,7 @@ function removeDirectedParticipants(params) {
     } = updateTieMatchUpScore({
       matchUpId: matchUpTieId,
       drawDefinition,
+      structure,
       event
     });
     if (!dualWinningSideChange && !removeWinningSide) return { ...SUCCESS
@@ -18720,6 +18733,7 @@ function directParticipants(params) {
     updateTieMatchUpScore({
       matchUpId: matchUpTieId,
       drawDefinition,
+      structure,
       event
     });
     const matchUpTie = inContextDrawMatchUps.find(({
@@ -19062,13 +19076,16 @@ function scoreModification(params) {
   if (isCollectionMatchUp) {
     const {
       matchUpTieId,
-      drawDefinition
+      drawDefinition,
+      structure,
+      event
     } = params;
     const {
       removeWinningSide
     } = updateTieMatchUpScore({
       matchUpId: matchUpTieId,
       drawDefinition,
+      structure,
       event
     });
     console.log('ndd', {
@@ -19326,6 +19343,22 @@ function setMatchUpStatus$2(params) {
     inContextDrawMatchUps,
     drawDefinition
   });
+  const structureId = inContextMatchUp.structureId;
+  const {
+    structure
+  } = findStructure({
+    drawDefinition,
+    structureId
+  });
+  Object.assign(params, {
+    inContextDrawMatchUps,
+    inContextMatchUp,
+    matchUpTieId,
+    matchUpsMap,
+    targetData,
+    structure,
+    matchUp
+  });
   let dualWinningSideChange;
 
   if (matchUpTieId) {
@@ -19345,6 +19378,7 @@ function setMatchUpStatus$2(params) {
       winningSide,
       dualMatchUp,
       tieFormat,
+      structure,
       matchUp,
       event
     });
@@ -19358,24 +19392,8 @@ function setMatchUpStatus$2(params) {
       dualMatchUp,
       tieFormat
     });
-  }
+  } // with propagating winningSide changes, activeDownstream only applies to eventType: TEAM
 
-  const structureId = inContextMatchUp.structureId;
-  const {
-    structure
-  } = findStructure({
-    drawDefinition,
-    structureId
-  });
-  Object.assign(params, {
-    inContextDrawMatchUps,
-    inContextMatchUp,
-    matchUpTieId,
-    matchUpsMap,
-    targetData,
-    structure,
-    matchUp
-  }); // with propagating winningSide changes, activeDownstream only applies to eventType: TEAM
 
   const activeDownstream = isActiveDownstream(params);
   const directingMatchUpStatus = isDirectingMatchUpStatus({
@@ -19471,13 +19489,15 @@ function applyMatchUpValues(params) {
   if (params.isCollectionMatchUp) {
     const {
       matchUpTieId,
-      drawDefinition
+      drawDefinition,
+      structure
     } = params;
     const {
       removeWinningSide
     } = updateTieMatchUpScore({
       matchUpId: matchUpTieId,
       drawDefinition,
+      structure,
       event
     });
     console.log('sms', {
@@ -23638,11 +23658,11 @@ function modifyMatchUpFormatTiming({
 
 function getMatchUpFormat({
   tournamentRecord,
-  drawId,
   drawDefinition,
-  event,
   structureId,
-  matchUpId
+  matchUpId,
+  drawId,
+  event
 }) {
   var _structure, _drawDefinition, _matchUpResult$matchU;
 
@@ -23655,8 +23675,9 @@ function getMatchUpFormat({
   const matchUpResult = findMatchUp({
     tournamentRecord,
     drawDefinition,
+    matchUpId,
     drawId,
-    matchUpId
+    event
   });
 
   if (matchUpId && matchUpResult !== null && matchUpResult !== void 0 && matchUpResult.error) {
@@ -27372,7 +27393,7 @@ const scheduleGovernor$1 = {
 };
 
 function factoryVersion() {
-  return '0.48.1';
+  return '0.48.2';
 }
 
 function attachPolicies$2({
@@ -33754,6 +33775,7 @@ function getUnseededByePositions({
 
 function getByesData({
   drawDefinition,
+  event,
   matchUpsMap,
   structure
 }) {
@@ -33769,7 +33791,8 @@ function getByesData({
     drawDefinition,
     matchUpFilters,
     matchUpsMap,
-    structure
+    structure,
+    event
   });
   const firstRoundMatchUps = roundMatchUps && roundMatchUps[1] || []; // firstRoundMatchUps don't work for CONTAINER / ROUND_ROBIN structures
 
@@ -33830,10 +33853,11 @@ function getByesData({
 function positionByes({
   blockOrdered = false,
   drawDefinition,
+  matchUpsMap,
   structureId,
   structure,
   seedsOnly,
-  matchUpsMap
+  event
 }) {
   if (!structure) ({
     structure
@@ -33850,8 +33874,9 @@ function positionByes({
     relevantMatchUps
   } = getByesData({
     drawDefinition,
+    matchUpsMap,
     structure,
-    matchUpsMap
+    event
   });
   const byesToPlace = byesCount - placedByes;
   if (byesToPlace <= 0) return SUCCESS;
@@ -34086,13 +34111,14 @@ function positionSeedBlock({
 }
 
 function automatedPositioning$1({
+  inContextDrawMatchUps,
   drawDefinition,
   candidatesCount,
   participants,
   structureId,
+  matchUpsMap,
   seedsOnly,
-  inContextDrawMatchUps,
-  matchUpsMap
+  event
 }) {
   const {
     structure,
@@ -34136,9 +34162,10 @@ function automatedPositioning$1({
     // BYEs must be placed first to ensure lower seeds get BYEs
     let result = positionByes({
       drawDefinition,
+      matchUpsMap,
       structure,
       seedsOnly,
-      matchUpsMap
+      event
     });
     if (result.error) return result;
     result = positionSeedBlocks({
@@ -34161,11 +34188,12 @@ function automatedPositioning$1({
     });
     if (result.error) return result;
     result = positionByes({
+      inContextDrawMatchUps,
       drawDefinition,
+      matchUpsMap,
       structure,
       seedsOnly,
-      matchUpsMap,
-      inContextDrawMatchUps
+      event
     });
     if (result.error) return result;
   }
@@ -37075,9 +37103,8 @@ function generateDrawType(params = {}) {
       });
       Object.assign(matchUp, {
         tieMatchUps,
-        tieFormat,
         matchUpType
-      }); // Object.assign(matchUp, { tieMatchUps, matchUpType });
+      });
     });
   }
 
@@ -39405,9 +39432,8 @@ function addPlayoffStructures$1(params) {
         });
         Object.assign(matchUp, {
           tieMatchUps,
-          tieFormat,
           matchUpType: TEAM$3
-        }); // Object.assign(matchUp, { tieMatchUps, matchUpType: TEAM });
+        });
       });
     }
   } // now advance any players from completed matchUps into the newly added structures
@@ -40152,11 +40178,11 @@ function generateVoluntaryConsolationStructure$1({
 
   if (automated) {
     automatedPositioning$1({
+      structureId: structureId || structure.structureId,
+      // either passed in or generated in template
       drawDefinition,
       participants,
-      event,
-      structureId: structureId || structure.structureId // either passed in or generated in template
-
+      event
     });
   }