tods-competition-factory 2.0.23 → 2.0.24

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

@@ -3,432 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.23';
-}
-
-const validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
-const validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
-const dateValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))([ T](0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
-const timeValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))?([ T]?(0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
-
-function getIsoDateString(schedule) {
-    let { scheduledDate } = schedule;
-    if (!scheduledDate && schedule.scheduledTime)
-        scheduledDate = extractDate(schedule.scheduledTime);
-    if (!scheduledDate)
-        return;
-    const extractedTime = extractTime(schedule.scheduledTime);
-    let isoDateString = extractDate(scheduledDate);
-    if (isoDateString && extractedTime)
-        isoDateString += `T${extractedTime}`;
-    return isoDateString;
-}
-function isDateObject(value) {
-    if (typeof value !== 'object' || Array.isArray(value)) {
-        return false;
-    }
-    else {
-        const datePrototype = Object.prototype.toString.call(value);
-        return datePrototype === '[object Date]';
-    }
-}
-function validTimeValue(value) {
-    const spaceSplit = typeof value === 'string' ? value?.split(' ') : [];
-    if (value && spaceSplit?.length > 1 && !['AM', 'PM'].includes(spaceSplit[1].toUpperCase()))
-        return false;
-    return !!(!value || timeValidation.test(convertTime(value, true, true)));
-}
-function isValidDateString(scheduleDate) {
-    return isISODateString(scheduleDate) || validDateString.test(scheduleDate);
-}
-function DateHHMM(date) {
-    const dt = new Date(date);
-    const secs = dt.getSeconds() + 60 * dt.getMinutes() + 60 * 60 * dt.getHours();
-    return HHMMSS(secs, { displaySeconds: false });
-}
-function HHMMSS(s, format) {
-    const secondNumber = parseInt(s, 10);
-    const hours = Math.floor(secondNumber / 3600);
-    const minutes = Math.floor((secondNumber - hours * 3600) / 60);
-    const seconds = secondNumber - hours * 3600 - minutes * 60;
-    const displaySeconds = !format || format?.displaySeconds;
-    const timeString = displaySeconds ? hours + ':' + minutes + ':' + seconds : hours + ':' + minutes;
-    return timeString.split(':').map(zeroPad).join(':');
-}
-const getUTCdateString = (date) => {
-    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
-    const monthNumber = dateDate.getUTCMonth() + 1;
-    const utcMonth = monthNumber < 10 ? `0${monthNumber}` : `${monthNumber}`;
-    return `${dateDate.getUTCFullYear()}-${zeroPad(utcMonth)}-${zeroPad(dateDate.getUTCDate())}`;
-};
-function timeUTC(date) {
-    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
-    return Date.UTC(dateDate.getFullYear(), dateDate.getMonth(), dateDate.getDate());
-}
-function formatDate(date, separator = '-', format = 'YMD') {
-    if (!date)
-        return '';
-    if (typeof date === 'string' && date.indexOf('T') < 0)
-        date = date + 'T00:00';
-    const d = new Date(date);
-    let month = '' + (d.getMonth() + 1);
-    let day = '' + d.getDate();
-    const year = d.getFullYear();
-    if (month.length < 2)
-        month = '0' + month;
-    if (day.length < 2)
-        day = '0' + day;
-    if (format === 'DMY')
-        return [day, month, year].join(separator);
-    if (format === 'MDY')
-        return [month, day, year].join(separator);
-    if (format === 'YDM')
-        return [year, day, month].join(separator);
-    if (format === 'DYM')
-        return [day, year, month].join(separator);
-    if (format === 'MYD')
-        return [month, year, day].join(separator);
-    return [year, month, day].join(separator);
-}
-function offsetDate(date) {
-    const targetTime = date ? new Date(date) : new Date();
-    const tzDifference = targetTime.getTimezoneOffset();
-    return new Date(targetTime.getTime() - tzDifference * 60 * 1000);
-}
-function offsetTime(date) {
-    return offsetDate(date).getTime();
-}
-function isDate(dateArg) {
-    if (typeof dateArg == 'boolean')
-        return false;
-    const t = (dateArg instanceof Date && dateArg) || (!isNaN(dateArg) && new Date(dateArg)) || false;
-    return t && !isNaN(t.valueOf());
-}
-function generateDateRange(startDt, endDt) {
-    if (!isValidDateString(startDt) || !isValidDateString(endDt))
-        return [];
-    const startDateString = extractDate(startDt) + 'T00:00';
-    const endDateString = extractDate(endDt) + 'T00:00';
-    const startDate = new Date(startDateString);
-    const endDate = new Date(endDateString);
-    const process = isDate(endDate) && isDate(startDate) && isValidDateRange(startDate, endDate);
-    const between = [];
-    let iterations = 0;
-    if (process) {
-        const currentDate = startDate;
-        let dateSecs = currentDate.getTime();
-        while (dateSecs <= endDate.getTime() && iterations < 300) {
-            iterations += 1;
-            between.push(new Date(currentDate));
-            dateSecs = currentDate.setDate(currentDate.getDate() + 1);
-        }
-    }
-    return between.map((date) => formatDate(date));
-    function isValidDateRange(minDate, maxDate) {
-        return minDate <= maxDate;
-    }
-}
-const re = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
-function isISODateString(dateString) {
-    if (typeof dateString !== 'string')
-        return false;
-    return re.test(dateString);
-}
-function isTimeString(timeString) {
-    if (typeof timeString !== 'string')
-        return false;
-    const noZ = timeString.split('Z')[0];
-    const parts = noZ.split(':');
-    const isNumeric = parts.every((part) => !isNaN(parseInt(part)));
-    const invalid = parts.length < 2 || !isNumeric || parseInt(parts[0]) > 23 || parseInt(parts[1]) > 60;
-    return !invalid;
-}
-function timeStringMinutes(timeString) {
-    const validTimeString = extractTime(timeString);
-    if (!validTimeString)
-        return 0;
-    const [hours, minutes] = validTimeString.split(':').map((value) => parseInt(value));
-    return hours * 60 + minutes;
-}
-function dayMinutesToTimeString(totalMinutes) {
-    let hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes - hours * 60;
-    if (hours > 23)
-        hours = hours % 24;
-    return [zeroPad(hours), zeroPad(minutes)].join(':');
-}
-function tidyTime(timeString) {
-    return isTimeString(timeString) ? timeString.split(':').slice(0, 2).map(zeroPad).join(':') : undefined;
-}
-function extractTime(dateString) {
-    return isISODateString(dateString) && dateString.indexOf('T') > 0
-        ? tidyTime(dateString.split('T').reverse()[0])
-        : tidyTime(dateString);
-}
-function extractDate(dateString) {
-    return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split('T')[0] : undefined;
-}
-function dateStringDaysChange(dateString, daysChange) {
-    const date = new Date(dateString);
-    date.setDate(date.getDate() + daysChange);
-    return extractDate(date.toISOString());
-}
-function splitTime(value) {
-    value = typeof value !== 'string' ? '00:00' : value;
-    const o = {}, time = {};
-    ({ 0: o.time, 1: o.ampm } = value.split(' ') || []);
-    ({ 0: time.hours, 1: time.minutes } = o.time.split(':') || []);
-    time.ampm = o.ampm;
-    if (isNaN(time.hours) || isNaN(time.minutes) || (time.ampm && !['AM', 'PM'].includes(time.ampm.toUpperCase())))
-        return {};
-    return time;
-}
-function militaryTime(value) {
-    const time = splitTime(value);
-    if (time.ampm && time.hours) {
-        if (time.ampm.toLowerCase() === 'pm' && parseInt(time.hours) < 12)
-            time.hours = ((time.hours && parseInt(time.hours)) || 0) + 12;
-        if (time.ampm.toLowerCase() === 'am' && time.hours === '12')
-            time.hours = '00';
-    }
-    const timeString = `${time.hours || '12'}:${time.minutes || '00'}`;
-    return timeString.split(':').map(zeroPad).join(':');
-}
-function regularTime(value) {
-    const time = splitTime(value);
-    if (typeof time === 'object' && !Object.keys(time).length)
-        return undefined;
-    if (time.ampm)
-        return value;
-    if (time.hours > 12) {
-        time.hours -= 12;
-        time.ampm = 'PM';
-    }
-    else if (time.hours === '12') {
-        time.ampm = 'PM';
-    }
-    else if (time.hours === '00') {
-        time.hours = '12';
-        time.ampm = 'AM';
-    }
-    else {
-        time.ampm = 'AM';
-    }
-    if (time.hours?.[0] === '0') {
-        time.hours = time.hours.slice(1);
-    }
-    return `${time.hours || '12'}:${time.minutes || '00'} ${time.ampm}`;
-}
-function convertTime(value, time24, keepDate) {
-    const hasDate = extractDate(value);
-    const timeString = extractTime(value);
-    const timeValue = hasDate ? timeString : value;
-    return !value
-        ? undefined
-        : (time24 && ((hasDate && keepDate && value) || militaryTime(timeValue))) || regularTime(timeValue);
-}
-function timeSort(a, b) {
-    const as = splitTime(a);
-    const bs = splitTime(b);
-    if (parseInt(as.hours) < parseInt(bs.hours))
-        return -1;
-    if (parseInt(as.hours) > parseInt(bs.hours))
-        return 1;
-    if (as.hours === bs.hours) {
-        if (parseInt(as.minutes) < parseInt(bs.minutes))
-            return -1;
-        if (parseInt(as.minutes) > parseInt(bs.minutes))
-            return 1;
-    }
-    return 0;
-}
-function addDays(date, days = 7) {
-    const universalDate = extractDate(date) + 'T00:00';
-    const now = new Date(universalDate);
-    const adjustedDate = new Date(now.setDate(now.getDate() + days));
-    return formatDate(adjustedDate);
-}
-function addWeek(date) {
-    return addDays(date);
-}
-function getDateByWeek(week, year, dateFormat, sunday = false) {
-    const date = new Date(year, 0, 1 + (week - 1) * 7);
-    const startValue = sunday ? 0 : 1;
-    date.setDate(date.getDate() + (startValue - date.getDay()));
-    return formatDate(date, dateFormat);
-}
-function dateFromDay(year, day, dateFormat) {
-    const date = new Date(year, 0);
-    return formatDate(new Date(date.setDate(day)), dateFormat);
-}
-function timeToDate(timeString, date = undefined) {
-    const [hours, minutes] = (timeString || '00:00').split(':').map(zeroPad);
-    const milliseconds = offsetDate(date).setHours(hours, minutes, 0, 0);
-    return offsetDate(milliseconds);
-}
-function minutesDifference(date1, date2, absolute = true) {
-    const dt1 = new Date(date1);
-    const dt2 = new Date(date2);
-    const diff = (dt2.getTime() - dt1.getTime()) / 1000 / 60;
-    return absolute ? Math.abs(Math.round(diff)) : Math.round(diff);
-}
-function addMinutesToTimeString(timeString, minutes) {
-    const validTimeString = extractTime(timeString);
-    if (!validTimeString)
-        return '00:00';
-    const minutesToAdd = isNaN(minutes) ? 0 : minutes;
-    return extractTime(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
-}
-function addMinutes(startDate, minutes) {
-    const date = new Date(startDate);
-    return new Date(date.getTime() + minutes * 60000);
-}
-function zeroPad(number) {
-    return number.toString()[1] ? number : '0' + number;
-}
-function sameDay(date1, date2) {
-    const d1 = new Date(date1);
-    const d2 = new Date(date2);
-    return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth() && d1.getDate() === d2.getDate();
-}
-const dateTime = {
-    addDays,
-    addWeek,
-    addMinutesToTimeString,
-    convertTime,
-    getIsoDateString,
-    getUTCdateString,
-    DateHHMM,
-    extractDate,
-    extractTime,
-    formatDate,
-    getDateByWeek,
-    isISODateString,
-    isDate,
-    isTimeString,
-    offsetDate,
-    offsetTime,
-    sameDay,
-    timeStringMinutes,
-    timeToDate,
-    timeUTC,
-    validTimeValue,
-    validDateString,
-    timeValidation,
-    dateValidation,
-};
-
-function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions, iteration = 0) {
-    if (getProvider().makeDeepCopy)
-        return getProvider().makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions);
-    const deepCopy = deepCopyEnabled();
-    const { stringify, toJSON, ignore, modulate } = deepCopy || {};
-    if ((!deepCopy?.enabled && !internalUse) ||
-        typeof sourceObject !== 'object' ||
-        typeof sourceObject === 'function' ||
-        sourceObject === null ||
-        (typeof deepCopy?.threshold === 'number' && iteration >= deepCopy.threshold)) {
-        return sourceObject;
-    }
-    const targetObject = Array.isArray(sourceObject) ? [] : {};
-    const sourceObjectKeys = Object.keys(sourceObject).filter((key) => !internalUse ||
-        !ignore ||
-        (Array.isArray(ignore) && !ignore.includes(key)) ||
-        (typeof ignore === 'function' && !ignore(key)));
-    const stringifyValue = (key, value) => {
-        targetObject[key] = typeof value?.toString === 'function' ? value.toString() : JSON.stringify(value);
-    };
-    for (const key of sourceObjectKeys) {
-        const value = sourceObject[key];
-        const modulated = typeof modulate === 'function' ? modulate(value) : undefined;
-        if (modulated !== undefined) {
-            targetObject[key] = modulated;
-        }
-        else if (convertExtensions && key === 'extensions' && Array.isArray(value)) {
-            const extensionConversions = extensionsToAttributes(value);
-            Object.assign(targetObject, ...extensionConversions);
-        }
-        else if (removeExtensions && key === 'extensions') {
-            targetObject[key] = [];
-        }
-        else if (Array.isArray(stringify) && stringify.includes(key)) {
-            stringifyValue(key, value);
-        }
-        else if (Array.isArray(toJSON) && toJSON.includes(key) && typeof value?.toJSON === 'function') {
-            targetObject[key] = value.toJSON();
-        }
-        else if (value === null) {
-            targetObject[key] = undefined;
-        }
-        else if (isDateObject(value)) {
-            targetObject[key] = new Date(value).toISOString();
-        }
-        else {
-            targetObject[key] = makeDeepCopy(value, convertExtensions, internalUse, removeExtensions, iteration + 1);
-        }
-    }
-    return targetObject;
-}
-function extensionsToAttributes(extensions) {
-    return extensions
-        ?.map((extension) => {
-        const { name, value } = extension;
-        return name && value && { [`_${name}`]: value };
-    })
-        .filter(Boolean);
-}
-
-function getAccessorValue({ element, accessor }) {
-    if (typeof accessor !== 'string')
-        return { values: [] };
-    const targetElement = makeDeepCopy(element);
-    const attributes = accessor.split('.');
-    const values = [];
-    let value;
-    processKeys({ targetElement, attributes });
-    const result = { value };
-    if (values.length)
-        result.values = values;
-    return result;
-    function processKeys({ targetElement, attributes = [], significantCharacters }) {
-        for (const [index, attribute] of attributes.entries()) {
-            if (targetElement?.[attribute]) {
-                const remainingKeys = attributes.slice(index + 1);
-                if (!remainingKeys.length) {
-                    if (!value)
-                        value = targetElement[attribute];
-                    if (!values.includes(targetElement[attribute])) {
-                        values.push(targetElement[attribute]);
-                    }
-                }
-                else if (Array.isArray(targetElement[attribute])) {
-                    const values = targetElement[attribute];
-                    values.forEach((nestedTarget) => processKeys({
-                        targetElement: nestedTarget,
-                        attributes: remainingKeys,
-                    }));
-                }
-                else {
-                    targetElement = targetElement[attribute];
-                    checkValue({ targetElement, index });
-                }
-            }
-        }
-        function checkValue({ targetElement, index }) {
-            if (targetElement && index === attributes.length - 1 && ['string', 'number'].includes(typeof targetElement)) {
-                const extractedValue = significantCharacters ? targetElement.slice(0, significantCharacters) : targetElement;
-                if (value) {
-                    if (!values.includes(extractedValue)) {
-                        values.push(extractedValue);
-                    }
-                }
-                else {
-                    value = extractedValue;
-                    values.push(extractedValue);
-                }
-            }
-        }
-    }
+    return '2.0.24';
 }
 
 function isFunction(obj) {
@@ -468,18 +43,6 @@ function createMap(objectArray, attribute) {
         .filter(Boolean));
 }
 const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] === a[key]);
