/**               
               * Generates an array of unique random integers within a specified range in sorted order.
               *
               * Performed daily for draws with parameters of generateUniqueRandomSortedIntegers(10, 1, 49)
               *
               *
               * @param {number} count - The number of unique integers to generate (must be positive)
               * @param {number} min - The lower bound of the range (inclusive)
               * @param {number} max - The upper bound of the range (inclusive)
               * @returns {number[]} A sorted array of unique random integers
               * @throws {Error} If the requested count exceeds the possible unique values in the range
               * or if any parameter is invalid
               */
              function generateUniqueRandomSortedIntegers(count, min, max) {
                // Validate input parameters
                if (!Number.isInteger(count) || !Number.isInteger(min) || !Number.isInteger(max)) {
                  throw new Error("All parameters must be integers");
                }

                if (count <= 0) {
                  throw new Error("Count must be a positive integer");
                }

                if (min > max) {
                  throw new Error("Minimum value cannot exceed maximum value");
                }

                const rangeSize = max - min + 1;
                if (count > rangeSize) {
                  throw new Error(`Cannot generate ${count} unique numbers in range [${min}, ${max}]`);
                }

                // For small ranges relative to count, use Fisher-Yates shuffle algorithm
                if (count > rangeSize / 2) {
                  const allNumbers = Array.from({length: rangeSize}, (_, i) => min + i);

                  // Fisher-Yates shuffle
                  for (let i = allNumbers.length - 1; i > 0; i--) {
                    const j = Math.floor(Math.random() * (i + 1));
                    [allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
                  }

                  return allNumbers.slice(0, count).sort((a, b) => a - b);
                }

                // For larger ranges relative to count, use Set approach
                const uniqueNumbers = new Set();
                while (uniqueNumbers.size < count) {
                  const randomNumber = Math.floor(Math.random() * rangeSize) + min;
                  uniqueNumbers.add(randomNumber);
                }

                return Array.from(uniqueNumbers).sort((a, b) => a - b);
              }