tods-competition-factory 2.2.41 → 2.2.43

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.41';
+    return '2.2.43';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -1982,13 +1982,15 @@ const setTypes$1 = {
 };
 
 function stringify(matchUpFormatObject, preserveRedundant) {
+    if (!isObject(matchUpFormatObject))
+        return undefined;
     if ((matchUpFormatObject?.bestOf || matchUpFormatObject?.exactly) && matchUpFormatObject?.setFormat) {
         return getSetFormat(matchUpFormatObject, preserveRedundant);
     }
     return undefined;
 }
 function getNumber$1(formatstring) {
-    return !isNaN(Number(formatstring)) && Number(formatstring);
+    return !Number.isNaN(Number(formatstring)) && Number(formatstring);
 }
 function timedSetFormat(matchUpFormatObject) {
     let value = `T${matchUpFormatObject.minutes}`;
@@ -2025,7 +2027,7 @@ function getSetFormat(matchUpFormatObject, preserveRedundant) {
         '';
     const valid = setLimitCode && setCountValue;
     if (valid) {
-        return [setLimitCode, setCode, finalSetCode].filter((f) => f).join('-');
+        return [setLimitCode, setCode, finalSetCode].filter(Boolean).join('-');
     }
     return undefined;
 }
@@ -10343,7 +10345,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
     const sourceDrawPositionRoundRanges = sourceDrawPositionRanges?.[roundNumber];
     const matchUpCategory = collectionDefinition?.category
         ? {
-            ...(context?.category || {}),
+            ...context?.category,
             ...collectionDefinition.category,
         }
         : (context?.category ?? event?.category);
@@ -10361,7 +10363,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
         ...onlyDefined(context),
         ...onlyDefined({
             matchUpFormat: matchUpType === TEAM$1 ? undefined : matchUpFormat,
-            tieFormat: matchUpType !== TEAM$1 ? undefined : tieFormat,
+            tieFormat: matchUpType === TEAM$1 ? tieFormat : undefined,
             gender: collectionDefinition?.gender ?? event?.gender,
             endDate: matchUp.endDate ?? endDate,
             discipline: event?.discipline,
@@ -10402,16 +10404,19 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                 .sort((a, b) => a.setNumber - b.setNumber)
                 .map((set, i) => {
                 const setNumber = i + 1;
-                if (setNumber === bestOf) {
-                    if (finalSetFormat?.tiebreakSet || finalSetFormat?.timed)
-                        set.tiebreakSet = true;
-                }
-                else if (setFormat?.tiebreakSet || setFormat?.timed) {
+                const isDecidingSet = setNumber === bestOf;
+                const currentSetFormat = isDecidingSet && finalSetFormat ? finalSetFormat : setFormat;
+                const isTiebreakOnly = currentSetFormat?.tiebreakSet && !currentSetFormat?.timed;
+                const isTimed = currentSetFormat?.timed;
+                if (isTiebreakOnly) {
                     set.tiebreakSet = true;
+                    if ([1, 2].includes(set.winningSide)) {
+                        set.side1Score = set.winningSide === 1 ? 1 : 0;
+                        set.side2Score = set.winningSide === 2 ? 1 : 0;
+                    }
                 }
-                if (set.tiebreakSet && [1, 2].includes(set.winningSide)) {
-                    set.side1Score = set.winningSide === 1 ? 1 : 0;
-                    set.side2Score = set.winningSide === 2 ? 1 : 0;
+                else if (isTimed) {
+                    set.timed = true;
                 }
                 return set;
             });
@@ -21620,7 +21625,7 @@ function processPlayoffGroups({ requireSequential = true, playoffMatchUpFormat,
     }
     for (const playoffGroup of playoffGroups) {
         const finishingPositions = playoffGroup.finishingPositions;
-        const positionsPlayedOff = positionRangeMap && finishingPositions.map((p) => positionRangeMap[p]?.finishingPositions).flat();
+        const positionsPlayedOff = positionRangeMap && finishingPositions.flatMap((p) => positionRangeMap[p]?.finishingPositions ?? []);
         const participantsInDraw = groupCount * finishingPositions.length;
         const drawSize = nextPowerOf2(participantsInDraw);
         const playoffDrawType = (drawSize === 2 && SINGLE_ELIMINATION) || playoffGroup.drawType || SINGLE_ELIMINATION;
@@ -32184,7 +32189,7 @@ var help = {
     tidyScore: tidyScore
 };
 
-function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete) {
+function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete, NoAD = false) {
     if (allowIncomplete) {
         return { isValid: true };
     }
@@ -32197,12 +32202,18 @@ function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSet
             error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
         };
     }
-    if (scoreDiff < 2) {
+    const requiredWinBy = NoAD ? 1 : 2;
+    if (scoreDiff < requiredWinBy) {
         return {
             isValid: false,
-            error: `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
+            error: NoAD
+                ? `Tiebreak-only set (NoAD) must be won by at least 1 point, got ${winnerScore}-${loserScore}`
+                : `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
         };
     }
+    if (NoAD) {
+        return { isValid: true };
+    }
     if (winnerScore === tiebreakSetTo && loserScore > tiebreakSetTo - 2) {
         return {
             isValid: false,
@@ -32393,7 +32404,8 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const loserScore = Math.min(side1Score, side2Score);
     const scoreDiff = winnerScore - loserScore;
     if (isTiebreakOnlyFormat) {
-        return validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete ?? false);
+        const NoAD = setFormat.tiebreakSet?.NoAD ?? false;
+        return validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete ?? false, NoAD);
     }
     const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
     const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
@@ -32427,6 +32439,62 @@ function validateMatchUpScore(sets, matchUpFormat, matchUpStatus) {
     return { isValid: true };
 }
 
+function validateTiebreak(tiebreakFormat, side1TiebreakScore, side2TiebreakScore, setWinningSide, isLastSet, irregularEnding) {
+    const { tiebreakTo, NoAD } = tiebreakFormat || {};
+    const maxTiebreakScore = Math.max(side1TiebreakScore ?? 0, side2TiebreakScore ?? 0);
+    if (NoAD && maxTiebreakScore > tiebreakTo)
+        return false;
+    if (maxTiebreakScore < tiebreakTo && setWinningSide) {
+        if (isLastSet && !irregularEnding)
+            return false;
+        if (!isLastSet)
+            return false;
+    }
+    return true;
+}
+function validateSet(set, i, matchUpScoringFormat, totalSets, isLastSet, irregularEnding) {
+    const setNumber = i + 1;
+    const isFinalSet = setNumber === totalSets;
+    const { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore, winningSide: setWinningSide } = set;
+    const maxSetScore = Math.max(side1Score ?? 0, side2Score ?? 0);
+    const hasTiebreak = side1TiebreakScore ?? side2TiebreakScore;
+    const { finalSetFormat, setFormat } = matchUpScoringFormat;
+    const setValues = isFinalSet ? finalSetFormat || setFormat : setFormat;
+    if (hasTiebreak) {
+        const isValidTiebreak = validateTiebreak(setValues?.tiebreakFormat, side1TiebreakScore, side2TiebreakScore, setWinningSide, isLastSet, irregularEnding);
+        if (!isValidTiebreak)
+            return false;
+    }
+    if (!setValues.setTo)
+        return true;
+    const excessiveSetScore = !setValues.noTiebreak && maxSetScore > setValues.setTo + 1;
+    return !excessiveSetScore;
+}
+function calculateAggregateWinner(sets) {
+    const aggregateTotals = sets.reduce((totals, set) => {
+        if (set.side1Score !== undefined || set.side2Score !== undefined) {
+            totals[0] += set.side1Score ?? 0;
+            totals[1] += set.side2Score ?? 0;
+        }
+        return totals;
+    }, [0, 0]);
+    if (aggregateTotals[0] > aggregateTotals[1]) {
+        return 1;
+    }
+    else if (aggregateTotals[1] > aggregateTotals[0]) {
+        return 2;
+    }
+    else {
+        const tiebreakSet = sets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+        return tiebreakSet?.winningSide;
+    }
+}
+function calculateStandardWinner(maxSetsCount, setsToWin, maxSetsInstances, setsWinCounts, matchUpFormat) {
+    return (((!matchUpFormat || maxSetsCount === setsToWin) &&
+        maxSetsInstances === 1 &&
+        setsWinCounts.indexOf(maxSetsCount) + 1) ||
+        undefined);
+}
 function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }) {
     const sets = score?.sets ?? [];
     const completedSets = sets?.filter((set) => set?.winningSide) || [];
@@ -32448,71 +32516,23 @@ function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, win
     const maxSetsCount = Math.max(...setsWinCounts);
     const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
     const timed = matchUpScoringFormat?.setFormat?.timed || matchUpScoringFormat?.finalSetFormat?.timed;
-    const bestOf = matchUpScoringFormat?.bestOf;
-    const setsToWin = (bestOf && Math.ceil(bestOf / 2)) || 1;
+    const totalSets = matchUpScoringFormat?.bestOf || matchUpScoringFormat?.exactly;
+    const setsToWin = (totalSets && Math.ceil(totalSets / 2)) || 1;
     const relevantMatchUpStatus = matchUpStatus ?? existingMatchUpStatus;
-    const irregularEnding = relevantMatchUpStatus && [DEFAULTED, RETIRED$1, WALKOVER$2].includes(relevantMatchUpStatus);
+    const irregularEnding = !!(relevantMatchUpStatus && [DEFAULTED, RETIRED$1, WALKOVER$2].includes(relevantMatchUpStatus));
     const validSets = !matchUpScoringFormat ||
         !sets.length ||
-        sets.every((set, i) => {
-            const setNumber = i + 1;
-            const isFinalSet = setNumber === bestOf;
-            const isLastSet = setNumber === sets.length;
-            const { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore, winningSide: setWinningSide } = set;
-            const maxSetScore = Math.max(side1Score ?? 0, side2Score ?? 0);
-            const hasTiebreak = side1TiebreakScore ?? side2TiebreakScore;
-            const { finalSetFormat, setFormat } = matchUpScoringFormat;
-            const setValues = isFinalSet ? finalSetFormat || setFormat : setFormat;
-            if (hasTiebreak) {
-                const { tiebreakTo, NoAD } = setValues?.tiebreakFormat || {};
-                const maxTiebreakScore = Math.max(side1TiebreakScore ?? 0, side2TiebreakScore ?? 0);
-                if (NoAD && maxTiebreakScore > tiebreakTo)
-                    return false;
-                if (maxTiebreakScore < tiebreakTo && setWinningSide) {
-                    if (isLastSet && !irregularEnding)
-                        return false;
-                    if (!isLastSet)
-                        return false;
-                }
-            }
-            if (!setValues.setTo)
-                return true;
-            const excessiveSetScore = !setValues.noTiebreak && maxSetScore > setValues.setTo + 1;
-            return !excessiveSetScore;
-        });
+        sets.every((set, i) => validateSet(set, i, matchUpScoringFormat, totalSets ?? 0, i === sets.length - 1, irregularEnding));
     const isAggregateScoring = matchUpScoringFormat?.setFormat?.based === 'A' || matchUpScoringFormat?.finalSetFormat?.based === 'A';
-    let calculatedWinningSide;
-    if (isAggregateScoring && sets.length > 0) {
-        const aggregateTotals = sets.reduce((totals, set) => {
-            if (set.side1Score !== undefined || set.side2Score !== undefined) {
-                totals[0] += set.side1Score ?? 0;
-                totals[1] += set.side2Score ?? 0;
-            }
-            return totals;
-        }, [0, 0]);
-        if (aggregateTotals[0] > aggregateTotals[1]) {
-            calculatedWinningSide = 1;
-        }
-        else if (aggregateTotals[1] > aggregateTotals[0]) {
-            calculatedWinningSide = 2;
-        }
-        else {
-            const tiebreakSet = sets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
-            if (tiebreakSet) {
-                calculatedWinningSide = tiebreakSet.winningSide;
-            }
-        }
-    }
-    else {
-        calculatedWinningSide =
-            ((!matchUpFormat || maxSetsCount === setsToWin) &&
-                maxSetsInstances === 1 &&
-                setsWinCounts.indexOf(maxSetsCount) + 1) ||
-                undefined;
-    }
+    const calculatedWinningSide = isAggregateScoring && sets.length > 0
+        ? calculateAggregateWinner(sets)
+        : calculateStandardWinner(maxSetsCount, setsToWin, maxSetsInstances, setsWinCounts, matchUpFormat);
     const valid = !!(validSets &&
         ((winningSide && isAggregateScoring && winningSide === calculatedWinningSide) ||
-            (winningSide && !isAggregateScoring && winningSideSetsCount > losingSideSetsCount && winningSide === calculatedWinningSide) ||
+            (winningSide &&
+                !isAggregateScoring &&
+                winningSideSetsCount > losingSideSetsCount &&
+                winningSide === calculatedWinningSide) ||
             (winningSide && irregularEnding) ||
             (!winningSide &&
                 !calculatedWinningSide &&
@@ -32631,94 +32651,115 @@ function getHighTiebreakValue(params) {
     return tiebreakTo;
 }
 
+function determineWinningSide(score1, score2) {
+    return (score1 > score2 && 1) || (score1 < score2 && 2) || undefined;
+}
+function parseTiebreakOnlySet(bracketedScores, isTiebreakOnlyFormat) {
+    if (isTiebreakOnlyFormat) {
+        return {
+            side1Score: bracketedScores[0],
+            side2Score: bracketedScores[1],
+            winningSide: determineWinningSide(bracketedScores[0], bracketedScores[1]),
+        };
+    }
+    return {
+        side1TiebreakScore: bracketedScores[0],
+        side2TiebreakScore: bracketedScores[1],
+        winningSide: determineWinningSide(bracketedScores[0], bracketedScores[1]),
+    };
+}
 function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
     let parsedFormat;
     let bestOfSets = 3;
     if (matchUpFormat) {
         try {
             parsedFormat = parse(matchUpFormat);
-            const bestOfMatch = matchUpFormat?.match(/SET(\d+)/)?.[1];
+            const bestOfMatch = /SET(\d+)/.exec(matchUpFormat)?.[1];
             bestOfSets = bestOfMatch ? Number.parseInt(bestOfMatch) : 3;
         }
-        catch (_e) {
+        catch {
         }
     }
     return scoreString
         ?.split(' ')
         .filter(Boolean)
         .map((set, index) => parseSet({ set, setNumber: index + 1 }));
+    function checkIsTiebreakOnlyFormat(setNumber, isTiebreakOnlySet) {
+        if (!parsedFormat || !isTiebreakOnlySet)
+            return false;
+        const isDecidingSet = setNumber === bestOfSets;
+        const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
+        if (!setFormat)
+            return false;
+        const tiebreakSetTo = setFormat.tiebreakSet?.tiebreakTo;
+        const regularSetTo = setFormat.setTo;
+        return !!tiebreakSetTo && !regularSetTo;
+    }
+    function getTiebreakToForSet(setNumber) {
+        if (!parsedFormat)
+            return tiebreakTo;
+        const isDecidingSet = setNumber === bestOfSets;
+        const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
+        return setFormat?.tiebreakFormat?.tiebreakTo ?? tiebreakTo;
+    }
+    function parseTiebreakGame(tiebreakMatch, winningSide, setNumber) {
+        const setTiebreakLowScore = tiebreakMatch[1];
+        const setSpecificTiebreakTo = getTiebreakToForSet(setNumber);
+        const side1TiebreakPerspective = getTiebreakComplement({
+            lowValue: setTiebreakLowScore,
+            isSide1: winningSide === 2,
+            tiebreakTo: setSpecificTiebreakTo,
+        });
+        if (Array.isArray(side1TiebreakPerspective)) {
+            return [side1TiebreakPerspective[0], side1TiebreakPerspective[1]];
+        }
+        return [undefined, undefined];
+    }
+    function parseRegularSet(set, tiebreak, bracketed, setNumber) {
+        const setString = (tiebreak && set.replace(tiebreak[0], '')) || (bracketed && set.replace(bracketed[0], '')) || set;
+        const setScores = setString.split('-').map((score) => Number.parseInt(score));
+        const side1Score = setScores[0];
+        const side2Score = setScores[1];
+        const winningSide = determineWinningSide(side1Score, side2Score);
+        let side1TiebreakScore;
+        let side2TiebreakScore;
+        if (tiebreak) {
+            [side1TiebreakScore, side2TiebreakScore] = parseTiebreakGame(tiebreak, winningSide, setNumber);
+        }
+        if (bracketed) {
+            const matchTiebreakScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
+            side1TiebreakScore = matchTiebreakScores[0];
+            side2TiebreakScore = matchTiebreakScores[1];
+        }
+        return {
+            side1Score,
+            side2Score,
+            side1TiebreakScore,
+            side2TiebreakScore,
+            winningSide,
+        };
+    }
     function parseSet({ set, setNumber }) {
         const inParentheses = /\(([^)]+)\)/;
         const inBrackets = /\[([^\]]+)\]/;
         const tiebreak = inParentheses.exec(set);
         const bracketed = inBrackets.exec(set);
         const isTiebreakOnlySet = set?.startsWith('[') && bracketed;
-        let isTiebreakOnlyFormat = false;
-        if (parsedFormat && isTiebreakOnlySet) {
-            const isDecidingSet = setNumber === bestOfSets;
-            const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
-            if (setFormat) {
-                const tiebreakSetTo = setFormat.tiebreakSet?.tiebreakTo;
-                const regularSetTo = setFormat.setTo;
-                isTiebreakOnlyFormat = !!tiebreakSetTo && !regularSetTo;
-            }
-        }
-        let side1Score;
-        let side2Score;
-        let side1TiebreakScore;
-        let side2TiebreakScore;
-        let winningSide;
+        const isTiebreakOnlyFormat = checkIsTiebreakOnlyFormat(setNumber, !!isTiebreakOnlySet);
+        let result;
         if (isTiebreakOnlySet) {
-            const bracketedScores = bracketed[1].split('-').map((score) => parseInt(score));
-            if (isTiebreakOnlyFormat) {
-                side1Score = bracketedScores[0];
-                side2Score = bracketedScores[1];
-                winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
-            }
-            else {
-                side1TiebreakScore = bracketedScores[0];
-                side2TiebreakScore = bracketedScores[1];
-                winningSide =
-                    (side1TiebreakScore > side2TiebreakScore && 1) || (side1TiebreakScore < side2TiebreakScore && 2) || undefined;
-            }
+            const bracketedScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
+            result = parseTiebreakOnlySet(bracketedScores, isTiebreakOnlyFormat);
         }
         else {
-            const setString = (tiebreak && set.replace(tiebreak[0], '')) || (bracketed && set.replace(bracketed[0], '')) || set;
-            const setScores = setString.split('-').map((score) => Number.parseInt(score));
-            side1Score = setScores[0];
-            side2Score = setScores[1];
-            winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
-            if (tiebreak) {
-                const setTiebreakLowScore = tiebreak[1];
-                let setSpecificTiebreakTo = tiebreakTo;
-                if (parsedFormat) {
-                    const isDecidingSet = setNumber === bestOfSets;
-                    const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
-                    if (setFormat?.tiebreakFormat?.tiebreakTo) {
-                        setSpecificTiebreakTo = setFormat.tiebreakFormat.tiebreakTo;
-                    }
-                }
-                const side1TiebreakPerspective = getTiebreakComplement({
-                    lowValue: setTiebreakLowScore,
-                    isSide1: winningSide === 2,
-                    tiebreakTo: setSpecificTiebreakTo,
-                });
-                if (Array.isArray(side1TiebreakPerspective)) {
-                    [side1TiebreakScore, side2TiebreakScore] = side1TiebreakPerspective;
-                }
-            }
-            if (bracketed && !isTiebreakOnlySet) {
-                const matchTiebreakScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
-                side1TiebreakScore = matchTiebreakScores[0];
-                side2TiebreakScore = matchTiebreakScores[1];
-            }
+            result = parseRegularSet(set, tiebreak, bracketed, setNumber);
         }
         return {
-            side1Score,
-            side2Score,
-            side1TiebreakScore,
-            side2TiebreakScore,
-            winningSide,
+            side1Score: result.side1Score,
+            side2Score: result.side2Score,
+            side1TiebreakScore: result.side1TiebreakScore,
+            side2TiebreakScore: result.side2TiebreakScore,
+            winningSide: result.winningSide,
             setNumber,
         };
     }
@@ -47239,6 +47280,67 @@ var index$9 = {
     validMatchUps: validMatchUps
 };
 
+function inferWinningSideFromAggregate(neutralParsedSets) {
+    const aggregateTotals = neutralParsedSets.reduce((totals, set) => {
+        if (set.side1Score !== undefined || set.side2Score !== undefined) {
+            totals.side1 += set.side1Score ?? 0;
+            totals.side2 += set.side2Score ?? 0;
+        }
+        return totals;
+    }, { side1: 0, side2: 0 });
+    if (aggregateTotals.side1 > aggregateTotals.side2)
+        return 1;
+    if (aggregateTotals.side2 > aggregateTotals.side1)
+        return 2;
+    const tiebreakSet = neutralParsedSets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+    return tiebreakSet?.winningSide;
+}
+function inferWinningSideFromSets(neutralParsedSets) {
+    const setsWon = { side1: 0, side2: 0 };
+    neutralParsedSets.forEach((set) => {
+        if (set.winningSide === 1)
+            setsWon.side1++;
+        else if (set.winningSide === 2)
+            setsWon.side2++;
+    });
+    if (setsWon.side1 > setsWon.side2)
+        return 1;
+    if (setsWon.side2 > setsWon.side1)
+        return 2;
+    return undefined;
+}
+function inferWinningSide(winningSide, matchUpFormat, neutralParsedSets) {
+    if (winningSide || !matchUpFormat || !neutralParsedSets)
+        return winningSide;
+    const parsedFormat = parse(matchUpFormat);
+    const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
+    return isAggregateScoring
+        ? inferWinningSideFromAggregate(neutralParsedSets)
+        : inferWinningSideFromSets(neutralParsedSets);
+}
+function generateScoreForSideOrder(scoreString, matchUpFormat, setTBlast) {
+    const sets = parseScoreString({ scoreString, matchUpFormat });
+    return {
+        sets,
+        scoreStringSide1: generateScoreString({ sets, matchUpFormat, setTBlast }),
+        scoreStringSide2: generateScoreString({ sets, reversed: true, matchUpFormat, setTBlast }),
+    };
+}
+function generateScoreForWinnerOrder(neutralParsedSets, inferredWinningSide, matchUpFormat, setTBlast) {
+    const winningScoreString = generateScoreString({ sets: neutralParsedSets, matchUpFormat, setTBlast });
+    const losingScoreString = generateScoreString({ sets: neutralParsedSets, reversed: true, matchUpFormat, setTBlast });
+    if (typeof winningScoreString !== 'string')
+        return winningScoreString;
+    if (typeof losingScoreString !== 'string')
+        return losingScoreString;
+    const scoreStringSide1 = inferredWinningSide === 2 ? losingScoreString : winningScoreString;
+    const scoreStringSide2 = inferredWinningSide === 2 ? winningScoreString : losingScoreString;
+    return {
+        sets: parseScoreString({ scoreString: scoreStringSide1, matchUpFormat }),
+        scoreStringSide1,
+        scoreStringSide2,
+    };
+}
 function generateOutcomeFromScoreString(params) {
     const { matchUpFormat, matchUpStatus, winningSide, scoreString, setTBlast } = params;
     if (!scoreString)
@@ -47253,81 +47355,12 @@ function generateOutcomeFromScoreString(params) {
         return { error: INVALID_VALUES, winningSide };
     const neutralParsedSets = scoreString && parseScoreString({ scoreString, matchUpFormat });
     const isBracketNotation = scoreString?.trim().startsWith('[');
-    let inferredWinningSide = winningSide;
-    if (!inferredWinningSide && matchUpFormat && neutralParsedSets) {
-        const parsedFormat = parse(matchUpFormat);
-        const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
-        if (isAggregateScoring) {
-            const aggregateTotals = neutralParsedSets.reduce((totals, set) => {
-                if (set.side1Score !== undefined || set.side2Score !== undefined) {
-                    totals.side1 += set.side1Score ?? 0;
-                    totals.side2 += set.side2Score ?? 0;
-                }
-                return totals;
-            }, { side1: 0, side2: 0 });
-            if (aggregateTotals.side1 > aggregateTotals.side2)
-                inferredWinningSide = 1;
-            else if (aggregateTotals.side2 > aggregateTotals.side1)
-                inferredWinningSide = 2;
-            else {
-                const tiebreakSet = neutralParsedSets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
-                if (tiebreakSet)
-                    inferredWinningSide = tiebreakSet.winningSide;
-            }
-        }
-        else {
-            const setsWon = { side1: 0, side2: 0 };
-            neutralParsedSets.forEach((set) => {
-                if (set.winningSide === 1)
-                    setsWon.side1++;
-                else if (set.winningSide === 2)
-                    setsWon.side2++;
-            });
-            if (setsWon.side1 > setsWon.side2)
-                inferredWinningSide = 1;
-            else if (setsWon.side2 > setsWon.side1)
-                inferredWinningSide = 2;
-        }
-    }
-    const score = {};
+    const inferredWinningSide = inferWinningSide(winningSide, matchUpFormat, neutralParsedSets);
     const parsedFormat = parse(matchUpFormat);
     const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
-    if (isBracketNotation || isAggregateScoring) {
-        score.sets = parseScoreString({ scoreString, matchUpFormat });
-        score.scoreStringSide1 = generateScoreString({
-            sets: score.sets,
-            matchUpFormat,
-            setTBlast,
-        });
-        score.scoreStringSide2 = generateScoreString({
-            sets: score.sets,
-            reversed: true,
-            matchUpFormat,
-            setTBlast,
-        });
-    }
-    else {
-        const winningScoreString = generateScoreString({
-            sets: neutralParsedSets,
-            matchUpFormat,
-            setTBlast,
-        });
-        const losingScoreString = generateScoreString({
-            sets: neutralParsedSets,
-            reversed: true,
-            matchUpFormat,
-            setTBlast,
-        });
-        if (inferredWinningSide === 2) {
-            score.scoreStringSide1 = losingScoreString;
-            score.scoreStringSide2 = winningScoreString;
-        }
-        else {
-            score.scoreStringSide1 = winningScoreString;
-            score.scoreStringSide2 = losingScoreString;
-        }
-        score.sets = parseScoreString({ scoreString: score.scoreStringSide1, matchUpFormat });
-    }
+    const score = isBracketNotation || isAggregateScoring
+        ? generateScoreForSideOrder(scoreString, matchUpFormat, setTBlast)
+        : generateScoreForWinnerOrder(neutralParsedSets, inferredWinningSide, matchUpFormat, setTBlast);
     return definedAttributes({
         outcome: {
             matchUpStatus,
@@ -59583,7 +59616,7 @@ async function asyncExecutionQueue(engine, directives, rollbackOnError) {
         if (!methods[methodName])
             return logMethodNotFound({ methodName, start, params });
         if (pipe) {
-            const lastResult = results[results.length - 1];
+            const lastResult = results.at(-1);
             const pipeKeys = Object.keys(pipe);
             for (const pipeKey of pipeKeys) {
                 if (lastResult[pipeKey])
@@ -59765,7 +59798,7 @@ function executionQueue(engine, directives, rollbackOnError) {
         if (!methods[methodName])
             return logMethodNotFound({ methodName, start, params });
         if (pipe) {
-            const lastResult = results[results.length - 1];
+            const lastResult = results.at(-1);
             const pipeKeys = Object.keys(pipe);
             for (const pipeKey of pipeKeys) {
                 if (lastResult[pipeKey])