tods-competition-factory 1.8.4 → 1.8.6

package/dist/index.mjs

@@ -11,9 +11,7 @@ const setTypes$1 = {
 function stringify(matchUpFormatObject, preserveRedundant) {
   if (typeof matchUpFormatObject !== "object")
     return;
-  if (matchUpFormatObject.timed && !isNaN(matchUpFormatObject.minutes))
-    return timedSetFormat(matchUpFormatObject);
-  if (matchUpFormatObject.bestOf && matchUpFormatObject.setFormat)
+  if ((matchUpFormatObject.bestOf || matchUpFormatObject.exactly) && matchUpFormatObject.setFormat)
     return getSetFormat(matchUpFormatObject, preserveRedundant);
   return void 0;
 }
@@ -29,11 +27,13 @@ function timedSetFormat(matchUpFormatObject) {
   return value;
 }
 function getSetFormat(matchUpFormatObject, preserveRedundant) {
-  const bestOfValue = getNumber$1(matchUpFormatObject.bestOf);
-  if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && bestOfValue === 1) {
+  const bestOfValue = getNumber$1(matchUpFormatObject.bestOf) || void 0;
+  const exactly = getNumber$1(matchUpFormatObject.exactly) || void 0;
+  const setLimit = bestOfValue || exactly;
+  if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
     return timedSetFormat(matchUpFormatObject.setFormat);
   }
-  const bestOfCode = bestOfValue && `${SET}${bestOfValue}` || "";
+  const setLimitCode = setLimit && `${SET}${setLimit}` || "";
   const setCountValue = stringifySet(
     matchUpFormatObject.setFormat,
     preserveRedundant
@@ -43,11 +43,11 @@ function getSetFormat(matchUpFormatObject, preserveRedundant) {
     matchUpFormatObject.finalSetFormat,
     preserveRedundant
   );
-  const finalSetCode = bestOfValue && bestOfValue > 1 && finalSetCountValue && setCountValue !== finalSetCountValue && // don't include final set code if equivalent to other sets
+  const finalSetCode = setLimit && setLimit > 1 && finalSetCountValue && setCountValue !== finalSetCountValue && // don't include final set code if equivalent to other sets
   `F:${finalSetCountValue}` || "";
-  const valid = bestOfCode && setCountValue;
+  const valid = setLimitCode && setCountValue;
   if (valid) {
-    return [bestOfCode, setCode, finalSetCode].filter((f) => f).join("-");
+    return [setLimitCode, setCode, finalSetCode].filter((f) => f).join("-");
   }
   return void 0;
 }
@@ -171,231 +171,6 @@ function skewedDistribution(min, max, skew, step, significantDecimals = 2) {
   return parseFloat(num.toFixed(significantDecimals));
 }
 
-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 (parsedFormat.setFormat)
-        return parsedFormat;
-    }
-    if (type === SET)
-      return setsMatch(matchUpFormatCode);
-  }
-  return void 0;
-}
-function setsMatch(formatstring) {
-  const parts = formatstring.split("-");
-  const bestOf = getNumber(parts[0].slice(3));
-  const setFormat = parts && parseSetFormat(parts[1]);
-  const finalSetFormat = parts && parseSetFormat(parts[2]);
-  const validBestOf = bestOf && bestOf < 6;
-  const validFinalSet = !parts[2] || finalSetFormat;
-  const validSetsFormat = setFormat;
-  const result = { bestOf, setFormat };
-  if (finalSetFormat)
-    result.finalSetFormat = finalSetFormat;
-  if (validBestOf && 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.indexOf("TB") === 0;
-      if (isTiebreakSet) {
-        const tiebreakSet = parseTiebreakFormat(setFormatString);
-        if (tiebreakSet === false)
-          return false;
-        return typeof tiebreakSet === "object" ? { tiebreakSet } : void 0;
-      }
-      const timedSet = setFormatString.indexOf("T") === 0;
-      if (timedSet)
-        return parseTimedSet(setFormatString);
-      const parts2 = formatstring.match(/^[FS]:(\d+)([A-Za-z]*)/);
-      const NoAD = parts2 && isNoAD(parts2[2]) || false;
-      const validNoAD = !parts2?.[2] || NoAD;
-      const setTo = parts2 ? getNumber(parts2[1]) : void 0;
-      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 void 0;
-}
-function parseTiebreakAt(setFormatString, expectNumber = true) {
-  const tiebreakAtValue = setFormatString?.indexOf("@") > 0 && setFormatString.split("@");
-  if (tiebreakAtValue) {
-    const tiebreakAt = expectNumber ? getNumber(tiebreakAtValue[1]) : tiebreakAtValue[1];
-    return tiebreakAt || false;
-  }
-  return void 0;
-}
-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(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 void 0;
-}
-function parseTimedSet(formatstring) {
-  const timestring = formatstring.slice(1);
-  const parts = timestring.match(/^(\d+)(@?[A-Za-z]*)/);
-  const minutes = getNumber(parts?.[1]);
-  if (!minutes)
-    return;
-  const setFormat = { timed: true, minutes };
-  const based = parts?.[2];
-  const validModifier = [void 0, "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(formatstring) {
-  return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
-}
-
-function isValid(matchUpFormat) {
-  if (typeof matchUpFormat !== "string")
-    return false;
-  const parsedFormat = parse(matchUpFormat);
-  const setParts = matchUpFormat.match(
-    /-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/
-  );
-  const setsTo = setParts?.[1];
-  const tiebreakTo = setParts?.[2];
-  const tiebreakAt = setParts?.[3];
-  const finalSetParts = matchUpFormat.match(
-    /-F:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/
-  );
-  const finalSetTo = finalSetParts?.[1];
-  const finalSetTiebreakTo = finalSetParts?.[2];
-  const finalTiebreakAt = finalSetParts?.[3];
-  const preserveRedundant = !!(setParts && tiebreakTo && setsTo === tiebreakAt || finalSetParts && finalSetTiebreakTo && finalSetTo === finalTiebreakAt);
-  const stringified = stringify(parsedFormat, preserveRedundant);
-  return stringified === matchUpFormat;
-}
-
-const matchUpFormatCode = {
-  isValidMatchUpFormat: isValid,
-  stringify,
-  isValid,
-  parse
-};
-
-function factoryVersion() {
-  return "1.8.4";
-}
-
-function getObjectTieFormat(obj) {
-  if (!obj)
-    return;
-  const { tieFormatId, tieFormats } = obj;
-  if (obj.tieFormat) {
-    return obj.tieFormat;
-  } else if (tieFormatId && Array.isArray(tieFormats)) {
-    return tieFormats.find((tf) => tf.tieFormatId === tieFormatId);
-  }
-}
-
-function getItemTieFormat({ item, drawDefinition, structure, event }) {
-  if (!item)
-    return;
-  if (item.tieFormat)
-    return item.tieFormat;
-  if (item.tieFormatId) {
-    if (drawDefinition.tieFormat)
-      return drawDefinition.tieFormat;
-    const tieFormat = drawDefinition.tieFormats?.find(
-      (tf) => item.tieFormatId === tf.tieFormatId
-    );
-    if (tieFormat)
-      return tieFormat;
-    if (event.tieFormat)
-      return event.tieFormat;
-    return event.tieFormats?.find((tf) => item.tieFormatId === tf.tieFormatId);
-  }
-  if (structure.tieFormat)
-    return structure.tieFormat;
-  if (structure.tieFormatId) {
-    const structureTieFormat = drawDefinition.tieFormats?.find(
-      (tf) => structure.tieFormatId === tf.tieFormatId
-    );
-    if (structureTieFormat)
-      return structureTieFormat;
-  }
-}
-
-function resolveTieFormat({
-  drawDefinition,
-  structure,
-  matchUp,
-  event
-}) {
-  return {
-    tieFormat: getItemTieFormat({
-      item: matchUp,
-      drawDefinition,
-      structure,
-      event
-    }) || getItemTieFormat({
-      item: structure,
-      drawDefinition,
-      structure,
-      event
-    }) || getObjectTieFormat(drawDefinition) || getObjectTieFormat(event)
-  };
-}
-
 function unique(arr) {
   return arr.filter((item, i, s) => s.lastIndexOf(item) === i);
 }
@@ -2230,177 +2005,6 @@ function generateHashCode(o) {
   return [str.length, keyCount, charSum].map((e) => e.toString(36)).join("");
 }
 
-const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
-const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
-function getCategoryAgeDetails(params) {
-  const category = params.category;
-  if (typeof category !== "object")
-    return { error: INVALID_CATEGORY };
-  let { ageCategoryCode, ageMaxDate, ageMinDate, ageMax, ageMin } = category;
-  const categoryName = category.categoryName;
-  let combinedAge;
-  if (!typeMatch(
-    [ageCategoryCode, ageMaxDate, ageMinDate, categoryName],
-    "string"
-  ) || !allNumeric(
-    [ageMax, ageMin]
-  ))
-    return { error: INVALID_CATEGORY };
-  const consideredDate = params.consideredDate ?? extractDate((/* @__PURE__ */ new Date()).toLocaleDateString("sv"));
-  if (!isValidDateString(consideredDate))
-    return { error: INVALID_DATE };
-  const [consideredYear] = consideredDate.split("-").slice(0, 3).map((n) => parseInt(n));
-  const previousDayDate = dateStringDaysChange(consideredDate, -1);
-  const [previousDayMonth, previousDay] = previousDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
-  const previousMonthDay = `${zeroPad(previousDayMonth)}-${zeroPad(
-    previousDay
-  )}`;
-  const nextDayDate = dateStringDaysChange(consideredDate, 1);
-  const [nextDayMonth, nextDay] = nextDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
-  const nextMonthDay = `${zeroPad(nextDayMonth)}-${zeroPad(nextDay)}`;
-  let calculatedAgeMaxDate = ageMin && dateStringDaysChange(consideredDate, -1 * 365 * ageMin);
-  let calculatedAgeMinDate = ageMax && dateStringDaysChange(consideredDate, -1 * 365 * ageMax);
-  const errors = [];
-  const addError = (errorString) => !errors.includes(errorString) && errors.push(errorString);
-  ageCategoryCode = ageCategoryCode ?? categoryName;
-  const prePost = /^([UO]?)(\d{1,2})([UO]?)$/;
-  const extractCombined = /^C(\d{1,2})-(\d{1,2})$/;
-  const isBetween = ageCategoryCode?.includes("-");
-  const isCombined = isBetween && ageCategoryCode?.match(extractCombined);
-  const isCoded = ageCategoryCode?.match(prePost);
-  const constructedDate = (y, df) => `${y}-${df}`;
-  const uPre = (ageInt) => {
-    const ageMinYear = consideredYear - ageInt;
-    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
-    if (category.ageMinDate && category.ageMinDate !== newMinDate)
-      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
-    ageMinDate = newMinDate;
-    if (ageCategoryCode) {
-      if (category.ageMax && category.ageMax !== ageInt - 1) {
-        addError(`Invalid submitted ageMax: ${ageMax}`);
-        calculatedAgeMinDate = void 0;
-      }
-      ageMax = ageInt - 1;
-    }
-  };
-  const uPost = (ageInt) => {
-    const ageMinYear = consideredYear - ageInt - 1;
-    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
-    if (category.ageMin && category.ageMin > ageInt) {
-      addError(`Invalid submitted ageMin: ${ageMin}`);
-    }
-    if (category.ageMax && category.ageMax > ageInt) {
-      addError(`Invalid submitted ageMax: ${ageMax}`);
-    }
-    if (category.ageMinDate && category.ageMinDate !== newMinDate)
-      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
-    ageMinDate = newMinDate;
-    if (ageCategoryCode) {
-      if (category.ageMax && category.ageMax !== ageInt) {
-        addError(`Invalid submitted ageMax: ${ageMax}`);
-        calculatedAgeMaxDate = void 0;
-      }
-      ageMax = ageInt;
-    }
-  };
-  const oPre = (ageInt) => {
-    const ageMaxYear = consideredYear - ageInt;
-    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
-    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
-      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
-    ageMaxDate = newMaxDate;
-    if (ageCategoryCode) {
-      if (category.ageMin && category.ageMin !== ageInt + 1) {
-        addError(`Invalid submitted ageMin: ${ageMin}`);
-        calculatedAgeMaxDate = void 0;
-      }
-      ageMin = ageInt + 1;
-    }
-  };
-  const oPost = (ageInt) => {
-    const ageMaxYear = consideredYear - ageInt - 1;
-    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
-    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
-      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
-    ageMaxDate = newMaxDate;
-    if (ageCategoryCode) {
-      if (category.ageMin && category.ageMin !== ageInt) {
-        addError(`Invalid submitted ageMin: ${ageMin}`);
-        calculatedAgeMaxDate = void 0;
-      }
-      ageMin = ageInt;
-    }
-  };
-  const processCode = (code) => {
-    const [pre, age, post] = (code.match(prePost) || []).slice(1);
-    const ageInt = parseInt(age);
-    if (pre === "U") {
-      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
-        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
-      }
-      uPre(ageInt);
-    } else if (pre === "O") {
-      oPre(ageInt);
-    }
-    if (post === "U") {
-      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
-        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
-      }
-      uPost(ageInt);
-    } else if (post === "O") {
-      oPost(ageInt);
-    }
-    ageMaxDate = ageMaxDate ?? calculatedAgeMaxDate;
-    ageMinDate = ageMinDate ?? calculatedAgeMinDate;
-  };
-  if (isCombined) {
-    ageMaxDate = void 0;
-    ageMinDate = void 0;
-    ageMax = void 0;
-    ageMin = void 0;
-    if (category.ageMin) {
-      const ageMaxYear = consideredYear - category.ageMin;
-      ageMaxDate = constructedDate(ageMaxYear, previousMonthDay);
-    }
-    if (category.ageMax) {
-      const ageMinYear = consideredYear - category.ageMax - 1;
-      ageMinDate = constructedDate(ageMinYear, nextMonthDay);
-    }
-    const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
-    if (lowAge <= highAge) {
-      ageMin = lowAge;
-      ageMax = highAge;
-      combinedAge = true;
-    } else {
-      addError(`Invalid combined age range ${ageCategoryCode}`);
-    }
-  } else if (isBetween) {
-    ageCategoryCode?.split("-").forEach(processCode);
-  } else if (isCoded) {
-    processCode(ageCategoryCode);
-  } else {
-    if (ageMin)
-      oPre(ageMin);
-    if (ageMax)
-      uPost(ageMax);
-  }
-  if (ageMax && category.ageMin && category.ageMin > ageMax) {
-    addError(`Invalid submitted ageMin: ${category.ageMin}`);
-    ageMin = void 0;
-  }
-  const result = definedAttributes({
-    consideredDate,
-    combinedAge,
-    ageMaxDate,
-    ageMinDate,
-    ageMax,
-    ageMin
-  });
-  if (errors.length)
-    result.errors = errors;
-  return result;
-}
-
 function attributeFilter(params) {
   if (params === null)
     return {};
@@ -2602,6 +2206,409 @@ function UUID() {
   lut[d3 & 255] + lut[d3 >> 8 & 255] + lut[d3 >> 16 & 255] + lut[d3 >> 24 & 255];
 }
 
+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 void 0;
+}
+function setsMatch(formatstring) {
+  const parts = formatstring.split("-");
+  const setsCount = getNumber(parts[0].slice(3));
+  const bestOf = setsCount === 1 || setsCount % 2 !== 0 ? setsCount : void 0;
+  const exactly = setsCount !== 1 && setsCount % 2 === 0 ? setsCount : void 0;
+  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.indexOf("TB") === 0;
+      if (isTiebreakSet) {
+        const tiebreakSet = parseTiebreakFormat(setFormatString);
+        if (tiebreakSet === false)
+          return false;
+        return typeof tiebreakSet === "object" ? { tiebreakSet } : void 0;
+      }
+      const timedSet = setFormatString.indexOf("T") === 0;
+      if (timedSet)
+        return parseTimedSet(setFormatString);
+      const parts2 = formatstring.match(/^[FS]:(\d+)([A-Za-z]*)/);
+      const NoAD = parts2 && isNoAD(parts2[2]) || false;
+      const validNoAD = !parts2?.[2] || NoAD;
+      const setTo = parts2 ? getNumber(parts2[1]) : void 0;
+      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 void 0;
+}
+function parseTiebreakAt(setFormatString, expectNumber = true) {
+  const tiebreakAtValue = setFormatString?.indexOf("@") > 0 && setFormatString.split("@");
+  if (tiebreakAtValue) {
+    const tiebreakAt = expectNumber ? getNumber(tiebreakAtValue[1]) : tiebreakAtValue[1];
+    return tiebreakAt || false;
+  }
+  return void 0;
+}
+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(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 void 0;
+}
+function parseTimedSet(formatstring) {
+  const timestring = formatstring.slice(1);
+  const parts = timestring.match(/^(\d+)(@?[A-Za-z]*)/);
+  const minutes = getNumber(parts?.[1]);
+  if (!minutes)
+    return;
+  const setFormat = { timed: true, minutes };
+  const based = parts?.[2];
+  const validModifier = [void 0, "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(formatstring) {
+  return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
+}
+
+function isValid(matchUpFormat) {
+  if (typeof matchUpFormat !== "string")
+    return false;
+  const parsedFormat = parse(matchUpFormat);
+  const setParts = matchUpFormat.match(
+    /-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/
+  );
+  const setsTo = setParts?.[1];
+  const tiebreakTo = setParts?.[2];
+  const tiebreakAt = setParts?.[3];
+  const finalSetParts = matchUpFormat.match(
+    /-F:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/
+  );
+  const finalSetTo = finalSetParts?.[1];
+  const finalSetTiebreakTo = finalSetParts?.[2];
+  const finalTiebreakAt = finalSetParts?.[3];
+  const preserveRedundant = !!(setParts && tiebreakTo && setsTo === tiebreakAt || finalSetParts && finalSetTiebreakTo && finalSetTo === finalTiebreakAt);
+  const stringified = stringify(parsedFormat, preserveRedundant);
+  return stringified === matchUpFormat;
+}
+
+const matchUpFormatCode = {
+  isValidMatchUpFormat: isValid,
+  stringify,
+  isValid,
+  parse
+};
+
+function factoryVersion() {
+  return "1.8.6";
+}
+
+function getObjectTieFormat(obj) {
+  if (!obj)
+    return;
+  const { tieFormatId, tieFormats } = obj;
+  if (obj.tieFormat) {
+    return obj.tieFormat;
+  } else if (tieFormatId && Array.isArray(tieFormats)) {
+    return tieFormats.find((tf) => tf.tieFormatId === tieFormatId);
+  }
+}
+
+function getItemTieFormat({ item, drawDefinition, structure, event }) {
+  if (!item)
+    return;
+  if (item.tieFormat)
+    return item.tieFormat;
+  if (item.tieFormatId) {
+    if (drawDefinition.tieFormat)
+      return drawDefinition.tieFormat;
+    const tieFormat = drawDefinition.tieFormats?.find(
+      (tf) => item.tieFormatId === tf.tieFormatId
+    );
+    if (tieFormat)
+      return tieFormat;
+    if (event.tieFormat)
+      return event.tieFormat;
+    return event.tieFormats?.find((tf) => item.tieFormatId === tf.tieFormatId);
+  }
+  if (structure.tieFormat)
+    return structure.tieFormat;
+  if (structure.tieFormatId) {
+    const structureTieFormat = drawDefinition.tieFormats?.find(
+      (tf) => structure.tieFormatId === tf.tieFormatId
+    );
+    if (structureTieFormat)
+      return structureTieFormat;
+  }
+}
+
+function resolveTieFormat({
+  drawDefinition,
+  structure,
+  matchUp,
+  event
+}) {
+  return {
+    tieFormat: getItemTieFormat({
+      item: matchUp,
+      drawDefinition,
+      structure,
+      event
+    }) || getItemTieFormat({
+      item: structure,
+      drawDefinition,
+      structure,
+      event
+    }) || getObjectTieFormat(drawDefinition) || getObjectTieFormat(event)
+  };
+}
+
+const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
+const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
+function getCategoryAgeDetails(params) {
+  const category = params.category;
+  if (typeof category !== "object")
+    return { error: INVALID_CATEGORY };
+  let { ageCategoryCode, ageMaxDate, ageMinDate, ageMax, ageMin } = category;
+  const categoryName = category.categoryName;
+  let combinedAge;
+  if (!typeMatch(
+    [ageCategoryCode, ageMaxDate, ageMinDate, categoryName],
+    "string"
+  ) || !allNumeric(
+    [ageMax, ageMin]
+  ))
+    return { error: INVALID_CATEGORY };
+  const consideredDate = params.consideredDate ?? extractDate((/* @__PURE__ */ new Date()).toLocaleDateString("sv"));
+  if (!isValidDateString(consideredDate))
+    return { error: INVALID_DATE };
+  const [consideredYear] = consideredDate.split("-").slice(0, 3).map((n) => parseInt(n));
+  const previousDayDate = dateStringDaysChange(consideredDate, -1);
+  const [previousDayMonth, previousDay] = previousDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
+  const previousMonthDay = `${zeroPad(previousDayMonth)}-${zeroPad(
+    previousDay
+  )}`;
+  const nextDayDate = dateStringDaysChange(consideredDate, 1);
+  const [nextDayMonth, nextDay] = nextDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
+  const nextMonthDay = `${zeroPad(nextDayMonth)}-${zeroPad(nextDay)}`;
+  let calculatedAgeMaxDate = ageMin && dateStringDaysChange(consideredDate, -1 * 365 * ageMin);
+  let calculatedAgeMinDate = ageMax && dateStringDaysChange(consideredDate, -1 * 365 * ageMax);
+  const errors = [];
+  const addError = (errorString) => !errors.includes(errorString) && errors.push(errorString);
+  ageCategoryCode = ageCategoryCode ?? categoryName;
+  const prePost = /^([UO]?)(\d{1,2})([UO]?)$/;
+  const extractCombined = /^C(\d{1,2})-(\d{1,2})$/;
+  const isBetween = ageCategoryCode?.includes("-");
+  const isCombined = isBetween && ageCategoryCode?.match(extractCombined);
+  const isCoded = ageCategoryCode?.match(prePost);
+  const constructedDate = (y, df) => `${y}-${df}`;
+  const uPre = (ageInt) => {
+    const ageMinYear = consideredYear - ageInt;
+    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
+    if (category.ageMinDate && category.ageMinDate !== newMinDate)
+      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
+    ageMinDate = newMinDate;
+    if (ageCategoryCode) {
+      if (category.ageMax && category.ageMax !== ageInt - 1) {
+        addError(`Invalid submitted ageMax: ${ageMax}`);
+        calculatedAgeMinDate = void 0;
+      }
+      ageMax = ageInt - 1;
+    }
+  };
+  const uPost = (ageInt) => {
+    const ageMinYear = consideredYear - ageInt - 1;
+    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
+    if (category.ageMin && category.ageMin > ageInt) {
+      addError(`Invalid submitted ageMin: ${ageMin}`);
+    }
+    if (category.ageMax && category.ageMax > ageInt) {
+      addError(`Invalid submitted ageMax: ${ageMax}`);
+    }
+    if (category.ageMinDate && category.ageMinDate !== newMinDate)
+      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
+    ageMinDate = newMinDate;
+    if (ageCategoryCode) {
+      if (category.ageMax && category.ageMax !== ageInt) {
+        addError(`Invalid submitted ageMax: ${ageMax}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMax = ageInt;
+    }
+  };
+  const oPre = (ageInt) => {
+    const ageMaxYear = consideredYear - ageInt;
+    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
+      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
+    ageMaxDate = newMaxDate;
+    if (ageCategoryCode) {
+      if (category.ageMin && category.ageMin !== ageInt + 1) {
+        addError(`Invalid submitted ageMin: ${ageMin}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMin = ageInt + 1;
+    }
+  };
+  const oPost = (ageInt) => {
+    const ageMaxYear = consideredYear - ageInt - 1;
+    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
+      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
+    ageMaxDate = newMaxDate;
+    if (ageCategoryCode) {
+      if (category.ageMin && category.ageMin !== ageInt) {
+        addError(`Invalid submitted ageMin: ${ageMin}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMin = ageInt;
+    }
+  };
+  const processCode = (code) => {
+    const [pre, age, post] = (code.match(prePost) || []).slice(1);
+    const ageInt = parseInt(age);
+    if (pre === "U") {
+      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
+        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
+      }
+      uPre(ageInt);
+    } else if (pre === "O") {
+      oPre(ageInt);
+    }
+    if (post === "U") {
+      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
+        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
+      }
+      uPost(ageInt);
+    } else if (post === "O") {
+      oPost(ageInt);
+    }
+    ageMaxDate = ageMaxDate ?? calculatedAgeMaxDate;
+    ageMinDate = ageMinDate ?? calculatedAgeMinDate;
+  };
+  if (isCombined) {
+    ageMaxDate = void 0;
+    ageMinDate = void 0;
+    ageMax = void 0;
+    ageMin = void 0;
+    if (category.ageMin) {
+      const ageMaxYear = consideredYear - category.ageMin;
+      ageMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    }
+    if (category.ageMax) {
+      const ageMinYear = consideredYear - category.ageMax - 1;
+      ageMinDate = constructedDate(ageMinYear, nextMonthDay);
+    }
+    const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
+    if (lowAge <= highAge) {
+      ageMin = lowAge;
+      ageMax = highAge;
+      combinedAge = true;
+    } else {
+      addError(`Invalid combined age range ${ageCategoryCode}`);
+    }
+  } else if (isBetween) {
+    ageCategoryCode?.split("-").forEach(processCode);
+  } else if (isCoded) {
+    processCode(ageCategoryCode);
+  } else {
+    if (ageMin)
+      oPre(ageMin);
+    if (ageMax)
+      uPost(ageMax);
+  }
+  if (ageMax && category.ageMin && category.ageMin > ageMax) {
+    addError(`Invalid submitted ageMin: ${category.ageMin}`);
+    ageMin = void 0;
+  }
+  const result = definedAttributes({
+    consideredDate,
+    combinedAge,
+    ageMaxDate,
+    ageMinDate,
+    ageMax,
+    ageMin
+  });
+  if (errors.length)
+    result.errors = errors;
+  return result;
+}
+
 function categoryCanContain({
   childCategory,
   withDetails,
@@ -7531,10 +7538,10 @@ function getOrderedDrawPositions({
   const pairedDrawPositions = targetRoundProfile?.pairedDrawPositions;
   const displayOrder = pairedDrawPositions?.find(
     (pair) => overlap(pair || [], drawPositions.filter(Boolean))
-  ) || unassignedDrawPositions;
+  ) ?? unassignedDrawPositions;
   const isFeedRound = targetRoundProfile?.feedRound;
   if (allNumeric$1(drawPositions)) {
-    const orderedDrawPositions = drawPositions.sort(numericSort);
+    const orderedDrawPositions = [...drawPositions].sort(numericSort);
     return {
       orderedDrawPositions: orderedDrawPositions.length === 2 ? orderedDrawPositions : displayOrder,
       displayOrder: isFeedRound ? orderedDrawPositions : displayOrder
@@ -8268,7 +8275,7 @@ function getAllStructureMatchUps({
     matchUp,
     event: event2
   }) {
-    additionalContext = additionalContext || {};
+    additionalContext = additionalContext ?? {};
     const tieFormat = resolveTieFormat({
       drawDefinition,
       structure,
@@ -8279,7 +8286,7 @@ function getAllStructureMatchUps({
     const collectionDefinition = matchUp.collectionId && collectionDefinitions?.find(
       (definition) => definition.collectionId === matchUp.collectionId
     );
-    const matchUpFormat = matchUp.collectionId ? collectionDefinition?.matchUpFormat : matchUp.matchUpFormat || structure?.matchUpFormat || drawDefinition?.matchUpFormat || event2?.matchUpFormat;
+    const matchUpFormat = matchUp.collectionId ? collectionDefinition?.matchUpFormat : matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event2?.matchUpFormat;
     const matchUpType = matchUp.matchUpType || collectionDefinition?.matchUpType || structure?.matchUpType || drawDefinition?.matchUpType || event2?.eventType !== TEAM$1 && event2?.eventType;
     const matchUpStatus = isCollectionBye ? BYE : matchUp.matchUpStatus;
     const { schedule, endDate } = getMatchUpScheduleDetails({
@@ -8294,7 +8301,7 @@ function getAllStructureMatchUps({
     });
     const drawPositions = tieDrawPositions ?? matchUp.drawPositions ?? [];
     const { collectionPosition, collectionId, roundPosition } = matchUp;
-    const roundNumber = matchUp.roundNumber || additionalContext.roundNumber;
+    const roundNumber = matchUp.roundNumber ?? additionalContext.roundNumber;
     const drawPositionCollectionAssignment = collectionId ? getDrawPositionCollectionAssignment({
       tournamentParticipants,
       positionAssignments,
@@ -8320,7 +8327,7 @@ function getAllStructureMatchUps({
     } : context?.category;
     const processCodes = matchUp.processCodes?.length && matchUp.processCodes || collectionDefinition?.processCodes?.length && collectionDefinition?.processCodes || structure?.processCodes?.length && structure?.processCodes || drawDefinition?.processCodes?.length && drawDefinition?.processCodes || event2?.processCodes?.length && event2?.processCodes || tournamentRecord?.processCodes;
     const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
-    const finishingPositionRange = matchUp.finishingPositionRange || additionalContext.finishingPositionRange;
+    const finishingPositionRange = matchUp.finishingPositionRange ?? additionalContext.finishingPositionRange;
     const onlyDefined = (obj) => definedAttributes(obj, void 0, true);
     const matchUpWithContext = {
       ...onlyDefined(context),
@@ -8328,7 +8335,7 @@ function getAllStructureMatchUps({
         matchUpFormat: matchUp.matchUpType === TEAM$1 ? void 0 : matchUpFormat,
         tieFormat: matchUp.matchUpType !== TEAM$1 ? void 0 : tieFormat,
         roundOfPlay: stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay2) && initialRoundOfPlay2 + (roundNumber || 0),
-        endDate: matchUp.endDate || endDate,
+        endDate: matchUp.endDate ?? endDate,
         gender: collectionDefinition?.gender,
         discipline: event2?.discipline,
         category: matchUpCategory,
@@ -9535,10 +9542,10 @@ function addUpcomingMatchUps({ drawDefinition, inContextDrawMatchUps }) {
     if (structure?.finishingPosition === WIN_RATIO) {
       const { roundNumber } = inContextMatchUp;
       const nextRoundNumber = roundNumber && ensureInt(roundNumber) + 1;
-      const matchUps = structure.matchUps || [];
+      const matchUps = structure.matchUps ?? [];
       const { roundMatchUps } = getRoundMatchUps$1({ matchUps });
       if (nextRoundNumber && roundMatchUps?.[nextRoundNumber]) {
-        const sidesTo = drawPositions.sort().map((drawPosition, index) => {
+        const sidesTo = [...drawPositions].sort(numericSort).map((drawPosition, index) => {
           const nextRoundMatchUp = roundMatchUps[nextRoundNumber].find(
             (matchUp) => matchUp.drawPositions?.includes(drawPosition)
           );
@@ -11205,7 +11212,7 @@ function getScoreAnalysis({
   const matchUpScoringFormat = parse(matchUpFormat);
   const isDecidingSet = setNumber === matchUpScoringFormat?.bestOf;
   const setFormat = isDecidingSet && matchUpScoringFormat?.finalSetFormat || matchUpScoringFormat?.setFormat || {};
-  const isTimedSet = setFormat?.timed || matchUpScoringFormat?.timed;
+  const isTimedSet = setFormat?.timed;
   const finalSet = isDecidingSet && sets[matchUpScoringFormat?.bestOf - 1];
   const finalSetIsComplete = finalSet?.winningSide;
   const { isTiebreakEntry: isSetTiebreakEntry } = testTiebreakEntry({
@@ -17712,7 +17719,7 @@ function getRoundRobinGroupMatchUps({ drawPositions }) {
   return { groupMatchUps, uniqueMatchUpGroupings };
 }
 function drawPositionsHash(drawPositions) {
-  return drawPositions.sort(numericSort).join("|");
+  return [...drawPositions].sort(numericSort).join("|");
 }
 function groupRounds({ groupSize, drawPositionOffset }) {
   const numArr = (count) => [...Array(count)].map((_, i) => i);
@@ -17738,7 +17745,7 @@ function groupRounds({ groupSize, drawPositionOffset }) {
   aRow = [aHead, bUp, ...aRow].filter(Boolean);
   bRow = [...bRow, aDown].filter(Boolean);
   const sum = (x) => x[0].reduce((a, b) => a + b);
-  return rounds.reverse().sort((a, b) => sum(a) - sum(b)).map(
+  return [...rounds].reverse().sort((a, b) => sum(a) - sum(b)).map(
     (round) => round.filter(
       (groupPositions2) => groupPositions2.every((position) => position <= groupSize)
     ).map((groupPositions2) => {
@@ -19788,6 +19795,7 @@ function getMatchUpContextIds({ matchUps, matchUpId }) {
 }
 
 function addMatchUpScheduledTime$2(params) {
+  const stack = "addMatchUpScheduledTime";
   let matchUp = params.matchUp;
   const {
     removePriorValues,
@@ -19798,27 +19806,18 @@ function addMatchUpScheduledTime$2(params) {
     matchUpId
   } = params;
   if (!matchUpId)
-    return { error: MISSING_MATCHUP_ID };
+    return decorateResult({ result: { error: MISSING_MATCHUP_ID }, stack });
   if (!validTimeValue(scheduledTime))
-    return { error: INVALID_TIME };
+    return decorateResult({ result: { error: INVALID_TIME }, stack });
   if (!matchUp) {
     const result = findMatchUp$1({ drawDefinition, matchUpId });
     if (result.error)
-      return result;
+      return decorateResult({ result, stack });
     matchUp = result.matchUp;
   }
   const timeDate = extractDate(scheduledTime);
-  const stack = "addMatchUpScheduledTime";
-  if (timeDate) {
-    const scheduledDate = scheduledMatchUpDate({ matchUp }).scheduledDate;
-    if (scheduledDate && scheduledDate !== timeDate) {
-      return decorateResult({
-        info: `date in time: ${timeDate} does not corresponde to scheduledDate: ${scheduledDate}`,
-        result: { error: INVALID_TIME },
-        stack
-      });
-    }
-  }
+  const scheduledDate = scheduledMatchUpDate({ matchUp }).scheduledDate;
+  const keepDate = timeDate && !scheduledDate;
   const existingTimeModifiers = matchUpTimeModifiers({ matchUp }).timeModifiers || [];
   if (existingTimeModifiers?.length) {
     const result = addMatchUpTimeModifiers({
@@ -19831,9 +19830,9 @@ function addMatchUpScheduledTime$2(params) {
       matchUp
     });
     if (result?.error)
-      return result;
+      return decorateResult({ result, stack });
   }
-  const militaryTime = convertTime(scheduledTime, true, true);
+  const militaryTime = convertTime(scheduledTime, true, keepDate);
   const itemValue = militaryTime;
   const timeItem = {
     itemType: SCHEDULED_TIME,
@@ -19858,14 +19857,19 @@ function addMatchUpTimeModifiers({
   matchUpId,
   matchUp
 }) {
+  const stack = "addMatchUpTimeModifiers";
   if (!matchUpId)
-    return { error: MISSING_MATCHUP_ID };
+    return decorateResult({ result: { error: MISSING_MATCHUP_ID }, stack });
   if (timeModifiers !== void 0 && !Array.isArray(timeModifiers))
-    return { error: INVALID_VALUES, info: mustBeAnArray("timeModifiers") };
+    return decorateResult({
+      info: mustBeAnArray("timeModifiers"),
+      result: { error: INVALID_VALUES },
+      stack
+    });
   if (!matchUp) {
     const result = findMatchUp$1({ drawDefinition, matchUpId });
     if (result.error)
-      return result;
+      return decorateResult({ result, stack });
     matchUp = result.matchUp;
   }
   let existingTimeModifiers = matchUpTimeModifiers({ matchUp }).timeModifiers || [];
@@ -19890,7 +19894,7 @@ function addMatchUpTimeModifiers({
       matchUpId
     });
     if (result.error)
-      return result;
+      return decorateResult({ result, stack });
   }
   const itemValue = !timeModifiers?.length ? void 0 : [...toBeAdded, ...existingTimeModifiers];
   const timeItem = {
@@ -36109,7 +36113,8 @@ function bulkRescheduleMatchUps$1({
               scheduledTime,
               minutesChange
             );
-            newScheduledTime = scheduledTimeDate && newScheduledDate ? `${newScheduledDate}T${timeString}` : timeString;
+            const timeStringDate = scheduledTimeDate && newScheduledDate || scheduledDate === scheduledTimeDate && scheduledTimeDate;
+            newScheduledTime = timeStringDate ? `${timeStringDate}T${timeString}` : timeString;
           }
         }
         if (doNotReschedule) {