-const extractAttributes = (accessor) => (element) => !accessor || typeof element !== 'object'
-    ? undefined
-    : (Array.isArray(accessor) &&
-        accessor.map((a) => ({
-            [a]: getAccessorValue({ element, accessor: a })?.value,
-        }))) ||
-        (typeof accessor === 'object' &&
-            Object.keys(accessor).map((key) => ({
-                [key]: getAccessorValue({ element, accessor: key })?.value,
-            }))) ||
-        (typeof accessor === 'string' && getAccessorValue({ element, accessor }))?.value;
-const xa = extractAttributes;
 function undefinedToNull(obj, shallow) {
     if (obj === undefined)
         return null;
@@ -1966,7 +1529,7 @@ function timeKeeper(action = 'reset', timer = 'default') {
     return globalState.timers[timer];
 }
 function setGlobalLog(loggingFx) {
-    if (typeof loggingFx === 'function') {
+    if (isFunction(loggingFx)) {
         globalState.globalLog = loggingFx;
     }
     else {
@@ -2022,7 +1585,7 @@ function setGlobalMethods(params) {
     if (typeof params !== 'object')
         return { error: INVALID_VALUES };
     Object.keys(params).forEach((methodName) => {
-        if (typeof params[methodName] !== 'function')
+        if (!isFunction(params[methodName]))
             return;
         globalState.globalMethods[methodName] = params[methodName];
     });
@@ -2087,7 +1650,7 @@ function getProvider() {
     return _globalStateProvider;
 }
 function handleCaughtError({ engineName, methodName, params, err }) {
-    const caughtErrorHandler = (typeof _globalStateProvider.handleCaughtError === 'function' && _globalStateProvider.handleCaughtError) ||
+    const caughtErrorHandler = (isFunction(_globalStateProvider.handleCaughtError) && _globalStateProvider.handleCaughtError) ||
         syncGlobalState$1.handleCaughtError;
     return caughtErrorHandler({
         engineName,
@@ -2244,6 +1807,7 @@ const UUIDS$1 = 'uuids';
 const AVERAGE_MATCHUP_MINUTES = 'averageMatchUpMinutes';
 const RECOVERY_MINUTES = 'recoveryMinutes';
 const PERIOD_LENGTH = 'periodLength';
+const NUMBER = 'number';
 const OBJECT = 'object';
 const ARRAY = 'array';
 const VALIDATE = '_validate';
@@ -2495,6 +2059,378 @@ function attributeFilter(params) {
     }
 }
 
+const validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
+const validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
+const dateValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))([ T](0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
+const timeValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))?([ T]?(0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
+
+function getIsoDateString(schedule) {
+    let { scheduledDate } = schedule;
+    if (!scheduledDate && schedule.scheduledTime)
+        scheduledDate = extractDate(schedule.scheduledTime);
+    if (!scheduledDate)
+        return;
+    const extractedTime = extractTime(schedule.scheduledTime);
+    let isoDateString = extractDate(scheduledDate);
+    if (isoDateString && extractedTime)
+        isoDateString += `T${extractedTime}`;
+    return isoDateString;
+}
+function isDateObject(value) {
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    else {
+        const datePrototype = Object.prototype.toString.call(value);
+        return datePrototype === '[object Date]';
+    }
+}
+function validTimeValue(value) {
+    const spaceSplit = typeof value === 'string' ? value?.split(' ') : [];
+    if (value && spaceSplit?.length > 1 && !['AM', 'PM'].includes(spaceSplit[1].toUpperCase()))
+        return false;
+    return !!(!value || timeValidation.test(convertTime(value, true, true)));
+}
+function isValidDateString(scheduleDate) {
+    return isISODateString(scheduleDate) || validDateString.test(scheduleDate);
+}
+function DateHHMM(date) {
+    const dt = new Date(date);
+    const secs = dt.getSeconds() + 60 * dt.getMinutes() + 60 * 60 * dt.getHours();
+    return HHMMSS(secs, { displaySeconds: false });
+}
+function HHMMSS(s, format) {
+    const secondNumber = parseInt(s, 10);
+    const hours = Math.floor(secondNumber / 3600);
+    const minutes = Math.floor((secondNumber - hours * 3600) / 60);
+    const seconds = secondNumber - hours * 3600 - minutes * 60;
+    const displaySeconds = !format || format?.displaySeconds;
+    const timeString = displaySeconds ? hours + ':' + minutes + ':' + seconds : hours + ':' + minutes;
+    return timeString.split(':').map(zeroPad).join(':');
+}
+const getUTCdateString = (date) => {
+    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
+    const monthNumber = dateDate.getUTCMonth() + 1;
+    const utcMonth = monthNumber < 10 ? `0${monthNumber}` : `${monthNumber}`;
+    return `${dateDate.getUTCFullYear()}-${zeroPad(utcMonth)}-${zeroPad(dateDate.getUTCDate())}`;
+};
+function timeUTC(date) {
+    const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : new Date();
+    return Date.UTC(dateDate.getFullYear(), dateDate.getMonth(), dateDate.getDate());
+}
+function formatDate(date, separator = '-', format = 'YMD') {
+    if (!date)
+        return '';
+    if (typeof date === 'string' && date.indexOf('T') < 0)
+        date = date + 'T00:00';
+    const d = new Date(date);
+    let month = '' + (d.getMonth() + 1);
+    let day = '' + d.getDate();
+    const year = d.getFullYear();
+    if (month.length < 2)
+        month = '0' + month;
+    if (day.length < 2)
+        day = '0' + day;
+    if (format === 'DMY')
+        return [day, month, year].join(separator);
+    if (format === 'MDY')
+        return [month, day, year].join(separator);
+    if (format === 'YDM')
+        return [year, day, month].join(separator);
+    if (format === 'DYM')
+        return [day, year, month].join(separator);
+    if (format === 'MYD')
+        return [month, year, day].join(separator);
+    return [year, month, day].join(separator);
+}
+function offsetDate(date) {
+    const targetTime = date ? new Date(date) : new Date();
+    const tzDifference = targetTime.getTimezoneOffset();
+    return new Date(targetTime.getTime() - tzDifference * 60 * 1000);
+}
+function offsetTime(date) {
+    return offsetDate(date).getTime();
+}
+function isDate(dateArg) {
+    if (typeof dateArg == 'boolean')
+        return false;
+    const t = (dateArg instanceof Date && dateArg) || (!isNaN(dateArg) && new Date(dateArg)) || false;
+    return t && !isNaN(t.valueOf());
+}
+function generateDateRange(startDt, endDt) {
+    if (!isValidDateString(startDt) || !isValidDateString(endDt))
+        return [];
+    const startDateString = extractDate(startDt) + 'T00:00';
+    const endDateString = extractDate(endDt) + 'T00:00';
+    const startDate = new Date(startDateString);
+    const endDate = new Date(endDateString);
+    const process = isDate(endDate) && isDate(startDate) && isValidDateRange(startDate, endDate);
+    const between = [];
+    let iterations = 0;
+    if (process) {
+        const currentDate = startDate;
+        let dateSecs = currentDate.getTime();
+        while (dateSecs <= endDate.getTime() && iterations < 300) {
+            iterations += 1;
+            between.push(new Date(currentDate));
+            dateSecs = currentDate.setDate(currentDate.getDate() + 1);
+        }
+    }
+    return between.map((date) => formatDate(date));
+    function isValidDateRange(minDate, maxDate) {
+        return minDate <= maxDate;
+    }
+}
+const re = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+function isISODateString(dateString) {
+    if (typeof dateString !== 'string')
+        return false;
+    return re.test(dateString);
+}
+function isTimeString(timeString) {
+    if (typeof timeString !== 'string')
+        return false;
+    const noZ = timeString.split('Z')[0];
+    const parts = noZ.split(':');
+    const isNumeric = parts.every((part) => !isNaN(parseInt(part)));
+    const invalid = parts.length < 2 || !isNumeric || parseInt(parts[0]) > 23 || parseInt(parts[1]) > 60;
+    return !invalid;
+}
+function timeStringMinutes(timeString) {
+    const validTimeString = extractTime(timeString);
+    if (!validTimeString)
+        return 0;
+    const [hours, minutes] = validTimeString.split(':').map((value) => parseInt(value));
+    return hours * 60 + minutes;
+}
+function dayMinutesToTimeString(totalMinutes) {
+    let hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes - hours * 60;
+    if (hours > 23)
+        hours = hours % 24;
+    return [zeroPad(hours), zeroPad(minutes)].join(':');
+}
+function tidyTime(timeString) {
+    return isTimeString(timeString) ? timeString.split(':').slice(0, 2).map(zeroPad).join(':') : undefined;
+}
+function extractTime(dateString) {
+    return isISODateString(dateString) && dateString.indexOf('T') > 0
+        ? tidyTime(dateString.split('T').reverse()[0])
+        : tidyTime(dateString);
+}
+function extractDate(dateString) {
+    return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split('T')[0] : undefined;
+}
+function dateStringDaysChange(dateString, daysChange) {
+    const date = new Date(dateString);
+    date.setDate(date.getDate() + daysChange);
+    return extractDate(date.toISOString());
+}
+function splitTime(value) {
+    value = typeof value !== 'string' ? '00:00' : value;
+    const o = {}, time = {};
+    ({ 0: o.time, 1: o.ampm } = value.split(' ') || []);
+    ({ 0: time.hours, 1: time.minutes } = o.time.split(':') || []);
+    time.ampm = o.ampm;
+    if (isNaN(time.hours) || isNaN(time.minutes) || (time.ampm && !['AM', 'PM'].includes(time.ampm.toUpperCase())))
+        return {};
+    return time;
+}
+function militaryTime(value) {
+    const time = splitTime(value);
+    if (time.ampm && time.hours) {
+        if (time.ampm.toLowerCase() === 'pm' && parseInt(time.hours) < 12)
+            time.hours = ((time.hours && parseInt(time.hours)) || 0) + 12;
+        if (time.ampm.toLowerCase() === 'am' && time.hours === '12')
+            time.hours = '00';
+    }
+    const timeString = `${time.hours || '12'}:${time.minutes || '00'}`;
+    return timeString.split(':').map(zeroPad).join(':');
+}
+function regularTime(value) {
+    const time = splitTime(value);
+    if (typeof time === 'object' && !Object.keys(time).length)
+        return undefined;
+    if (time.ampm)
+        return value;
+    if (time.hours > 12) {
+        time.hours -= 12;
+        time.ampm = 'PM';
+    }
+    else if (time.hours === '12') {
+        time.ampm = 'PM';
+    }
+    else if (time.hours === '00') {
+        time.hours = '12';
+        time.ampm = 'AM';
+    }
+    else {
+        time.ampm = 'AM';
+    }
+    if (time.hours?.[0] === '0') {
+        time.hours = time.hours.slice(1);
+    }
+    return `${time.hours || '12'}:${time.minutes || '00'} ${time.ampm}`;
+}
+function convertTime(value, time24, keepDate) {
+    const hasDate = extractDate(value);
+    const timeString = extractTime(value);
+    const timeValue = hasDate ? timeString : value;
+    return !value
+        ? undefined
+        : (time24 && ((hasDate && keepDate && value) || militaryTime(timeValue))) || regularTime(timeValue);
+}
+function timeSort(a, b) {
+    const as = splitTime(a);
+    const bs = splitTime(b);
+    if (parseInt(as.hours) < parseInt(bs.hours))
+        return -1;
+    if (parseInt(as.hours) > parseInt(bs.hours))
+        return 1;
+    if (as.hours === bs.hours) {
+        if (parseInt(as.minutes) < parseInt(bs.minutes))
+            return -1;
+        if (parseInt(as.minutes) > parseInt(bs.minutes))
+            return 1;
+    }
+    return 0;
+}
+function addDays(date, days = 7) {
+    const universalDate = extractDate(date) + 'T00:00';
+    const now = new Date(universalDate);
+    const adjustedDate = new Date(now.setDate(now.getDate() + days));
+    return formatDate(adjustedDate);
+}
+function addWeek(date) {
+    return addDays(date);
+}
+function getDateByWeek(week, year, dateFormat, sunday = false) {
+    const date = new Date(year, 0, 1 + (week - 1) * 7);
+    const startValue = sunday ? 0 : 1;
+    date.setDate(date.getDate() + (startValue - date.getDay()));
+    return formatDate(date, dateFormat);
+}
+function dateFromDay(year, day, dateFormat) {
+    const date = new Date(year, 0);
+    return formatDate(new Date(date.setDate(day)), dateFormat);
+}
+function timeToDate(timeString, date = undefined) {
+    const [hours, minutes] = (timeString || '00:00').split(':').map(zeroPad);
+    const milliseconds = offsetDate(date).setHours(hours, minutes, 0, 0);
+    return offsetDate(milliseconds);
+}
+function minutesDifference(date1, date2, absolute = true) {
+    const dt1 = new Date(date1);
+    const dt2 = new Date(date2);
+    const diff = (dt2.getTime() - dt1.getTime()) / 1000 / 60;
+    return absolute ? Math.abs(Math.round(diff)) : Math.round(diff);
+}
+function addMinutesToTimeString(timeString, minutes) {
+    const validTimeString = extractTime(timeString);
+    if (!validTimeString)
+        return '00:00';
+    const minutesToAdd = isNaN(minutes) ? 0 : minutes;
+    return extractTime(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
+}
+function addMinutes(startDate, minutes) {
+    const date = new Date(startDate);
+    return new Date(date.getTime() + minutes * 60000);
+}
+function zeroPad(number) {
+    return number.toString()[1] ? number : '0' + number;
+}
+function sameDay(date1, date2) {
+    const d1 = new Date(date1);
+    const d2 = new Date(date2);
+    return d1.getFullYear() === d2.getFullYear() && d1.getMonth() === d2.getMonth() && d1.getDate() === d2.getDate();
+}
+const dateTime = {
+    addDays,
+    addWeek,
+    addMinutesToTimeString,
+    convertTime,
+    getIsoDateString,
+    getUTCdateString,
+    DateHHMM,
+    extractDate,
+    extractTime,
+    formatDate,
+    getDateByWeek,
+    isISODateString,
+    isDate,
+    isTimeString,
+    offsetDate,
+    offsetTime,
+    sameDay,
+    timeStringMinutes,
+    timeToDate,
+    timeUTC,
+    validTimeValue,
+    validDateString,
+    timeValidation,
+    dateValidation,
+};
+
+function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions, iteration = 0) {
+    if (getProvider().makeDeepCopy)
+        return getProvider().makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions);
+    const deepCopy = deepCopyEnabled();
+    const { stringify, toJSON, ignore, modulate } = deepCopy || {};
+    if ((!deepCopy?.enabled && !internalUse) ||
+        typeof sourceObject !== 'object' ||
+        isFunction(sourceObject) ||
+        sourceObject === null ||
+        (typeof deepCopy?.threshold === 'number' && iteration >= deepCopy.threshold)) {
+        return sourceObject;
+    }
+    const targetObject = Array.isArray(sourceObject) ? [] : {};
+    const sourceObjectKeys = Object.keys(sourceObject).filter((key) => !internalUse ||
+        !ignore ||
+        (Array.isArray(ignore) && !ignore.includes(key)) ||
+        (isFunction(ignore) && !ignore(key)));
+    const stringifyValue = (key, value) => {
+        targetObject[key] = isFunction(value?.toString) ? value.toString() : JSON.stringify(value);
+    };
+    for (const key of sourceObjectKeys) {
+        const value = sourceObject[key];
+        const modulated = isFunction(modulate) ? modulate(value) : undefined;
+        if (modulated !== undefined) {
+            targetObject[key] = modulated;
+        }
+        else if (convertExtensions && key === 'extensions' && Array.isArray(value)) {
+            const extensionConversions = extensionsToAttributes(value);
+            Object.assign(targetObject, ...extensionConversions);
+        }
+        else if (removeExtensions && key === 'extensions') {
+            targetObject[key] = [];
+        }
+        else if (Array.isArray(stringify) && stringify.includes(key)) {
+            stringifyValue(key, value);
+        }
+        else if (Array.isArray(toJSON) && toJSON.includes(key) && isFunction(value?.toJSON)) {
+            targetObject[key] = value.toJSON();
+        }
+        else if (value === null) {
+            targetObject[key] = undefined;
+        }
+        else if (isDateObject(value)) {
+            targetObject[key] = new Date(value).toISOString();
+        }
+        else {
+            targetObject[key] = makeDeepCopy(value, convertExtensions, internalUse, removeExtensions, iteration + 1);
+        }
+    }
+    return targetObject;
+}
+function extensionsToAttributes(extensions) {
+    return extensions
+        ?.map((extension) => {
+        const { name, value } = extension;
+        return name && value && { [`_${name}`]: value };
+    })
+        .filter(Boolean);
+}
+
 const POLICY_TYPE_VOLUNTARY_CONSOLATION = 'voluntaryConsolation';
 const POLICY_TYPE_COMPETITIVE_BANDS = 'competitiveBands';
 const POLICY_TYPE_ROUND_ROBIN_TALLY = 'roundRobinTally';
@@ -3930,6 +3866,72 @@ function getRoundMatchUps({ matchUps = [], interpolate }) {
     };
 }
 
+function getAccessorValue({ element, accessor }) {
+    if (typeof accessor !== 'string')
+        return { values: [] };
+    const targetElement = makeDeepCopy(element);
+    const attributes = accessor.split('.');
+    const values = [];
+    let value;
+    processKeys({ targetElement, attributes });
+    const result = { value };
+    if (values.length)
+        result.values = values;
+    return result;
+    function processKeys({ targetElement, attributes = [], significantCharacters }) {
+        for (const [index, attribute] of attributes.entries()) {
+            if (targetElement?.[attribute]) {
+                const remainingKeys = attributes.slice(index + 1);
+                if (!remainingKeys.length) {
+                    if (!value)
+                        value = targetElement[attribute];
+                    if (!values.includes(targetElement[attribute])) {
+                        values.push(targetElement[attribute]);
+                    }
+                }
+                else if (Array.isArray(targetElement[attribute])) {
+                    const values = targetElement[attribute];
+                    values.forEach((nestedTarget) => processKeys({
+                        targetElement: nestedTarget,
+                        attributes: remainingKeys,
+                    }));
+                }
+                else {
+                    targetElement = targetElement[attribute];
+                    checkValue({ targetElement, index });
+                }
+            }
+        }
+        function checkValue({ targetElement, index }) {
+            if (targetElement && index === attributes.length - 1 && ['string', 'number'].includes(typeof targetElement)) {
+                const extractedValue = significantCharacters ? targetElement.slice(0, significantCharacters) : targetElement;
+                if (value) {
+                    if (!values.includes(extractedValue)) {
+                        values.push(extractedValue);
+                    }
+                }
+                else {
+                    value = extractedValue;
+                    values.push(extractedValue);
+                }
+            }
+        }
+    }
+}
+
+const extractAttributes = (accessor) => (element) => !accessor || typeof element !== 'object'
+    ? undefined
+    : (Array.isArray(accessor) &&
+        accessor.map((a) => ({
+            [a]: getAccessorValue({ element, accessor: a })?.value,
+        }))) ||
+        (typeof accessor === 'object' &&
+            Object.keys(accessor).map((key) => ({
+                [key]: getAccessorValue({ element, accessor: key })?.value,
+            }))) ||
+        (typeof accessor === 'string' && getAccessorValue({ element, accessor }))?.value;
+const xa = extractAttributes;
+
 function addFinishingRounds({ finishingPositionOffset = 0, finishingPositionLimit, positionsFed, roundsCount, roundLimit, matchUps, lucky, fmlc, }) {
     if (!validMatchUps(matchUps))
         return [];
@@ -5001,6 +5003,109 @@ function matchUpAssignedVenueId({ visibilityThreshold, timeStamp, schedule, matc
         : schedule;
 }
 
+function matchUpTimeModifiers({ visibilityThreshold, timeStamp, schedule, matchUp }) {
+    const { itemValue: timeModifiers, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: TIME_MODIFIERS,
+        visibilityThreshold,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { timeModifiers }
+        : schedule;
+}
+
+function timeDate$1(value) {
+    if (validTimeString.test(value)) {
+        const dateString = getUTCdateString();
+        return new Date(`${dateString}T${value}`);
+    }
+    else {
+        return new Date(value);
+    }
+}
+function matchUpDuration({ matchUp }) {
+    if (!matchUp)
+        return { error: MISSING_MATCHUP };
+    if (!matchUp.timeItems)
+        return { error: MISSING_TIME_ITEMS };
+    const relevantTimeItems = matchUp.timeItems
+        .filter((timeItem) => [START_TIME, STOP_TIME, RESUME_TIME, END_TIME].includes(timeItem?.itemType))
+        .sort((a, b) => timeDate$1(a.itemValue).getTime() - timeDate$1(b.itemValue).getTime());
+    const elapsed = relevantTimeItems.reduce((elapsed, timeItem) => {
+        let milliseconds;
+        const itemTypeComponents = timeItem?.itemType?.split('.');
+        const timeType = timeItem?.itemType?.startsWith('SCHEDULE.TIME') && itemTypeComponents[2];
+        const scheduleType = `SCHEDULE.TIME.${timeType}`;
+        switch (scheduleType) {
+            case START_TIME:
+                milliseconds = 0;
+                break;
+            case END_TIME:
+                if (elapsed.lastValue && [START_TIME, RESUME_TIME].includes(elapsed.lastType)) {
+                    const interval = timeDate$1(timeItem.itemValue).getTime() - timeDate$1(elapsed.lastValue).getTime();
+                    milliseconds = elapsed.milliseconds + interval;
+                }
+                else {
+                    milliseconds = elapsed.milliseconds;
+                }
+                break;
+            case STOP_TIME:
+                if ([START_TIME, 'SCHECULE.TIME.RESUME'].includes(elapsed.lastType)) {
+                    const interval = timeDate$1(timeItem.itemValue).getTime() - timeDate$1(elapsed.lastValue).getTime();
+                    milliseconds = elapsed.milliseconds + interval;
+                }
+                else {
+                    milliseconds = elapsed.milliseconds;
+                }
+                break;
+            default:
+                milliseconds = elapsed.milliseconds;
+                break;
+        }
+        return {
+            milliseconds,
+            lastType: scheduleType,
+            lastValue: timeItem.itemValue,
+        };
+    }, { milliseconds: 0, lastType: undefined, lastValue: undefined });
+    if ([START_TIME, RESUME_TIME].includes(elapsed.lastType)) {
+        const interval = new Date().getTime() - timeDate$1(elapsed.lastValue).getTime();
+        elapsed.milliseconds += interval;
+    }
+    return {
+        milliseconds: elapsed.milliseconds,
+        time: msToTime(elapsed.milliseconds),
+        relevantTimeItems,
+    };
+}
+function msToTime(s) {
+    const pad = (n, z = 2) => ('00' + n).slice(-z);
+    return pad((s / 3.6e6) | 0) + ':' + pad(((s % 3.6e6) / 6e4) | 0) + ':' + pad(((s % 6e4) / 1000) | 0);
+}
+
+function matchUpCourtOrder({ visibilityThreshold, timeStamp, schedule, matchUp }) {
+    const { itemValue: courtOrder, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: COURT_ORDER,
+        visibilityThreshold,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { courtOrder }
+        : schedule;
+}
+
+function matchUpStartTime({ matchUp }) {
+    const timeItems = matchUp?.timeItems || [];
+    const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
+    const startTimeItem = timeItems.reduce((startTimeItem, timeItem) => {
+        const startTimeCandidate = timeItem.itemType === START_TIME && timeItem;
+        const earlierStartTimeItem = startTimeCandidate && (!startTimeItem || getTimeStamp(startTimeCandidate) < getTimeStamp(startTimeItem));
+        return earlierStartTimeItem ? startTimeCandidate : startTimeItem;
+    }, undefined);
+    const startTime = startTimeItem?.itemValue;
+    return { startTime };
+}
+
 function UUIDS(count = 1) {
     return generateRange(0, count).map(UUID);
 }
@@ -5218,84 +5323,16 @@ function getVenueData({ tournamentRecord, venueId }) {
     return { ...SUCCESS, venueData: makeDeepCopy(venueData, false, true) };
 }
 
-function matchUpTimeModifiers({ visibilityThreshold, timeStamp, schedule, matchUp }) {
-    const { itemValue: timeModifiers, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: TIME_MODIFIERS,
-        visibilityThreshold,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { timeModifiers }
-        : schedule;
-}
-
-function timeDate$1(value) {
-    if (validTimeString.test(value)) {
-        const dateString = getUTCdateString();
-        return new Date(`${dateString}T${value}`);
-    }
-    else {
-        return new Date(value);
-    }
-}
-function matchUpDuration({ matchUp }) {
-    if (!matchUp)
-        return { error: MISSING_MATCHUP };
-    if (!matchUp.timeItems)
-        return { error: MISSING_TIME_ITEMS };
-    const relevantTimeItems = matchUp.timeItems
-        .filter((timeItem) => [START_TIME, STOP_TIME, RESUME_TIME, END_TIME].includes(timeItem?.itemType))
-        .sort((a, b) => timeDate$1(a.itemValue).getTime() - timeDate$1(b.itemValue).getTime());
-    const elapsed = relevantTimeItems.reduce((elapsed, timeItem) => {
-        let milliseconds;
-        const itemTypeComponents = timeItem?.itemType?.split('.');
-        const timeType = timeItem?.itemType?.startsWith('SCHEDULE.TIME') && itemTypeComponents[2];
-        const scheduleType = `SCHEDULE.TIME.${timeType}`;
-        switch (scheduleType) {
-            case START_TIME:
-                milliseconds = 0;
-                break;
-            case END_TIME:
-                if (elapsed.lastValue && [START_TIME, RESUME_TIME].includes(elapsed.lastType)) {
-                    const interval = timeDate$1(timeItem.itemValue).getTime() - timeDate$1(elapsed.lastValue).getTime();
-                    milliseconds = elapsed.milliseconds + interval;
-                }
-                else {
-                    milliseconds = elapsed.milliseconds;
-                }
-                break;
-            case STOP_TIME:
-                if ([START_TIME, 'SCHECULE.TIME.RESUME'].includes(elapsed.lastType)) {
-                    const interval = timeDate$1(timeItem.itemValue).getTime() - timeDate$1(elapsed.lastValue).getTime();
-                    milliseconds = elapsed.milliseconds + interval;
-                }
-                else {
-                    milliseconds = elapsed.milliseconds;
-                }
-                break;
-            default:
-                milliseconds = elapsed.milliseconds;
-                break;
-        }
-        return {
-            milliseconds,
-            lastType: scheduleType,
-            lastValue: timeItem.itemValue,
-        };
-    }, { milliseconds: 0, lastType: undefined, lastValue: undefined });
-    if ([START_TIME, RESUME_TIME].includes(elapsed.lastType)) {
-        const interval = new Date().getTime() - timeDate$1(elapsed.lastValue).getTime();
-        elapsed.milliseconds += interval;
-    }
-    return {
-        milliseconds: elapsed.milliseconds,
-        time: msToTime(elapsed.milliseconds),
-        relevantTimeItems,
-    };
-}
-function msToTime(s) {
-    const pad = (n, z = 2) => ('00' + n).slice(-z);
-    return pad((s / 3.6e6) | 0) + ':' + pad(((s % 3.6e6) / 6e4) | 0) + ':' + pad(((s % 6e4) / 1000) | 0);
+function matchUpEndTime({ matchUp }) {
+    const timeItems = matchUp?.timeItems || [];
+    const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
+    const endTimeItem = timeItems.reduce((endTimeItem, timeItem) => {
+        const endTimeCandidate = timeItem.itemType === END_TIME && timeItem;
+        const earlierStartTimeItem = endTimeCandidate && (!endTimeItem || getTimeStamp(endTimeCandidate) > getTimeStamp(endTimeItem));
+        return earlierStartTimeItem ? endTimeCandidate : endTimeItem;
+    }, undefined);
+    const endTime = endTimeItem?.itemValue;
+    return { endTime };
 }
 
 function getFlightProfile({ event, eventId }) {
@@ -5391,41 +5428,6 @@ function findEvent(params) {
     };
 }
 
-function matchUpCourtOrder({ visibilityThreshold, timeStamp, schedule, matchUp }) {
-    const { itemValue: courtOrder, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: COURT_ORDER,
-        visibilityThreshold,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { courtOrder }
-        : schedule;
-}
-
-function matchUpStartTime({ matchUp }) {
-    const timeItems = matchUp?.timeItems || [];
-    const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
-    const startTimeItem = timeItems.reduce((startTimeItem, timeItem) => {
-        const startTimeCandidate = timeItem.itemType === START_TIME && timeItem;
-        const earlierStartTimeItem = startTimeCandidate && (!startTimeItem || getTimeStamp(startTimeCandidate) < getTimeStamp(startTimeItem));
-        return earlierStartTimeItem ? startTimeCandidate : startTimeItem;
-    }, undefined);
-    const startTime = startTimeItem?.itemValue;
-    return { startTime };
-}
-
-function matchUpEndTime({ matchUp }) {
-    const timeItems = matchUp?.timeItems || [];
-    const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
-    const endTimeItem = timeItems.reduce((endTimeItem, timeItem) => {
-        const endTimeCandidate = timeItem.itemType === END_TIME && timeItem;
-        const earlierStartTimeItem = endTimeCandidate && (!endTimeItem || getTimeStamp(endTimeCandidate) > getTimeStamp(endTimeItem));
-        return earlierStartTimeItem ? endTimeCandidate : endTimeItem;
-    }, undefined);
-    const endTime = endTimeItem?.itemValue;
-    return { endTime };
-}
-
 function getMatchUpScheduleDetails(params) {
     let event = params.event;
     let matchUpType = params.matchUpType;
@@ -5762,159 +5764,6 @@ function getContextContent({ policyDefinitions, tournamentRecord, contextProfile
     return contextContent;
 }
 
-const NORMAL = 'normal';
-const TIMED = 'timed';
-const FINAL = 'final';
-const NOAD = 'NOAD';
-const SET = 'SET';
-const setTypes$1 = {
-    S: NORMAL,
-    F: FINAL,
-};
-
-function parse(matchUpFormatCode) {
-    if (typeof matchUpFormatCode === 'string') {
-        const type = (matchUpFormatCode.startsWith('T') && TIMED) || (matchUpFormatCode.startsWith(SET) && SET) || '';
-        if (type === TIMED) {
-            const setFormat = parseTimedSet(matchUpFormatCode);
-            const parsedFormat = {
-                simplified: true,
-                setFormat,
-                bestOf: 1,
-            };
-            if (setFormat)
-                return parsedFormat;
-        }
-        if (type === SET)
-            return setsMatch(matchUpFormatCode);
-    }
-    return undefined;
-}
-function setsMatch(formatstring) {
-    const parts = formatstring.split('-');
-    const setsCount = getNumber$1(parts[0].slice(3));
-    const bestOf = setsCount === 1 || setsCount % 2 !== 0 ? setsCount : undefined;
-    const exactly = setsCount !== 1 && setsCount % 2 === 0 ? setsCount : undefined;
-    const setFormat = parts && parseSetFormat(parts[1]);
-    const finalSetFormat = parts && parseSetFormat(parts[2]);
-    const timed = (setFormat && setFormat.timed) || (finalSetFormat && finalSetFormat.timed);
-    const validSetsCount = (bestOf && bestOf < 6) || (timed && exactly);
-    const validFinalSet = !parts[2] || finalSetFormat;
-    const validSetsFormat = setFormat;
-    const result = definedAttributes({
-        setFormat,
-        exactly,
-        bestOf,
-    });
-    if (finalSetFormat)
-        result.finalSetFormat = finalSetFormat;
-    if (validSetsCount && validSetsFormat && validFinalSet)
-        return result;
-}
-function parseSetFormat(formatstring) {
-    if (formatstring?.[1] === ':') {
-        const parts = formatstring.split(':');
-        const setType = setTypes$1[parts[0]];
-        const setFormatString = parts[1];
-        if (setType && setFormatString) {
-            const isTiebreakSet = setFormatString.startsWith('TB');
-            if (isTiebreakSet) {
-                const tiebreakSet = parseTiebreakFormat(setFormatString);
-                if (tiebreakSet === false)
-                    return false;
-                return typeof tiebreakSet === 'object' ? { tiebreakSet } : undefined;
-            }
-            const timedSet = setFormatString.startsWith('T');
-            if (timedSet)
-                return parseTimedSet(setFormatString);
-            const parts = formatstring.match(/^[FS]:(\d+)([A-Za-z]*)/);
-            const NoAD = (parts && isNoAD(parts[2])) || false;
-            const validNoAD = !parts?.[2] || NoAD;
-            const setTo = parts ? getNumber$1(parts[1]) : undefined;
-            const tiebreakAtValue = parseTiebreakAt(setFormatString);
-            const validTiebreakAt = tiebreakAtValue !== false;
-            const tiebreakAt = (validTiebreakAt && tiebreakAtValue) || setTo;
-            const tiebreakFormat = parseTiebreakFormat(setFormatString.split('/')[1]);
-            const validTiebreak = tiebreakFormat !== false;
-            const result = { setTo };
-            if (NoAD)
-                result.NoAD = true;
-            if (tiebreakFormat) {
-                result.tiebreakFormat = tiebreakFormat;
-                result.tiebreakAt = tiebreakAt;
-            }
-            else {
-                result.noTiebreak = true;
-            }
-            return (setTo && validNoAD && validTiebreak && validTiebreakAt && result) || false;
-        }
-    }
-    return undefined;
-}
-function parseTiebreakAt(setFormatString, expectNumber = true) {
-    const tiebreakAtValue = setFormatString?.indexOf('@') > 0 && setFormatString.split('@');
-    if (tiebreakAtValue) {
-        const tiebreakAt = expectNumber ? getNumber$1(tiebreakAtValue[1]) : tiebreakAtValue[1];
-        return tiebreakAt || false;
-    }
-    return undefined;
-}
-function parseTiebreakFormat(formatstring) {
-    if (formatstring) {
-        if (formatstring.startsWith('TB')) {
-            const modifier = parseTiebreakAt(formatstring, false);
-            const parts = formatstring.match(/^TB(\d+)([A-Za-z]*)/);
-            const tiebreakToString = parts?.[1];
-            const NoAD = parts && isNoAD(parts[2]);
-            const validNoAD = !parts?.[2] || NoAD;
-            const tiebreakTo = getNumber$1(tiebreakToString);
-            if (tiebreakTo && validNoAD) {
-                const result = { tiebreakTo };
-                if (modifier && typeof modifier === 'string' && !isConvertableInteger(modifier)) {
-                    result.modifier = modifier;
-                }
-                if (NoAD)
-                    result.NoAD = true;
-                return result;
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            return false;
-        }
-    }
-    return undefined;
-}
-function parseTimedSet(formatstring) {
-    const timestring = formatstring.slice(1);
-    const parts = timestring.match(/^(\d+)(@?[A-Za-z]*)/);
-    const minutes = getNumber$1(parts?.[1]);
-    if (!minutes)
-        return;
-    const setFormat = { timed: true, minutes };
-    const based = parts?.[2];
-    const validModifier = [undefined, 'P', 'G'].includes(based);
-    if (based && !validModifier) {
-        const modifier = timestring.match(/^(\d+)(@)([A-Za-z]+)$/)?.[3];
-        if (modifier) {
-            setFormat.modifier = modifier;
-            return setFormat;
-        }
-        return;
-    }
-    if (based)
-        setFormat.based = parts[2];
-    return setFormat;
-}
-function isNoAD(formatstring) {
-    return formatstring && formatstring.indexOf(NOAD) >= 0;
-}
-function getNumber$1(formatstring) {
-    return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
-}
-
 function getOrderedDrawPositions({ drawPositions, roundProfile, roundNumber }) {
     const unassignedDrawPositions = [undefined, undefined];
     if (noNumeric(drawPositions)) {
@@ -6338,6 +6187,159 @@ function getMatchUpType(params) {
     return { matchUpType };
 }
 
+const NORMAL = 'normal';
+const TIMED = 'timed';
+const FINAL = 'final';
+const NOAD = 'NOAD';
+const SET = 'SET';
+const setTypes$1 = {
+    S: NORMAL,
+    F: FINAL,
+};
+
+function parse(matchUpFormatCode) {
+    if (typeof matchUpFormatCode === 'string') {
+        const type = (matchUpFormatCode.startsWith('T') && TIMED) || (matchUpFormatCode.startsWith(SET) && SET) || '';
+        if (type === TIMED) {
+            const setFormat = parseTimedSet(matchUpFormatCode);
+            const parsedFormat = {
+                simplified: true,
+                setFormat,
+                bestOf: 1,
+            };
+            if (setFormat)
+                return parsedFormat;
+        }
+        if (type === SET)
+            return setsMatch(matchUpFormatCode);
+    }
+    return undefined;
+}
+function setsMatch(formatstring) {
+    const parts = formatstring.split('-');
+    const setsCount = getNumber$1(parts[0].slice(3));
+    const bestOf = setsCount === 1 || setsCount % 2 !== 0 ? setsCount : undefined;
+    const exactly = setsCount !== 1 && setsCount % 2 === 0 ? setsCount : undefined;
+    const setFormat = parts && parseSetFormat(parts[1]);
+    const finalSetFormat = parts && parseSetFormat(parts[2]);
+    const timed = (setFormat && setFormat.timed) || (finalSetFormat && finalSetFormat.timed);
+    const validSetsCount = (bestOf && bestOf < 6) || (timed && exactly);
+    const validFinalSet = !parts[2] || finalSetFormat;
+    const validSetsFormat = setFormat;
+    const result = definedAttributes({
+        setFormat,
+        exactly,
+        bestOf,
+    });
+    if (finalSetFormat)
+        result.finalSetFormat = finalSetFormat;
+    if (validSetsCount && validSetsFormat && validFinalSet)
+        return result;
+}
+function parseSetFormat(formatstring) {
+    if (formatstring?.[1] === ':') {
+        const parts = formatstring.split(':');
+        const setType = setTypes$1[parts[0]];
+        const setFormatString = parts[1];
+        if (setType && setFormatString) {
+            const isTiebreakSet = setFormatString.startsWith('TB');
+            if (isTiebreakSet) {
+                const tiebreakSet = parseTiebreakFormat(setFormatString);
+                if (tiebreakSet === false)
+                    return false;
+                return typeof tiebreakSet === 'object' ? { tiebreakSet } : undefined;
+            }
+            const timedSet = setFormatString.startsWith('T');
+            if (timedSet)
+                return parseTimedSet(setFormatString);
+            const parts = formatstring.match(/^[FS]:(\d+)([A-Za-z]*)/);
+            const NoAD = (parts && isNoAD(parts[2])) || false;
+            const validNoAD = !parts?.[2] || NoAD;
+            const setTo = parts ? getNumber$1(parts[1]) : undefined;
+            const tiebreakAtValue = parseTiebreakAt(setFormatString);
+            const validTiebreakAt = tiebreakAtValue !== false;
+            const tiebreakAt = (validTiebreakAt && tiebreakAtValue) || setTo;
+            const tiebreakFormat = parseTiebreakFormat(setFormatString.split('/')[1]);
+            const validTiebreak = tiebreakFormat !== false;
+            const result = { setTo };
+            if (NoAD)
+                result.NoAD = true;
+            if (tiebreakFormat) {
+                result.tiebreakFormat = tiebreakFormat;
+                result.tiebreakAt = tiebreakAt;
+            }
+            else {
+                result.noTiebreak = true;
+            }
+            return (setTo && validNoAD && validTiebreak && validTiebreakAt && result) || false;
+        }
+    }
+    return undefined;
+}
+function parseTiebreakAt(setFormatString, expectNumber = true) {
+    const tiebreakAtValue = setFormatString?.indexOf('@') > 0 && setFormatString.split('@');
+    if (tiebreakAtValue) {
+        const tiebreakAt = expectNumber ? getNumber$1(tiebreakAtValue[1]) : tiebreakAtValue[1];
+        return tiebreakAt || false;
+    }
+    return undefined;
+}
+function parseTiebreakFormat(formatstring) {
+    if (formatstring) {
+        if (formatstring.startsWith('TB')) {
+            const modifier = parseTiebreakAt(formatstring, false);
+            const parts = formatstring.match(/^TB(\d+)([A-Za-z]*)/);
+            const tiebreakToString = parts?.[1];
+            const NoAD = parts && isNoAD(parts[2]);
+            const validNoAD = !parts?.[2] || NoAD;
+            const tiebreakTo = getNumber$1(tiebreakToString);
+            if (tiebreakTo && validNoAD) {
+                const result = { tiebreakTo };
+                if (modifier && typeof modifier === 'string' && !isConvertableInteger(modifier)) {
+                    result.modifier = modifier;
+                }
+                if (NoAD)
+                    result.NoAD = true;
+                return result;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    return undefined;
+}
+function parseTimedSet(formatstring) {
+    const timestring = formatstring.slice(1);
+    const parts = timestring.match(/^(\d+)(@?[A-Za-z]*)/);
+    const minutes = getNumber$1(parts?.[1]);
+    if (!minutes)
+        return;
+    const setFormat = { timed: true, minutes };
+    const based = parts?.[2];
+    const validModifier = [undefined, 'P', 'G'].includes(based);
+    if (based && !validModifier) {
+        const modifier = timestring.match(/^(\d+)(@)([A-Za-z]+)$/)?.[3];
+        if (modifier) {
+            setFormat.modifier = modifier;
+            return setFormat;
+        }
+        return;
+    }
+    if (based)
+        setFormat.based = parts[2];
+    return setFormat;
+}
+function isNoAD(formatstring) {
+    return formatstring && formatstring.indexOf(NOAD) >= 0;
+}
+function getNumber$1(formatstring) {
+    return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
+}
+
 function includesMatchUpEventType(types, matchUpEventType) {
     if (!Array.isArray(types) || !isString(matchUpEventType))
         return false;
@@ -15237,6 +15239,69 @@ function alternateDrawPositionAssignment(params) {
     return alternateDrawPositionAssignment$1(params);
 }
 
+function modifyMappedMatchUps({ params, modMap, structure }) {
+    const { tournamentRecord, drawDefinition, event } = params;
+    for (const matchUp of structure.matchUps) {
+        if (modMap[matchUp.matchUpId]) {
+            matchUp.roundNumber = modMap[matchUp.matchUpId];
+            modifyMatchUpNotice({
+                tournamentId: tournamentRecord?.tournamentId,
+                eventId: event?.eventId,
+                drawDefinition,
+                matchUp,
+            });
+        }
+    }
+}
+
+function checkRoundsArgs(params, additionalChecks) {
+    const checks = [{ drawDefinition: true, structureId: true }];
+    if (Array.isArray(additionalChecks))
+        checks.push(...additionalChecks);
+    const paramsCheck = checkRequiredParameters(params, checks);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const result = findStructure(params);
+    if (result.error)
+        return result;
+    const structure = result.structure;
+    const structureIsAdHoc = isAdHoc({ structure });
+    if (!structureIsAdHoc)
+        return decorateResult({ result: { error: INVALID_STRUCTURE, message: 'structure must be adHoc' } });
+    const { roundMatchUps = [], roundNumbers } = getRoundMatchUps({ matchUps: structure?.matchUps });
+    if (!roundNumbers?.length)
+        return { error: MISSING_MATCHUPS };
+    return { valid: true, structure, roundMatchUps, roundNumbers };
+}
+
+function shiftAdHocRounds(params) {
+    const check = checkRoundsArgs(params, [
+        {
+            targetRoundNumber: true,
+            roundNumber: true,
+            [OF_TYPE]: NUMBER,
+        },
+    ]);
+    if (check.error)
+        return check;
+    const { structure, roundMatchUps, roundNumbers } = check;
+    const { targetRoundNumber, roundNumber } = params;
+    if (!roundNumbers?.includes(roundNumber) || !roundNumbers?.includes(targetRoundNumber)) {
+        return decorateResult({ result: { error: INVALID_VALUES }, info: 'roundNumbers must be valid rounds' });
+    }
+    const downShift = targetRoundNumber > roundNumber;
+    const collateralShifts = downShift
+        ? generateRange(roundNumber + 1, targetRoundNumber + 1)
+        : generateRange(targetRoundNumber, roundNumber);
+    const modMap = {};
+    collateralShifts.forEach((roundNumber) => (roundMatchUps?.[roundNumber] ?? []).forEach(({ matchUpId }) => {
+        modMap[matchUpId] = roundNumber - (downShift ? 1 : -1);
+    }));
+    roundMatchUps?.[roundNumber]?.forEach(({ matchUpId }) => (modMap[matchUpId] = targetRoundNumber));
+    modifyMappedMatchUps({ params, modMap, structure });
+    return { ...SUCCESS };
+}
+
 function setPositionAssignments({ structurePositionAssignments, provisionalPositioning, tournamentRecord, drawDefinition, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -15327,6 +15392,28 @@ function setPositionAssignments({ structurePositionAssignments, provisionalPosit
     return { ...SUCCESS };
 }
 
+function swapAdHocRounds(params) {
+    const check = checkRoundsArgs(params, [
+        {
+            roundNumbers: true,
+            [OF_TYPE]: ARRAY,
+            [VALIDATE]: (value) => value.length === 2 && value.every(isNumeric),
+        },
+    ]);
+    if (check.error)
+        return check;
+    const { structure, roundMatchUps, roundNumbers } = check;
+    if (!params.roundNumbers.every((roundNumber) => roundNumbers?.includes(roundNumber))) {
+        return decorateResult({ result: { error: INVALID_VALUES, message: 'roundNumbers must be valid rounds' } });
+    }
+    const modMap = {};
+    params.roundNumbers.forEach((roundNumber, i) => (roundMatchUps?.[roundNumber] ?? []).forEach(({ matchUpId }) => {
+        modMap[matchUpId] = params.roundNumbers[1 - i];
+    }));
+    modifyMappedMatchUps({ params, modMap, structure });
+    return { ...SUCCESS };
+}
+
 function qualifierDrawPositionAssignment$1({ qualifyingParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
     return positionParticipantAction({
         positionActionName: 'qualifierDrawPositionAssignment',
@@ -17704,20 +17791,78 @@ function addDrawDefinitionTimeItem({ drawDefinition, timeItem }) {
     return { ...SUCCESS };
 }
 
-function removeStructure({ tournamentRecord, drawDefinition, structureId, event, force }) {
-    if (typeof structureId !== 'string')
-        return { error: INVALID_VALUES };
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
+function removeStructure(params) {
+    const { tournamentRecord, drawDefinition, structureId, event } = params;
+    const checkParams = checkRequiredParameters(params, [{ drawDefinition: true, structureId: true }]);
+    if (checkParams.error)
+        return checkParams;
     const structures = drawDefinition.structures ?? [];
-    const removedStructureIds = [];
     const structure = structures.find((structure) => structure.structureId === structureId);
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
-    const structureMatchUps = getAllStructureMatchUps({ structure }).matchUps;
-    const scoresPresent = structureMatchUps.some(({ score }) => checkScoreHasValue({ score }));
+    const mainStageSequence1 = structures.find(({ stage, stageSequence }) => stage === MAIN && stageSequence === 1);
+    const isMainStageSequence1 = structureId === mainStageSequence1?.structureId;
+    const qualifyingStructureIds = structures.filter(({ stage }) => stage === QUALIFYING).map(xa('structureId'));
+    if (isMainStageSequence1 && !qualifyingStructureIds.length)
+        return { error: CANNOT_REMOVE_MAIN_STRUCTURE };
+    const isQualifyingStructure = qualifyingStructureIds.includes(structureId);
+    const policyResult = policyCheck({ isQualifyingStructure, structure, ...params });
+    if (policyResult?.error)
+        return policyResult;
+    const { structureIdsToRemove, relatedStructureIdsMap } = getIdsToRemove({
+        qualifyingStructureIds,
+        isQualifyingStructure,
+        isMainStageSequence1,
+        mainStageSequence1,
+        drawDefinition,
+        structureId,
+    });
+    const { removedMatchUpIds, removedStructureIds } = removeMatchUpsAndStructures({
+        relatedStructureIdsMap,
+        qualifyingStructureIds,
+        isMainStageSequence1,
+        mainStageSequence1,
+        drawDefinition,
+        structureIdsToRemove,
+        structureId,
+    });
+    removeReferencesToRemovedMatchUps({ removedMatchUpIds, drawDefinition });
+    if (isMainStageSequence1) {
+        const mainStageSequence1MatchUpIds = (mainStageSequence1.matchUps ?? [])?.map(xa('matchUpId'));
+        removedMatchUpIds.push(...mainStageSequence1MatchUpIds);
+        mainStageSequence1.positionAssignments = [];
+        mainStageSequence1.seedAssignments = [];
+        mainStageSequence1.matchUps = [];
+        if (mainStageSequence1.extensions) {
+            mainStageSequence1.extensions = [];
+        }
+    }
+    isQualifyingStructure && resequenceStructures({ drawDefinition });
+    deleteMatchUpsNotice({
+        tournamentId: tournamentRecord?.tournamentId,
+        matchUpIds: removedMatchUpIds,
+        action: 'removeStructure',
+        eventId: event?.eventId,
+        drawDefinition,
+    });
+    modifyDrawNotice({ drawDefinition, eventId: event?.eventId });
+    return { ...SUCCESS, removedMatchUpIds, removedStructureIds };
+}
+function policyCheck({ isQualifyingStructure, tournamentRecord, drawDefinition, structureId, structure, event, force, }) {
+    const structureIdsToFilter = [structureId];
+    if (isQualifyingStructure) {
+        const getSourceLink = (structureId) => drawDefinition.links?.find((link) => link.target.structureId === structureId);
+        let sourceStructureId = getSourceLink(structureId)?.source.structureId;
+        while (sourceStructureId) {
+            structureIdsToFilter.push(sourceStructureId);
+            sourceStructureId = getSourceLink(sourceStructureId)?.source.structureId;
+        }
+    }
+    const relevantMatchUps = getAllDrawMatchUps({
+        matchUpFilters: { structureIds: structureIdsToFilter },
+        drawDefinition,
+    }).matchUps;
+    const scoresPresent = relevantMatchUps?.some(({ score }) => checkScoreHasValue({ score }));
     if (scoresPresent) {
         const appliedPolicies = getAppliedPolicies({
             tournamentRecord,
@@ -17729,14 +17874,22 @@ function removeStructure({ tournamentRecord, drawDefinition, structureId, event,
         if (!allowDeletionWithScoresPresent)
             return { error: SCORES_PRESENT };
     }
-    const mainStageSequence1 = structures.find(({ stage, stageSequence }) => stage === MAIN && stageSequence === 1);
-    const isMainStageSequence1 = structureId === mainStageSequence1?.structureId;
-    const qualifyingStructureIds = structures.filter(({ stage }) => stage === QUALIFYING).map(xa('structureId'));
-    if (isMainStageSequence1 && !qualifyingStructureIds.length) {
-        return { error: CANNOT_REMOVE_MAIN_STRUCTURE };
-    }
+    return { ...SUCCESS };
+}
+function removeReferencesToRemovedMatchUps({ removedMatchUpIds, drawDefinition }) {
+    const { matchUps } = getAllDrawMatchUps({ drawDefinition });
+    matchUps?.forEach((matchUp) => {
+        if (matchUp.winnerMatchUpId && removedMatchUpIds.includes(matchUp.winnerMatchUpId)) {
+            delete matchUp.winnerMatchUpId;
+        }
+        if (matchUp.loserMatchUpId && removedMatchUpIds.includes(matchUp.loserMatchUpId)) {
+            delete matchUp.loserMatchUpId;
+        }
+    });
+}
+function getIdsToRemove({ qualifyingStructureIds, isQualifyingStructure, isMainStageSequence1, mainStageSequence1, drawDefinition, structureId, }) {
+    const structures = drawDefinition.structures ?? [];
     const structureIds = structures.map(xa('structureId'));
-    const removedMatchUpIds = [];
     const getTargetedStructureIds = (structureId) => drawDefinition.links
         ?.map((link) => link.source.structureId === structureId &&
         link.target.structureId !== mainStageSequence1?.structureId &&
@@ -17747,66 +17900,64 @@ function removeStructure({ tournamentRecord, drawDefinition, structureId, event,
         link.target.structureId === structureId &&
         link.source.structureId)
         .filter(Boolean) ?? [];
-    const isQualifyingStructure = qualifyingStructureIds.includes(structureId);
     const relatedStructureIdsMap = new Map();
     structureIds.forEach((id) => relatedStructureIdsMap.set(id, isQualifyingStructure
         ? getQualifyingSourceStructureIds(id)
         : getTargetedStructureIds(id)));
-    const idsToRemove = isMainStageSequence1 ? relatedStructureIdsMap.get(structureId) : [structureId];
-    while (idsToRemove?.length) {
-        const idBeingRemoved = idsToRemove.pop();
-        const { structure } = findStructure({
-            structureId: idBeingRemoved,
+    const structureIdsToRemove = isMainStageSequence1 ? relatedStructureIdsMap.get(structureId) : [structureId];
+    return { structureIdsToRemove, relatedStructureIdsMap };
+}
+function removeMatchUpsAndStructures({ relatedStructureIdsMap, qualifyingStructureIds, isMainStageSequence1, mainStageSequence1, drawDefinition, structureIdsToRemove, structureId, }) {
+    const removedStructureIds = [];
+    const removedMatchUpIds = [];
+    while (structureIdsToRemove?.length) {
+        const idBeingRemoved = structureIdsToRemove.pop();
+        removedMatchUpIds.push(...getRemovedMatchUpIds({ idBeingRemoved, drawDefinition }));
+        const result = pruneLinksAndStructures({
+            qualifyingStructureIds,
+            isMainStageSequence1,
+            idBeingRemoved,
             drawDefinition,
+            structureId,
+        });
+        removedStructureIds.push(...result.removedStructureIds);
+        const targetedStructureIds = getTargetedStructureIds({
+            relatedStructureIdsMap,
+            mainStageSequence1,
+            idBeingRemoved,
+            structureId,
         });
-        const matchUps = getAllStructureMatchUps({ structure }).matchUps;
-        const matchUpIds = getMatchUpIds(matchUps);
-        removedMatchUpIds.push(...matchUpIds);
-        drawDefinition.links =
-            drawDefinition.links?.filter((link) => link.source.structureId !== idBeingRemoved && link.target.structureId !== idBeingRemoved) ?? [];
-        if (!isMainStageSequence1 ||
-            (isMainStageSequence1 && qualifyingStructureIds.length) ||
-            idBeingRemoved !== structureId) {
-            drawDefinition.structures = (drawDefinition.structures ?? []).filter((structure) => {
-                if (idBeingRemoved && idBeingRemoved === structure.structureId)
-                    removedStructureIds.push(idBeingRemoved);
-                return structure.structureId !== idBeingRemoved;
-            });
-        }
-        const targetedStructureIds = idBeingRemoved &&
-            relatedStructureIdsMap.get(idBeingRemoved)?.filter((id) => id !== mainStageSequence1?.structureId || structureId === mainStageSequence1.structureId);
         if (targetedStructureIds?.length)
-            idsToRemove.push(...targetedStructureIds);
+            structureIdsToRemove.push(...targetedStructureIds);
     }
-    const { matchUps } = getAllDrawMatchUps({ drawDefinition });
-    matchUps?.forEach((matchUp) => {
-        if (matchUp.winnerMatchUpId && removedMatchUpIds.includes(matchUp.winnerMatchUpId)) {
-            delete matchUp.winnerMatchUpId;
-        }
-        if (matchUp.loserMatchUpId && removedMatchUpIds.includes(matchUp.loserMatchUpId)) {
-            delete matchUp.loserMatchUpId;
-        }
-    });
-    if (isMainStageSequence1) {
-        const mainStageSequence1MatchUpIds = (mainStageSequence1.matchUps ?? [])?.map(xa('matchUpId'));
-        removedMatchUpIds.push(...mainStageSequence1MatchUpIds);
-        mainStageSequence1.positionAssignments = [];
-        mainStageSequence1.seedAssignments = [];
-        mainStageSequence1.matchUps = [];
-        if (mainStageSequence1.extensions) {
-            mainStageSequence1.extensions = [];
-        }
+    return { removedMatchUpIds, removedStructureIds };
+}
+function getTargetedStructureIds({ idBeingRemoved, relatedStructureIdsMap, mainStageSequence1, structureId }) {
+    return (idBeingRemoved &&
+        relatedStructureIdsMap.get(idBeingRemoved)?.filter((id) => id !== mainStageSequence1?.structureId || structureId === mainStageSequence1.structureId));
+}
+function pruneLinksAndStructures({ qualifyingStructureIds, isMainStageSequence1, idBeingRemoved, drawDefinition, structureId, }) {
+    const removedStructureIds = [];
+    drawDefinition.links =
+        drawDefinition.links?.filter((link) => link.source.structureId !== idBeingRemoved && link.target.structureId !== idBeingRemoved) ?? [];
+    if (!isMainStageSequence1 ||
+        (isMainStageSequence1 && qualifyingStructureIds.length) ||
+        idBeingRemoved !== structureId) {
+        drawDefinition.structures = (drawDefinition.structures ?? []).filter((structure) => {
+            if (idBeingRemoved && idBeingRemoved === structure.structureId)
+                removedStructureIds.push(idBeingRemoved);
+            return structure.structureId !== idBeingRemoved;
+        });
     }
-    isQualifyingStructure && resequenceStructures({ drawDefinition });
-    deleteMatchUpsNotice({
-        tournamentId: tournamentRecord?.tournamentId,
-        matchUpIds: removedMatchUpIds,
-        action: 'removeStructure',
-        eventId: event?.eventId,
+    return { removedStructureIds };
+}
+function getRemovedMatchUpIds({ idBeingRemoved, drawDefinition }) {
+    const { structure } = findStructure({
+        structureId: idBeingRemoved,
         drawDefinition,
     });
-    modifyDrawNotice({ drawDefinition, eventId: event?.eventId });
-    return { ...SUCCESS, removedMatchUpIds, removedStructureIds };
+    const matchUps = getAllStructureMatchUps({ structure }).matchUps;
+    return getMatchUpIds(matchUps);
 }
 
 function setStageDrawSize({ stageSequence = 1, drawDefinition, drawSize, stage }) {
@@ -23206,6 +23357,8 @@ var mutate$c = {
     setPositionAssignments: setPositionAssignments,
     setStructureOrder: setStructureOrder,
     setSubOrder: setSubOrder,
+    shiftAdHocRounds: shiftAdHocRounds,
+    swapAdHocRounds: swapAdHocRounds,
     swapDrawPositionAssignments: swapDrawPositionAssignments,
     updateTeamLineUp: updateTeamLineUp,
     withdrawParticipantAtDrawPosition: withdrawParticipantAtDrawPosition
@@ -25913,6 +26066,462 @@ function generateDrawTypeAndModifyDrawDefinition(params) {
     };
 }
 
+function getParticipantScaleItem(params) {
+    const { tournamentRecord, scaleAttributes, participantId } = params;
+    const tournamentRecords = params.tournamentRecords ||
+        (tournamentRecord && {
+            [tournamentRecord.tournamentId]: tournamentRecord,
+        }) ||
+        {};
+    if (!participantId)
+        return { error: MISSING_PARTICIPANT_ID };
+    const { participant, tournamentId } = findTournamentParticipant({
+        tournamentRecords,
+        tournamentRecord,
+        participantId,
+    });
+    if (!participant)
+        return { error: PARTICIPANT_NOT_FOUND };
+    return {
+        ...participantScaleItem({ participant, scaleAttributes }),
+        tournamentId,
+    };
+}
+
+function setParticipantScaleItem(params) {
+    const { removePriorValues, tournamentRecord, participantId, scaleItem } = params;
+    let equivalentValue, participant;
+    if (!isValidScaleItem({ scaleItem }))
+        return { error: INVALID_SCALE_ITEM };
+    if (participantId && Array.isArray(tournamentRecord.participants)) {
+        participant = tournamentRecord.participants.find((participant) => participant.participantId === participantId);
+        if (participant) {
+            const result = addParticipantScaleItem({
+                removePriorValues,
+                participant,
+                scaleItem,
+            });
+            if (result.error)
+                return result;
+            equivalentValue = !result.valueChanged;
+            const { topics } = getTopics();
+            if (topics.includes(MODIFY_PARTICIPANTS)) {
+                addNotice({
+                    topic: MODIFY_PARTICIPANTS,
+                    payload: {
+                        tournamentId: tournamentRecord.tournamentId,
+                        participants: [participant],
+                    },
+                });
+            }
+        }
+    }
+    return ((equivalentValue && {
+        ...SUCCESS,
+        info: VALUE_UNCHANGED,
+        existingValue: scaleItem?.scaleValue,
+    }) ||
+        (participant && { ...SUCCESS, newValue: scaleItem?.scaleValue }) || {
+        error: PARTICIPANT_NOT_FOUND,
+    });
+}
+function setParticipantScaleItems(params) {
+    const { scaleItemsWithParticipantIds = [], removePriorValues, tournamentRecord, auditData, context } = params;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!tournamentRecord.participants)
+        return { error: MISSING_PARTICIPANTS };
+    let modificationsApplied = 0;
+    const participantScaleItemsMap = {};
+    const modifiedParticipants = [];
+    for (const item of scaleItemsWithParticipantIds) {
+        const participantId = item?.participantId;
+        if (Array.isArray(item?.scaleItems)) {
+            for (const scaleItem of item.scaleItems) {
+                if (isValidScaleItem({ scaleItem })) {
+                    if (!Array.isArray(participantScaleItemsMap[participantId])) {
+                        participantScaleItemsMap[participantId] = [];
+                    }
+                    participantScaleItemsMap[participantId].push(scaleItem);
+                }
+                else {
+                    return { error: INVALID_SCALE_ITEM };
+                }
+            }
+        }
+    }
+    tournamentRecord.participants.forEach((participant) => {
+        const { participantId } = participant || {};
+        if (Array.isArray(participantScaleItemsMap[participantId])) {
+            participantScaleItemsMap[participantId].forEach((scaleItem) => {
+                addParticipantScaleItem({ participant, scaleItem, removePriorValues });
+                modifiedParticipants.push(participant);
+                modificationsApplied++;
+            });
+        }
+    });
+    const info = !modificationsApplied ? NO_MODIFICATIONS_APPLIED : undefined;
+    const { topics } = getTopics();
+    if (topics.includes(MODIFY_PARTICIPANTS) && modificationsApplied) {
+        addNotice({
+            topic: MODIFY_PARTICIPANTS,
+            payload: {
+                tournamentId: tournamentRecord.tournamentId,
+                participants: modifiedParticipants,
+            },
+        });
+    }
+    if (context) {
+        const { eventId, drawId, ...itemValue } = context;
+        const itemSubTypes = itemValue.scaleAttributes?.scaleType && [itemValue.scaleAttributes.scaleType];
+        if (Object.keys(itemValue).length) {
+            const timeItem = {
+                itemType: ADD_SCALE_ITEMS,
+                itemValue,
+            };
+            if (itemSubTypes)
+                timeItem.itemSubTypes = itemSubTypes;
+            if (drawId || eventId) {
+                const { drawDefinition, event } = findEvent({
+                    tournamentRecord,
+                    eventId,
+                    drawId,
+                });
+                if (drawId) {
+                    addDrawDefinitionTimeItem({ drawDefinition, timeItem });
+                }
+                if (eventId) {
+                    addEventTimeItem({ event, timeItem });
+                }
+            }
+            else {
+                addTournamentTimeItem({ tournamentRecord, timeItem });
+            }
+        }
+    }
+    if (auditData && topics.includes(AUDIT)) {
+        addNotice({ topic: AUDIT, payload: auditData });
+    }
+    return definedAttributes({ ...SUCCESS, modificationsApplied, info });
+}
+function isValidScaleItem({ scaleItem }) {
+    const scaleItemAttributes = scaleItem && Object.keys(scaleItem);
+    const requiredAttributes = ['scaleType', 'eventType', 'scaleName'];
+    const validScaleItem = requiredAttributes.filter((attribute) => scaleItemAttributes?.includes(attribute)).length ===
+        requiredAttributes.length;
+    return !!validScaleItem;
+}
+function addParticipantScaleItem({ removePriorValues, participant, scaleItem }) {
+    if (!participant) {
+        return { error: MISSING_PARTICIPANT };
+    }
+    const scaleItemAttributes = scaleItem && Object.keys(scaleItem);
+    const requiredAttributes = ['scaleType', 'eventType', 'scaleName'];
+    const validScaleItem = requiredAttributes.filter((attribute) => scaleItemAttributes.includes(attribute) && scaleItem[attribute]).length ===
+        requiredAttributes.length;
+    if (!validScaleItem)
+        return { error: INVALID_SCALE_ITEM };
+    const createdAt = new Date().toISOString();
+    if (!participant.timeItems)
+        participant.timeItems = [];
+    const { scaleItem: existingScaleItem } = participantScaleItem({
+        scaleAttributes: scaleItem,
+        participant,
+    });
+    const isUndefined = (value) => [undefined, null, ''].includes(value);
+    const valueChanged = !(isUndefined(existingScaleItem?.scaleValue) && isUndefined(scaleItem.scaleValue)) &&
+        JSON.stringify(existingScaleItem?.scaleValue) !== JSON.stringify(scaleItem.scaleValue);
+    if (valueChanged) {
+        const { scaleType, eventType, scaleName } = scaleItem;
+        const itemType = [SCALE$1, scaleType, eventType, scaleName].join('.');
+        const timeItem = definedAttributes({
+            itemValue: scaleItem.scaleValue,
+            itemDate: scaleItem.scaleDate,
+            createdAt,
+            itemType,
+        });
+        if (scaleItem.scaleId) {
+            timeItem.itemSubTypes = [scaleItem.scaleId];
+        }
+        if (removePriorValues) {
+            participant.timeItems = participant.timeItems.filter((timeItem) => timeItem.itemType !== itemType);
+        }
+        participant.timeItems.push(timeItem);
+    }
+    return { ...SUCCESS, valueChanged, newValue: scaleItem.scaleValue };
+}
+
+const ELO = 'ELO';
+const NTRP = 'NTRP';
+const TRN = 'TRN';
+const UTR = 'UTR';
+const WTN = 'WTN';
+const ratingConstants = {
+    ELO,
+    NTRP,
+    TRN,
+    UTR,
+    WTN,
+};
+
+const ratingsParameters = {
+    [ELO]: {
+        defaultInitialization: 1500,
+        decimalsCount: 0,
+        range: [0, 3000],
+        ascending: true,
+    },
+    [NTRP]: {
+        accessors: ['ntrpRating', 'dntrpRatingHundredths'],
+        attributes: { ustaRatingType: '' },
+        accessor: 'dntrpRatingHundredths',
+        defaultInitialization: 3,
+        decimalsCount: 1,
+        ascending: true,
+        range: [1, 7],
+    },
+    [UTR]: {
+        defaultInitialization: 6,
+        accessors: ['utrRating'],
+        accessor: 'utrRating',
+        decimalsCount: 2,
+        ascending: true,
+        range: [1, 16],
+    },
+    [WTN]: {
+        attributes: { confidence: { generator: true, range: [60, 100] } },
+        accessors: ['wtnRating', 'confidence'],
+        defaultInitialization: 23,
+        accessor: 'wtnRating',
+        ascending: false,
+        decimalsCount: 2,
+        range: [40, 1],
+    },
+};
+
+const k538 = (countables) => 250 / Math.pow(countables + 5, 0.4);
+const kDefault = () => 1;
+function kSet(maxCountables = 3, counted = 2) {
+    const kset = maxCountables / counted;
+    return isNaN(kset) ? eloConfig.kDefault() : kset;
+}
+const eloConfig = {
+    nSpread: 400,
+    diffThreshold: 0.125,
+    kCalc: k538,
+    kMultiplier: kSet,
+    kDefault,
+};
+function calculateNewRatings(params) {
+    let { winnerRating, loserRating, ratingRange } = params;
+    const { ratings = ratingsParameters, winnerCountables = 1, loserCountables = 0, ratingType = ELO, maxCountables, countables, } = params || {};
+    const ratingParameters = ratings?.[ratingType];
+    if (!ratingParameters)
+        return { error: MISSING_VALUE };
+    ratingRange = ratingParameters.range || ratingRange;
+    winnerRating = winnerRating || ratingParameters.defaultInitialization;
+    loserRating = loserRating || ratingParameters.defaultInitialization;
+    const invertedScale = ratingRange[0] > ratingRange[1];
+    const decimalPlaces = ratingParameters.decimalsCount || 0;
+    const consideredRange = invertedScale ? ratingRange.slice().reverse() : ratingRange;
+    const inRange = (range, value) => parseFloat(value) >= Math.min(...range) && parseFloat(value) <= Math.max(...range);
+    if (!inRange(ratingRange, winnerRating) || !inRange(ratingRange, loserRating)) {
+        if (!inRange(ratingRange, winnerRating))
+            winnerRating = ratingParameters.defaultInitialization;
+        if (!inRange(ratingRange, loserRating))
+            loserRating = ratingParameters.defaultInitialization;
+    }
+    const convertRange = ({ value, sourceRange, targetRange }) => ((value - sourceRange[0]) * (targetRange[1] - targetRange[0])) / (sourceRange[1] - sourceRange[0]) + targetRange[0];
+    const convertedWinnerRating = convertRange({
+        targetRange: ratingsParameters[ELO].range,
+        sourceRange: consideredRange,
+        value: invertedScale ? ratingRange[0] - winnerRating : winnerRating,
+    });
+    const convertedLoserRating = convertRange({
+        targetRange: ratingsParameters[ELO].range,
+        sourceRange: consideredRange,
+        value: invertedScale ? ratingRange[0] - loserRating : loserRating,
+    });
+    const getExpectation = (playerRating, opponentRating) => 1 / (1 + Math.pow(10, (opponentRating - playerRating) / eloConfig.nSpread));
+    const winnerExpectation = getExpectation(convertedWinnerRating, convertedLoserRating);
+    const loserExpectation = getExpectation(convertedLoserRating, convertedWinnerRating);
+    const winnerKValue = eloConfig.kCalc(winnerCountables);
+    const loserKValue = eloConfig.kCalc(loserCountables);
+    const k = eloConfig.kMultiplier(maxCountables, countables);
+    const winnerUpdatedConvertedRating = convertedWinnerRating + k * winnerKValue * (1 - winnerExpectation);
+    const loserUpdatedConvertedRating = convertedLoserRating + k * loserKValue * (0 - loserExpectation);
+    const convertedUpdatedWinnerRating = convertRange({
+        sourceRange: ratingsParameters[ELO].range,
+        value: winnerUpdatedConvertedRating,
+        targetRange: consideredRange,
+    });
+    const convertedUpdatedLoserRating = convertRange({
+        sourceRange: ratingsParameters[ELO].range,
+        value: loserUpdatedConvertedRating,
+        targetRange: consideredRange,
+    });
+    const updatedWinnerRating = invertedScale
+        ? ratingRange[0] - convertedUpdatedWinnerRating
+        : convertedUpdatedWinnerRating;
+    let newWinnerRating = parseFloat(parseFloat(updatedWinnerRating).toFixed(decimalPlaces));
+    const updatedLoserRating = invertedScale ? ratingRange[0] - convertedUpdatedLoserRating : convertedUpdatedLoserRating;
+    let newLoserRating = parseFloat(parseFloat(updatedLoserRating).toFixed(decimalPlaces));
+    const percentageDifference = Math.max(...ratingRange)
+        ? Math.abs(winnerRating - loserRating) / Math.max(...ratingRange)
+        : 0;
+    if ((convertedUpdatedWinnerRating > convertedUpdatedLoserRating && percentageDifference > eloConfig.diffThreshold) ||
+        newWinnerRating < 0 ||
+        newLoserRating < 0) {
+        newWinnerRating = winnerRating;
+        newLoserRating = loserRating;
+    }
+    return { newWinnerRating, newLoserRating };
+}
+
+const aggregateSets = (sets) => {
+    return (sets?.reduce((aggregate, set) => {
+        if (set.winningSide)
+            aggregate[set.winningSide - 1] += 1;
+        return aggregate;
+    }, [0, 0]) || [0, 0]);
+};
+
+function generateDynamicRatings(params) {
+    const { removePriorValues = true, tournamentRecord, ratingType = ELO, considerGames, matchUpIds, asDynamic } = params;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    if (!Array.isArray(matchUpIds))
+        return { error: MISSING_MATCHUPS };
+    if (typeof ratingType !== 'string')
+        return { error: INVALID_VALUES, ratingType };
+    if (!ratingsParameters[ratingType])
+        return { error: INVALID_VALUES };
+    const ratingParameter = ratingsParameters[ratingType];
+    const { accessor } = ratingParameter;
+    const modifiedScaleValues = {};
+    const matchUps = params.matchUps ??
+        allTournamentMatchUps({
+            matchUpFilters: { matchUpIds, matchUpStatuses: completedMatchUpStatuses },
+            tournamentRecord,
+            inContext: true,
+        }).matchUps ??
+        [];
+    matchUps.sort(matchUpSort);
+    for (const matchUp of matchUps) {
+        const { endDate, matchUpFormat, score, sides, winningSide } = matchUp;
+        const matchUpType = matchUp.matchUpType;
+        const scaleAttributes = {
+            eventType: matchUpType,
+            scaleName: ratingType,
+            scaleType: RATING$1,
+        };
+        const dynamicScaleName = `${ratingType}.${DYNAMIC}`;
+        const dynamicScaleAttributes = {
+            scaleName: dynamicScaleName,
+            eventType: matchUpType,
+            scaleType: RATING$1,
+        };
+        const sideParticipantIds = Object.assign({}, ...(sides ?? []).map((side) => {
+            const { sideNumber, participant } = side;
+            return (sideNumber && {
+                [sideNumber]: [participant?.participantId, ...(participant?.individualParticipantIds ?? [])]
+                    .filter(Boolean)
+                    .flat(),
+            });
+        }));
+        const outputScaleName = asDynamic ? dynamicScaleName : ratingType;
+        const scaleItemMap = Object.assign({}, ...Object.values(sideParticipantIds)
+            .flat()
+            .map((participantId) => {
+            const { scaleItem: dynamicScaleItem } = getParticipantScaleItem({
+                scaleAttributes: dynamicScaleAttributes,
+                tournamentRecord,
+                participantId,
+            });
+            const { scaleItem } = getParticipantScaleItem({
+                tournamentRecord,
+                scaleAttributes,
+                participantId,
+            });
+            const scaleValue = accessor ? { [accessor]: undefined } : undefined;
+            return (participantId && {
+                [participantId]: dynamicScaleItem ??
+                    scaleItem ?? {
+                    scaleName: outputScaleName,
+                    eventType: matchUpType,
+                    scaleDate: endDate,
+                    scaleType: RATING$1,
+                    scaleValue,
+                },
+            });
+        }));
+        const parsedFormat = matchUpFormat ? parse(matchUpFormat) : {};
+        const bestOf = parsedFormat?.bestOf || 1;
+        const setsTo = parsedFormat?.setsTo || 1;
+        const maxCountables = considerGames ? bestOf & setsTo : bestOf;
+        const countables = (score?.sets && aggregateSets(score.sets)) || (winningSide === 1 && [1, 0]) || [0, 1];
+        const winningSideParticipantIds = winningSide ? sideParticipantIds[winningSide] : [];
+        const losingSideParticipantIds = winningSide ? sideParticipantIds[3 - winningSide] : [];
+        for (const winnerParticipantId of winningSideParticipantIds) {
+            const winnerScaleValue = scaleItemMap[winnerParticipantId]?.scaleValue;
+            const winnerRating = typeof winnerScaleValue === 'object' ? winnerScaleValue[accessor] : winnerScaleValue;
+            for (const loserParticipantId of losingSideParticipantIds) {
+                const loserScaleValue = scaleItemMap[loserParticipantId]?.scaleValue;
+                const loserRating = typeof loserScaleValue === 'object' ? loserScaleValue[accessor] : loserScaleValue;
+                const winnerCountables = winningSide ? countables[winningSide] : [0, 0];
+                const loserCountables = winningSide ? countables[3 - winningSide] : [0, 0];
+                const { newWinnerRating, newLoserRating } = calculateNewRatings({
+                    winnerCountables,
+                    loserCountables,
+                    maxCountables,
+                    winnerRating,
+                    loserRating,
+                    ratingType,
+                });
+                const newWinnerScaleValue = accessor
+                    ? {
+                        ...winnerScaleValue,
+                        [accessor]: newWinnerRating,
+                    }
+                    : newWinnerRating;
+                const newLoserScaleValue = accessor
+                    ? {
+                        ...loserScaleValue,
+                        [accessor]: newLoserRating,
+                    }
+                    : newLoserRating;
+                scaleItemMap[winnerParticipantId].scaleValue = newWinnerScaleValue;
+                scaleItemMap[loserParticipantId].scaleValue = newLoserScaleValue;
+                let result = setParticipantScaleItem({
+                    participantId: winnerParticipantId,
+                    removePriorValues,
+                    tournamentRecord,
+                    scaleItem: {
+                        ...scaleItemMap[winnerParticipantId],
+                        scaleName: outputScaleName,
+                    },
+                });
+                if (result.error)
+                    return result;
+                result = setParticipantScaleItem({
+                    participantId: loserParticipantId,
+                    removePriorValues,
+                    tournamentRecord,
+                    scaleItem: {
+                        ...scaleItemMap[loserParticipantId],
+                        scaleName: outputScaleName,
+                    },
+                });
+                if (result.error)
+                    return result;
+            }
+        }
+        Object.assign(modifiedScaleValues, scaleItemMap);
+    }
+    const processedMatchUpIds = matchUps.map(({ matchUpId }) => matchUpId);
+    return { ...SUCCESS, modifiedScaleValues, processedMatchUpIds };
+}
+
 function generateAdHocMatchUps(params) {
     const { matchUpIds = [], drawDefinition, roundNumber, newRound, isMock, event } = params;
     if (typeof drawDefinition !== 'object')
@@ -26150,54 +26759,6 @@ function getParticipantPairingValues({ possiblePairings, valueObjects }) {
     return { pairingValues };
 }
 
-const ELO = 'ELO';
-const NTRP = 'NTRP';
-const TRN = 'TRN';
-const UTR = 'UTR';
-const WTN = 'WTN';
-const ratingConstants = {
-    ELO,
-    NTRP,
-    TRN,
-    UTR,
-    WTN,
-};
-
-const ratingsParameters = {
-    [ELO]: {
-        defaultInitialization: 1500,
-        decimalsCount: 0,
-        range: [0, 3000],
-        ascending: true,
-    },
-    [NTRP]: {
-        accessors: ['ntrpRating', 'dntrpRatingHundredths'],
-        attributes: { ustaRatingType: '' },
-        accessor: 'dntrpRatingHundredths',
-        defaultInitialization: 3,
-        decimalsCount: 1,
-        ascending: true,
-        range: [1, 7],
-    },
-    [UTR]: {
-        defaultInitialization: 6,
-        accessors: ['utrRating'],
-        accessor: 'utrRating',
-        decimalsCount: 2,
-        ascending: true,
-        range: [1, 16],
-    },
-    [WTN]: {
-        attributes: { confidence: { generator: true, range: [60, 100] } },
-        accessors: ['wtnRating', 'confidence'],
-        defaultInitialization: 23,
-        accessor: 'wtnRating',
-        ascending: false,
-        decimalsCount: 2,
-        range: [40, 1],
-    },
-};
-
 const DEFAULT_RATING = 0;
 function getSideRatings({ tournamentParticipants, adHocRatings, eventType, scaleName, pairing }) {
     const defaultRating = ratingsParameters[scaleName]?.defaultInitialization ?? DEFAULT_RATING;
@@ -26259,7 +26820,7 @@ function getPairings({ tournamentParticipants, adHocRatings = {}, possiblePairin
 const ENCOUNTER_VALUE = 100;
 const SAME_TEAM_VALUE = 100;
 const MAX_ITERATIONS = 4000;
-function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValue = SAME_TEAM_VALUE, maxIterations = MAX_ITERATIONS, generateMatchUps = true, ignoreLastRoundNumber, iterationMatchUps, tournamentRecord, participantIds, drawDefinition, adHocRatings, salted = 0.5, roundNumber, structureId, matchUpIds, eventType, structure, scaleName, idPrefix, isMock, event, }) {
+function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValue = SAME_TEAM_VALUE, maxIterations = MAX_ITERATIONS, generateMatchUps = true, ignoreLastRoundNumber, iterationMatchUps, tournamentRecord, dynamicRatings, participantIds, drawDefinition, adHocRatings, salted = 0.5, roundNumber, structureId, matchUpIds, eventType, structure, scaleName, idPrefix, isMock, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure && !structureId)
@@ -26269,12 +26830,26 @@ function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValu
     }
     if (!isObject(structure))
         return { error: MISSING_STRUCTURE };
-    if (!participantIds?.length) {
+    if (!participantIds?.length)
         return { error: MISSING_PARTICIPANT_IDS };
-    }
     const consideredMatchUps = [...(iterationMatchUps ?? []), ...(structure?.matchUps ?? [])];
     const { encounters } = getEncounters({ matchUps: consideredMatchUps });
     const tournamentParticipants = tournamentRecord?.participants ?? [];
+    if (dynamicRatings) {
+        const roundNumbers = unique(structure?.matchUps ? structure.matchUps.map(({ roundNumber }) => roundNumber) : []);
+        const lastRoundNumber = Math.max(...roundNumbers, 0);
+        if (lastRoundNumber) {
+            const matchUpIds = structure?.matchUps
+                ?.filter(({ roundNumber }) => roundNumber === lastRoundNumber)
+                .map(({ matchUpId }) => matchUpId);
+            generateDynamicRatings({
+                ratingType: scaleName || event?.category?.ratingType,
+                tournamentRecord,
+                asDynamic: true,
+                matchUpIds,
+            });
+        }
+    }
     const { valueObjects } = getValueObjects({
         tournamentParticipants,
         encounterValue,
@@ -26630,28 +27205,6 @@ function getParticipantSchedules({ participantFilters = {}, tournamentRecord })
     };
 }
 
-function getParticipantScaleItem(params) {
-    const { tournamentRecord, scaleAttributes, participantId } = params;
-    const tournamentRecords = params.tournamentRecords ||
-        (tournamentRecord && {
-            [tournamentRecord.tournamentId]: tournamentRecord,
-        }) ||
-        {};
-    if (!participantId)
-        return { error: MISSING_PARTICIPANT_ID };
-    const { participant, tournamentId } = findTournamentParticipant({
-        tournamentRecords,
-        tournamentRecord,
-        participantId,
-    });
-    if (!participant)
-        return { error: PARTICIPANT_NOT_FOUND };
-    return {
-        ...participantScaleItem({ participant, scaleAttributes }),
-        tournamentId,
-    };
-}
-
 function getParticipantSignInStatus({ tournamentRecord, participantId }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
@@ -35639,6 +36192,45 @@ function generateAdHocRounds(params) {
     return { matchUps };
 }
 
+function getAdHocRatings(params) {
+    const { tournamentRecord, participantIds, scaleName, eventType, adHocRatings = {} } = params;
+    const scaleAccessor = params.scaleAccessor ?? ratingsParameters[scaleName]?.accessor;
+    const tournamentParticipants = tournamentRecord.participants ?? [];
+    for (const participantId of participantIds ?? []) {
+        const participant = tournamentParticipants?.find((participant) => participant.participantId === participantId);
+        let scaleValue = getScaleValue({
+            scaleName: `${scaleName}.${DYNAMIC}`,
+            participant,
+            eventType,
+        });
+        if (!scaleValue && scaleName) {
+            scaleValue = getScaleValue({
+                scaleAccessor,
+                participant,
+                scaleName,
+                eventType,
+            });
+        }
+        if (scaleValue && !adHocRatings[participantId])
+            adHocRatings[participantId] = scaleValue;
+    }
+    return adHocRatings;
+}
+function getScaleValue({ scaleType = RATING$1, scaleAccessor, participant, scaleName, eventType }) {
+    const scaleAttributes = {
+        eventType: eventType ?? SINGLES_EVENT,
+        scaleType,
+        scaleName,
+    };
+    const result = participant &&
+        participantScaleItem({
+            scaleAttributes,
+            participant,
+        });
+    const scaleValue = result?.scaleItem?.scaleValue;
+    return scaleAccessor && isObject(scaleValue) ? scaleValue[scaleAccessor] : scaleValue;
+}
+
 function drawMatic(params) {
     const paramsCheck = checkParams(params);
     if (paramsCheck?.error)
@@ -35646,7 +36238,7 @@ function drawMatic(params) {
     const idsResult = getParticipantIds(params);
     if (idsResult.error)
         return idsResult;
-    const structureResult = getStructure(params);
+    const structureResult = getAdHocStructure(params);
     if (structureResult.error)
         return structureResult;
     const adHocRatings = getAdHocRatings(params);
@@ -35678,45 +36270,7 @@ function drawMatic(params) {
     }
     return { ...SUCCESS, matchUps, roundResults };
 }
-function getScaleValue({ scaleType = RATING$1, scaleAccessor, participant, scaleName, eventType }) {
-    const scaleAttributes = {
-        eventType: eventType ?? SINGLES_EVENT,
-        scaleType,
-        scaleName,
-    };
-    const result = participant &&
-        participantScaleItem({
-            scaleAttributes,
-            participant,
-        });
-    const scaleValue = result?.scaleItem?.scaleValue;
-    return scaleAccessor && isObject(scaleValue) ? scaleValue[scaleAccessor] : scaleValue;
-}
-function getAdHocRatings(params) {
-    const { tournamentRecord, participantIds, scaleAccessor, scaleName, eventType, adHocRatings = {} } = params;
-    const tournamentParticipants = tournamentRecord.participants ?? [];
-    for (const participantId of participantIds ?? []) {
-        const participant = tournamentParticipants?.find((participant) => participant.participantId === participantId);
-        let scaleValue = getScaleValue({
-            scaleName: `${scaleName}.${DYNAMIC}`,
-            scaleAccessor,
-            participant,
-            eventType,
-        });
-        if (!scaleValue && scaleName) {
-            scaleValue = getScaleValue({
-                scaleAccessor,
-                participant,
-                scaleName,
-                eventType,
-            });
-        }
-        if (scaleValue && !adHocRatings[participantId])
-            adHocRatings[participantId] = scaleValue;
-    }
-    return adHocRatings;
-}
-function getStructure(params) {
+function getAdHocStructure(params) {
     if (params.structureId)
         return params.structureId;
     const drawDefinition = params.drawDefinition;
@@ -35784,17 +36338,18 @@ function generateAdHoc(params) {
     return { ...SUCCESS };
 }
 function automateAdHoc(params) {
-    const { restrictEntryStatus, generateMatchUps, structureId, matchUpIds, scaleName } = params.drawMatic ?? {};
+    const { restrictEntryStatus, generateMatchUps, structureId, matchUpIds, scaleName, scaleAccessor } = params.drawMatic ?? {};
     const result = drawMatic({
         ...params,
         eventType: params.drawMatic?.eventType ?? params.matchUpType,
         generateMatchUps: generateMatchUps ?? true,
+        scaleAccessor: scaleAccessor ?? params.scaleAccessor,
+        scaleName: scaleName ?? params.scaleName,
         participantIds: params.participantIds,
         roundsCount: params.roundsCount,
         restrictEntryStatus,
         structureId,
         matchUpIds,
-        scaleName,
     });
     if (result.error)
         return result;
@@ -36706,6 +37261,8 @@ var index$e = {
     setPositionAssignments: setPositionAssignments,
     setStructureOrder: setStructureOrder,
     setSubOrder: setSubOrder,
+    shiftAdHocRounds: shiftAdHocRounds,
+    swapAdHocRounds: swapAdHocRounds,
     swapDrawPositionAssignments: swapDrawPositionAssignments,
     updateTeamLineUp: updateTeamLineUp,
     withdrawParticipantAtDrawPosition: withdrawParticipantAtDrawPosition
@@ -47172,169 +47729,6 @@ function getStageParticipants({ allUniqueParticipantIds, stageParticipantsCount,
     return { stageParticipants };
 }
 
-function setParticipantScaleItem(params) {
-    const { removePriorValues, tournamentRecord, participantId, scaleItem } = params;
-    let equivalentValue, participant;
-    if (!isValidScaleItem({ scaleItem }))
-        return { error: INVALID_SCALE_ITEM };
-    if (participantId && Array.isArray(tournamentRecord.participants)) {
-        participant = tournamentRecord.participants.find((participant) => participant.participantId === participantId);
-        if (participant) {
-            const result = addParticipantScaleItem({
-                removePriorValues,
-                participant,
-                scaleItem,
-            });
-            if (result.error)
-                return result;
-            equivalentValue = !result.valueChanged;
-            const { topics } = getTopics();
-            if (topics.includes(MODIFY_PARTICIPANTS)) {
-                addNotice({
-                    topic: MODIFY_PARTICIPANTS,
-                    payload: {
-                        tournamentId: tournamentRecord.tournamentId,
-                        participants: [participant],
-                    },
-                });
-            }
-        }
-    }
-    return ((equivalentValue && {
-        ...SUCCESS,
-        info: VALUE_UNCHANGED,
-        existingValue: scaleItem?.scaleValue,
-    }) ||
-        (participant && { ...SUCCESS, newValue: scaleItem?.scaleValue }) || {
-        error: PARTICIPANT_NOT_FOUND,
-    });
-}
-function setParticipantScaleItems(params) {
-    const { scaleItemsWithParticipantIds = [], removePriorValues, tournamentRecord, auditData, context } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!tournamentRecord.participants)
-        return { error: MISSING_PARTICIPANTS };
-    let modificationsApplied = 0;
-    const participantScaleItemsMap = {};
-    const modifiedParticipants = [];
-    for (const item of scaleItemsWithParticipantIds) {
-        const participantId = item?.participantId;
-        if (Array.isArray(item?.scaleItems)) {
-            for (const scaleItem of item.scaleItems) {
-                if (isValidScaleItem({ scaleItem })) {
-                    if (!Array.isArray(participantScaleItemsMap[participantId])) {
-                        participantScaleItemsMap[participantId] = [];
-                    }
-                    participantScaleItemsMap[participantId].push(scaleItem);
-                }
-                else {
-                    return { error: INVALID_SCALE_ITEM };
-                }
-            }
-        }
-    }
-    tournamentRecord.participants.forEach((participant) => {
-        const { participantId } = participant || {};
-        if (Array.isArray(participantScaleItemsMap[participantId])) {
-            participantScaleItemsMap[participantId].forEach((scaleItem) => {
-                addParticipantScaleItem({ participant, scaleItem, removePriorValues });
-                modifiedParticipants.push(participant);
-                modificationsApplied++;
-            });
-        }
-    });
-    const info = !modificationsApplied ? NO_MODIFICATIONS_APPLIED : undefined;
-    const { topics } = getTopics();
-    if (topics.includes(MODIFY_PARTICIPANTS) && modificationsApplied) {
-        addNotice({
-            topic: MODIFY_PARTICIPANTS,
-            payload: {
-                tournamentId: tournamentRecord.tournamentId,
-                participants: modifiedParticipants,
-            },
-        });
-    }
-    if (context) {
-        const { eventId, drawId, ...itemValue } = context;
-        const itemSubTypes = itemValue.scaleAttributes?.scaleType && [itemValue.scaleAttributes.scaleType];
-        if (Object.keys(itemValue).length) {
-            const timeItem = {
-                itemType: ADD_SCALE_ITEMS,
-                itemValue,
-            };
-            if (itemSubTypes)
-                timeItem.itemSubTypes = itemSubTypes;
-            if (drawId || eventId) {
-                const { drawDefinition, event } = findEvent({
-                    tournamentRecord,
-                    eventId,
-                    drawId,
-                });
-                if (drawId) {
-                    addDrawDefinitionTimeItem({ drawDefinition, timeItem });
-                }
-                if (eventId) {
-                    addEventTimeItem({ event, timeItem });
-                }
-            }
-            else {
-                addTournamentTimeItem({ tournamentRecord, timeItem });
-            }
-        }
-    }
-    if (auditData && topics.includes(AUDIT)) {
-        addNotice({ topic: AUDIT, payload: auditData });
-    }
-    return definedAttributes({ ...SUCCESS, modificationsApplied, info });
-}
-function isValidScaleItem({ scaleItem }) {
-    const scaleItemAttributes = scaleItem && Object.keys(scaleItem);
-    const requiredAttributes = ['scaleType', 'eventType', 'scaleName'];
-    const validScaleItem = requiredAttributes.filter((attribute) => scaleItemAttributes?.includes(attribute)).length ===
-        requiredAttributes.length;
-    return !!validScaleItem;
-}
-function addParticipantScaleItem({ removePriorValues, participant, scaleItem }) {
-    if (!participant) {
-        return { error: MISSING_PARTICIPANT };
-    }
-    const scaleItemAttributes = scaleItem && Object.keys(scaleItem);
-    const requiredAttributes = ['scaleType', 'eventType', 'scaleName'];
-    const validScaleItem = requiredAttributes.filter((attribute) => scaleItemAttributes.includes(attribute) && scaleItem[attribute]).length ===
-        requiredAttributes.length;
-    if (!validScaleItem)
-        return { error: INVALID_SCALE_ITEM };
-    const createdAt = new Date().toISOString();
-    if (!participant.timeItems)
-        participant.timeItems = [];
-    const { scaleItem: existingScaleItem } = participantScaleItem({
-        scaleAttributes: scaleItem,
-        participant,
-    });
-    const isUndefined = (value) => [undefined, null, ''].includes(value);
-    const valueChanged = !(isUndefined(existingScaleItem?.scaleValue) && isUndefined(scaleItem.scaleValue)) &&
-        JSON.stringify(existingScaleItem?.scaleValue) !== JSON.stringify(scaleItem.scaleValue);
-    if (valueChanged) {
-        const { scaleType, eventType, scaleName } = scaleItem;
-        const itemType = [SCALE$1, scaleType, eventType, scaleName].join('.');
-        const timeItem = definedAttributes({
-            itemValue: scaleItem.scaleValue,
-            itemDate: scaleItem.scaleDate,
-            createdAt,
-            itemType,
-        });
-        if (scaleItem.scaleId) {
-            timeItem.itemSubTypes = [scaleItem.scaleId];
-        }
-        if (removePriorValues) {
-            participant.timeItems = participant.timeItems.filter((timeItem) => timeItem.itemType !== itemType);
-        }
-        participant.timeItems.push(timeItem);
-    }
-    return { ...SUCCESS, valueChanged, newValue: scaleItem.scaleValue };
-}
-
 const defaultStatusProfile = {
     [WALKOVER$2]: 2,
     [DOUBLE_WALKOVER]: 1,
@@ -55652,7 +56046,7 @@ function JSON2CSV(arrayOfJSON, config) {
                 context?.[columnName] ||
                 '';
             const mappedValue = valuesMap[columnName]?.[value] || value;
-            const fxValue = typeof functionMap[columnName] === 'function' ? functionMap[columnName](mappedValue) : mappedValue;
+            const fxValue = isFunction(functionMap[columnName]) ? functionMap[columnName](mappedValue) : mappedValue;
             columnsMap[columnName] = withDelimiter(fxValue);
             if (fxValue) {
                 columnValueCounts[columnIndex] = (columnValueCounts[columnIndex] || 0) + 1;
@@ -56791,226 +57185,6 @@ const rankingsGovernor = {
     getTournamentPoints,
 };
 
-const k538 = (countables) => 250 / Math.pow(countables + 5, 0.4);
-const kDefault = () => 1;
-function kSet(maxCountables = 3, counted = 2) {
-    const kset = maxCountables / counted;
-    return isNaN(kset) ? eloConfig.kDefault() : kset;
-}
-const eloConfig = {
-    nSpread: 400,
-    diffThreshold: 0.125,
-    kCalc: k538,
-    kMultiplier: kSet,
-    kDefault,
-};
-function calculateNewRatings(params) {
-    let { winnerRating, loserRating, ratingRange } = params;
-    const { ratings = ratingsParameters, winnerCountables = 1, loserCountables = 0, ratingType = ELO, maxCountables, countables, } = params || {};
-    const ratingParameters = ratings?.[ratingType];
-    if (!ratingParameters)
-        return { error: MISSING_VALUE };
-    ratingRange = ratingParameters.range || ratingRange;
-    winnerRating = winnerRating || ratingParameters.defaultInitialization;
-    loserRating = loserRating || ratingParameters.defaultInitialization;
-    const invertedScale = ratingRange[0] > ratingRange[1];
-    const decimalPlaces = ratingParameters.decimalsCount || 0;
-    const consideredRange = invertedScale ? ratingRange.slice().reverse() : ratingRange;
-    const inRange = (range, value) => parseFloat(value) >= Math.min(...range) && parseFloat(value) <= Math.max(...range);
-    if (!inRange(ratingRange, winnerRating) || !inRange(ratingRange, loserRating)) {
-        if (!inRange(ratingRange, winnerRating))
-            winnerRating = ratingParameters.defaultInitialization;
-        if (!inRange(ratingRange, loserRating))
-            loserRating = ratingParameters.defaultInitialization;
-    }
-    const convertRange = ({ value, sourceRange, targetRange }) => ((value - sourceRange[0]) * (targetRange[1] - targetRange[0])) / (sourceRange[1] - sourceRange[0]) + targetRange[0];
-    const convertedWinnerRating = convertRange({
-        targetRange: ratingsParameters[ELO].range,
-        sourceRange: consideredRange,
-        value: invertedScale ? ratingRange[0] - winnerRating : winnerRating,
-    });
-    const convertedLoserRating = convertRange({
-        targetRange: ratingsParameters[ELO].range,
-        sourceRange: consideredRange,
-        value: invertedScale ? ratingRange[0] - loserRating : loserRating,
-    });
-    const getExpectation = (playerRating, opponentRating) => 1 / (1 + Math.pow(10, (opponentRating - playerRating) / eloConfig.nSpread));
-    const winnerExpectation = getExpectation(convertedWinnerRating, convertedLoserRating);
-    const loserExpectation = getExpectation(convertedLoserRating, convertedWinnerRating);
-    const winnerKValue = eloConfig.kCalc(winnerCountables);
-    const loserKValue = eloConfig.kCalc(loserCountables);
-    const k = eloConfig.kMultiplier(maxCountables, countables);
-    const winnerUpdatedConvertedRating = convertedWinnerRating + k * winnerKValue * (1 - winnerExpectation);
-    const loserUpdatedConvertedRating = convertedLoserRating + k * loserKValue * (0 - loserExpectation);
-    const convertedUpdatedWinnerRating = convertRange({
-        sourceRange: ratingsParameters[ELO].range,
-        value: winnerUpdatedConvertedRating,
-        targetRange: consideredRange,
-    });
-    const convertedUpdatedLoserRating = convertRange({
-        sourceRange: ratingsParameters[ELO].range,
-        value: loserUpdatedConvertedRating,
-        targetRange: consideredRange,
-    });
-    const updatedWinnerRating = invertedScale
-        ? ratingRange[0] - convertedUpdatedWinnerRating
-        : convertedUpdatedWinnerRating;
-    let newWinnerRating = parseFloat(parseFloat(updatedWinnerRating).toFixed(decimalPlaces));
-    const updatedLoserRating = invertedScale ? ratingRange[0] - convertedUpdatedLoserRating : convertedUpdatedLoserRating;
-    let newLoserRating = parseFloat(parseFloat(updatedLoserRating).toFixed(decimalPlaces));
-    const percentageDifference = Math.max(...ratingRange)
-        ? Math.abs(winnerRating - loserRating) / Math.max(...ratingRange)
-        : 0;
-    if ((convertedUpdatedWinnerRating > convertedUpdatedLoserRating && percentageDifference > eloConfig.diffThreshold) ||
-        newWinnerRating < 0 ||
-        newLoserRating < 0) {
-        newWinnerRating = winnerRating;
-        newLoserRating = loserRating;
-    }
-    return { newWinnerRating, newLoserRating };
-}
-
-const aggregateSets = (sets) => {
-    return (sets?.reduce((aggregate, set) => {
-        if (set.winningSide)
-            aggregate[set.winningSide - 1] += 1;
-        return aggregate;
-    }, [0, 0]) || [0, 0]);
-};
-
-function generateDynamicRatings({ removePriorValues = true, tournamentRecord, ratingType = ELO, considerGames, matchUpIds, asDynamic, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!Array.isArray(matchUpIds))
-        return { error: MISSING_MATCHUPS };
-    if (typeof ratingType !== 'string')
-        return { error: INVALID_VALUES, ratingType };
-    if (!ratingsParameters[ratingType])
-        return { error: INVALID_VALUES };
-    const ratingParameter = ratingsParameters[ratingType];
-    const { accessor } = ratingParameter;
-    const modifiedScaleValues = {};
-    const matchUps = allTournamentMatchUps({
-        matchUpFilters: { matchUpIds, matchUpStatuses: completedMatchUpStatuses },
-        tournamentRecord,
-        inContext: true,
-    }).matchUps ?? [];
-    matchUps.sort(matchUpSort);
-    for (const matchUp of matchUps) {
-        const { endDate, matchUpFormat, score, sides, winningSide } = matchUp;
-        const matchUpType = matchUp.matchUpType;
-        const scaleAttributes = {
-            eventType: matchUpType,
-            scaleName: ratingType,
-            scaleType: RATING$1,
-        };
-        const dynamicScaleName = `${ratingType}.${DYNAMIC}`;
-        const dynamicScaleAttributes = {
-            scaleName: dynamicScaleName,
-            eventType: matchUpType,
-            scaleType: RATING$1,
-        };
-        const sideParticipantIds = Object.assign({}, ...(sides ?? []).map((side) => {
-            const { sideNumber, participant } = side;
-            return (sideNumber && {
-                [sideNumber]: [participant?.participantId, ...(participant?.individualParticipantIds ?? [])]
-                    .filter(Boolean)
-                    .flat(),
-            });
-        }));
-        const outputScaleName = asDynamic ? dynamicScaleName : ratingType;
-        const scaleItemMap = Object.assign({}, ...Object.values(sideParticipantIds)
-            .flat()
-            .map((participantId) => {
-            const { scaleItem: dynamicScaleItem } = getParticipantScaleItem({
-                scaleAttributes: dynamicScaleAttributes,
-                tournamentRecord,
-                participantId,
-            });
-            const { scaleItem } = getParticipantScaleItem({
-                tournamentRecord,
-                scaleAttributes,
-                participantId,
-            });
-            const scaleValue = accessor ? { [accessor]: undefined } : undefined;
-            return (participantId && {
-                [participantId]: dynamicScaleItem ??
-                    scaleItem ?? {
-                    scaleName: outputScaleName,
-                    eventType: matchUpType,
-                    scaleDate: endDate,
-                    scaleType: RATING$1,
-                    scaleValue,
-                },
-            });
-        }));
-        const parsedFormat = matchUpFormat ? parse(matchUpFormat) : {};
-        const bestOf = parsedFormat?.bestOf || 1;
-        const setsTo = parsedFormat?.setsTo || 1;
-        const maxCountables = considerGames ? bestOf & setsTo : bestOf;
-        const countables = (score?.sets && aggregateSets(score.sets)) || (winningSide === 1 && [1, 0]) || [0, 1];
-        const winningSideParticipantIds = winningSide ? sideParticipantIds[winningSide] : [];
-        const losingSideParticipantIds = winningSide ? sideParticipantIds[3 - winningSide] : [];
-        for (const winnerParticipantId of winningSideParticipantIds) {
-            const winnerScaleValue = scaleItemMap[winnerParticipantId]?.scaleValue;
-            const winnerRating = typeof winnerScaleValue === 'object' ? winnerScaleValue[accessor] : winnerScaleValue;
-            for (const loserParticipantId of losingSideParticipantIds) {
-                const loserScaleValue = scaleItemMap[loserParticipantId]?.scaleValue;
-                const loserRating = typeof loserScaleValue === 'object' ? loserScaleValue[accessor] : loserScaleValue;
-                const winnerCountables = winningSide ? countables[winningSide] : [0, 0];
-                const loserCountables = winningSide ? countables[3 - winningSide] : [0, 0];
-                const { newWinnerRating, newLoserRating } = calculateNewRatings({
-                    winnerCountables,
-                    loserCountables,
-                    maxCountables,
-                    winnerRating,
-                    loserRating,
-                    ratingType,
-                });
-                const newWinnerScaleValue = accessor
-                    ? {
-                        ...winnerScaleValue,
-                        [accessor]: newWinnerRating,
-                    }
-                    : newWinnerRating;
-                const newLoserScaleValue = accessor
-                    ? {
-                        ...loserScaleValue,
-                        [accessor]: newLoserRating,
-                    }
-                    : newLoserRating;
-                scaleItemMap[winnerParticipantId].scaleValue = newWinnerScaleValue;
-                scaleItemMap[loserParticipantId].scaleValue = newLoserScaleValue;
-                let result = setParticipantScaleItem({
-                    participantId: winnerParticipantId,
-                    removePriorValues,
-                    tournamentRecord,
-                    scaleItem: {
-                        ...scaleItemMap[winnerParticipantId],
-                        scaleName: outputScaleName,
-                    },
-                });
-                if (result.error)
-                    return result;
-                result = setParticipantScaleItem({
-                    participantId: loserParticipantId,
-                    removePriorValues,
-                    tournamentRecord,
-                    scaleItem: {
-                        ...scaleItemMap[loserParticipantId],
-                        scaleName: outputScaleName,
-                    },
-                });
-                if (result.error)
-                    return result;
-            }
-        }
-        Object.assign(modifiedScaleValues, scaleItemMap);
-    }
-    const processedMatchUpIds = matchUps.map(({ matchUpId }) => matchUpId);
-    return { ...SUCCESS, modifiedScaleValues, processedMatchUpIds };
-}
-
 const governor = {
     calculateNewRatings,
     generateDynamicRatings,