cronli5 0.1.6 → 0.2.0

package/dist/lang/en.cjs

@@ -40,6 +40,26 @@ function arithmeticStep(values) {
   }
   return { start: values[0], interval, last: values[values.length - 1] };
 }
+function weekdayDisplayKey(value) {
+  return value === 0 ? 7 : value;
+}
+function orderWeekdaysForDisplay(segments) {
+  const flattened = segments.flatMap(function flat(segment) {
+    return segment.kind === "step" ? segment.fires.map(function single(value) {
+      return { kind: "single", value: "" + value };
+    }) : [segment];
+  });
+  function key(segment) {
+    return segment.kind === "range" ? weekdayDisplayKey(+segment.bounds[0]) : weekdayDisplayKey(+segment.value);
+  }
+  return flattened.map(function index(segment, position) {
+    return [segment, position];
+  }).sort(function byDisplayKey(a, b) {
+    return key(a[0]) - key(b[0]) || a[1] - b[1];
+  }).map(function unwrap(pair) {
+    return pair[0];
+  });
+}
 
 // src/core/specs.ts
 var maxClockTimes = 6;
@@ -84,7 +104,8 @@ var dialects = {
     pm: "p.m.",
     sep: ":",
     serialComma: true,
-    through: " through "
+    through: " through ",
+    untilWindow: true
   },
   house: {
     am: "AM",
@@ -101,7 +122,7 @@ var dialects = {
 };
 function resolveDialect(dialect) {
   if (typeof dialect === "object" && dialect !== null) {
-    return { ...dialects.us, ...dialect };
+    return { ...dialects.us, untilWindow: false, ...dialect };
   }
   const name = dialect === "uk" ? "gb" : dialect;
   return dialects[name] || dialects.us;
@@ -173,7 +194,9 @@ function normalizeOptions(options) {
   };
 }
 function describe(ir, opts) {
-  return applyYear(render(ir, ir.plan, opts), ir, opts);
+  const body = confinement(ir, opts) ?? render(ir, ir.plan, opts);
+  const lead = isDayUnion(ir, opts) ? dayUnionMonthLead(ir, opts) : "";
+  return applyYear(lead + body, ir, opts);
 }
 function render(ir, plan, opts) {
   const renderer = renderers[plan.kind];
@@ -266,7 +289,7 @@ function secondsClause(ir, anchor, opts) {
   }
   if (shape === "range") {
     const bounds = secondField.split("-");
-    const num = seriesNumber(bounds, opts);
+    const num = seriesNumber();
     return "every second from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the " + anchor;
   }
   if (shape === "single") {
@@ -332,15 +355,21 @@ function renderMinutesAcrossHours(ir, plan, opts) {
     }
     return "every minute during the " + hourTimesFromPlan(ir, plan.times, false, opts) + " hours" + trailingQualifier(ir, opts);
   }
-  const lead = plan.form === "range" ? minuteRangeLead(ir.pattern.minute, opts) : (
-    // The 'list' form is a minute list, which has segments; an offset/uneven
-    // step enumerated to that list reads as a stride.
-    strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
-      segmentWords(ir.analyses.segments.minute, opts),
-      "minute",
-      "hour",
-      opts
-    )
+  if (plan.form === "range") {
+    const lead2 = minuteRangeLead(ir.pattern.minute, opts);
+    if (cadence !== null) {
+      return lead2 + ", " + cadence + trailingQualifier(ir, opts);
+    }
+    if (singleHourFire(plan.times)) {
+      return lead2 + ", at " + hourTimesFromPlan(ir, plan.times, true, opts) + trailingQualifier(ir, opts);
+    }
+    return lead2 + " during the " + hourTimesFromPlan(ir, plan.times, false, opts) + " hours" + trailingQualifier(ir, opts);
+  }
+  const lead = strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
+    segmentWords(ir.analyses.segments.minute, opts),
+    "minute",
+    "hour",
+    opts
   );
   if (cadence !== null) {
     return lead + ", " + cadence + trailingQualifier(ir, opts);
@@ -377,7 +406,7 @@ function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
 }
 function minuteRangeLead(minuteField, opts) {
   const bounds = minuteField.split("-");
-  const num = seriesNumber(bounds, opts);
+  const num = seriesNumber();
   return "every minute from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the hour";
 }
 function renderEveryHour(ir, plan, opts) {
@@ -417,10 +446,18 @@ function renderHourStep(ir, plan, opts) {
   return stepHours(ir.analyses.segments.hour[0], opts) + trailingQualifier(ir, opts);
 }
 function boundedWindow(plan) {
-  return { from: plan.from, last: plan.boundMinute ?? 0, to: plan.to };
+  const last = plan.minuteForm === "wildcard" ? plan.boundMinute ?? 0 : 0;
+  return { from: plan.from, last, to: plan.to };
+}
+function rangeWindow(from, to, throughMinute, opts) {
+  const open = "from " + getTime({ hour: from, minute: 0 }, opts);
+  if (opts.style.untilWindow && !opts.short && from !== to) {
+    return open + " until " + getTime({ hour: (to + 1) % 24, minute: 0 }, opts);
+  }
+  return open + through(opts) + getTime({ hour: to, minute: throughMinute }, opts);
 }
 function hourWindow(window, opts) {
-  return "from " + getTime({ hour: window.from, minute: 0 }, opts) + through(opts) + getTime({ hour: window.to, minute: window.last }, opts);
+  return rangeWindow(window.from, window.to, window.last, opts);
 }
 function renderClockTimes(ir, plan, opts) {
   if (ir.shapes.minute === "single") {
@@ -439,7 +476,10 @@ function renderClockTimes(ir, plan, opts) {
       plain
     }, opts);
   });
-  return interpretDayQualifier(ir, opts) + "at " + joinList(times, opts);
+  return interpretDayQualifier(ir, opts) + "at " + joinList(times, opts) + dayUnionTrail(ir, opts);
+}
+function dayUnionTrail(ir, opts) {
+  return isDayUnion(ir, opts) ? dayUnionCondition(ir, opts) : "";
 }
 function renderCompactClockTimes(ir, plan, opts) {
   if (plan.fold) {
@@ -454,7 +494,7 @@ function renderCompactClockTimes(ir, plan, opts) {
       return foldedHourWindows(ir, plan, opts) + trailingQualifier(ir, opts);
     }
     const fold = { minute: plan.minute, second: ir.analyses.clockSecond };
-    return interpretDayQualifier(ir, opts) + "at " + hourSegmentTimes(ir, fold, true, opts);
+    return interpretDayQualifier(ir, opts) + "at " + hourSegmentTimes(ir, fold, true, opts) + dayUnionTrail(ir, opts);
   }
   const minuteLead = (
     // The non-fold branch is a minute list, which has segments. An
@@ -473,26 +513,161 @@ function renderCompactClockTimes(ir, plan, opts) {
 function foldedHourWindows(ir, plan, opts) {
   const minute = plan.minute;
   const windows = [];
-  const singles = [];
+  const outliers = collectHourOutliers(ir);
+  const times = outliers.hours.map(function time(hour) {
+    return getTime({ hour, minute }, opts);
+  });
   ir.analyses.segments.hour.forEach(function classify(segment) {
     if (segment.kind === "range") {
-      windows.push("from " + getTime(
-        { hour: segment.bounds[0], minute: 0 },
+      windows.push(rangeWindow(
+        +segment.bounds[0],
+        +segment.bounds[1],
+        minute,
         opts
-      ) + through(opts) + getTime({ hour: segment.bounds[1], minute }, opts));
-    } else if (segment.kind === "step") {
-      singles.push(...segment.fires);
-    } else {
-      singles.push(+segment.value);
+      ));
+    }
+  });
+  const phrase = rangeMinuteLead(ir, opts) + " " + joinList(windows, opts);
+  return phrase + outlierTail(times, outliers.pureStrays, opts);
+}
+function collectHourOutliers(ir) {
+  const hours = [];
+  let pureStrays = true;
+  ir.analyses.segments.hour.forEach(function classify(segment) {
+    if (segment.kind === "step") {
+      hours.push(...segment.fires);
+      pureStrays = false;
+    } else if (segment.kind !== "range") {
+      hours.push(+segment.value);
     }
   });
-  let phrase = rangeMinuteLead(ir, opts) + " " + joinList(windows, opts);
-  if (singles.length) {
-    phrase += " and at " + joinList(singles.map(function time(hour) {
-      return getTime({ hour, minute }, opts);
-    }), opts);
+  return { hours, pureStrays };
+}
+function outlierTail(times, pureStrays, opts) {
+  if (!times.length) {
+    return "";
   }
-  return phrase;
+  const connector = pureStrays && opts.style.untilWindow && !opts.short ? " plus " : " and at ";
+  return connector + joinList(times, opts);
+}
+function isCadenceField(token) {
+  return token === "*" || token.startsWith("*/") && token.indexOf("-") === -1;
+}
+function leadingCadence(ir, opts) {
+  const { second, minute } = ir.pattern;
+  if (isCadenceField(second)) {
+    return { secondLead: true, text: secondsClause(ir, "minute", opts) };
+  }
+  if (second === "0" && isCadenceField(minute)) {
+    const text = minute === "*" ? "every minute" : (
+      // A clean minute step's first segment is a step segment.
+      stepCycle60(
+        ir.analyses.segments.minute[0],
+        "minute",
+        "hour",
+        opts
+      )
+    );
+    return { secondLead: false, text };
+  }
+  return null;
+}
+function minuteConfinement(ir, opts) {
+  const minute = ir.pattern.minute;
+  if (minute === "*") {
+    return "";
+  }
+  if (isCadenceField(minute)) {
+    return " of every other minute";
+  }
+  const segments = ir.analyses.segments.minute;
+  if (ir.shapes.minute === "single") {
+    return " during minute :" + pad(minute);
+  }
+  if (ir.shapes.minute === "range") {
+    const bounds = minute.split("-");
+    return " during minutes :" + pad(bounds[0]) + through(opts) + ":" + pad(bounds[1]);
+  }
+  const values = segmentWords(segments, opts).map(function colon(word) {
+    return ":" + pad(word);
+  });
+  return " during minutes " + joinList(values, opts);
+}
+function hourConfinement(ir, opts) {
+  const hour = ir.pattern.hour;
+  if (hour === "*") {
+    const minutePinned = ir.pattern.minute !== "*" && !isCadenceField(ir.pattern.minute);
+    return minutePinned ? " of every hour" : "";
+  }
+  if (isCadenceField(hour)) {
+    return hour === "*/2" ? " of every other hour" : "";
+  }
+  if (ir.shapes.hour === "single") {
+    const h = +hour;
+    if (ir.shapes.minute === "step") {
+      return " from " + getTime({ hour: h, minute: 0 }, opts) + " until " + getTime({ hour: (h + 1) % 24, minute: 0 }, opts);
+    }
+    if (ir.pattern.minute !== "*" && !isCadenceField(ir.pattern.minute)) {
+      return " at " + getTime({ hour: h, minute: 0 }, opts);
+    }
+    return " of the " + getTime({ hour: h, minute: 0 }, opts) + " hour";
+  }
+  if (ir.shapes.hour === "range") {
+    const bounds = hour.split("-");
+    return " " + rangeWindow(+bounds[0], +bounds[1], 0, opts);
+  }
+  return " during the " + hourSegmentTimes(ir, { minute: 0, second: null }, false, opts) + " hours";
+}
+function isContiguousHourRange(ir) {
+  return ir.shapes.hour === "range";
+}
+function confinableHour(ir) {
+  if (ir.shapes.hour !== "step") {
+    return true;
+  }
+  const segment = ir.analyses.segments.hour[0];
+  return ir.pattern.hour === "*/2" || segment.startToken.indexOf("-") !== -1;
+}
+function isMinuteStride(ir) {
+  if (ir.shapes.minute !== "list") {
+    return false;
+  }
+  const values = singleValues(ir.analyses.segments.minute);
+  return values !== null && arithmeticStep(values) !== null;
+}
+function confinementEligible(ir, lead) {
+  const { minute, hour } = ir.pattern;
+  const minuteStep = isCadenceField(minute) && minute !== "*";
+  if (!confinableHour(ir)) {
+    return false;
+  }
+  if (lead.secondLead) {
+    if (minuteStep) {
+      return minute === "*/2" && !isContiguousHourRange(ir);
+    }
+    if (isMinuteStride(ir) || ir.shapes.minute === "list" && ir.shapes.hour === "list") {
+      return false;
+    }
+    return true;
+  }
+  if (hour === "*/2") {
+    return true;
+  }
+  return ir.shapes.hour === "single" && minute === "*/2";
+}
+function confinement(ir, opts) {
+  if (!opts.style.untilWindow || opts.short) {
+    return null;
+  }
+  if (ir.pattern.minute === "*" && ir.pattern.hour === "*") {
+    return null;
+  }
+  const lead = leadingCadence(ir, opts);
+  if (!lead || !confinementEligible(ir, lead)) {
+    return null;
+  }
+  const minutePart = lead.secondLead ? minuteConfinement(ir, opts) : "";
+  return lead.text + minutePart + hourConfinement(ir, opts) + trailingQualifier(ir, opts);
 }
 var renderers = {
   clockTimes: renderClockTimes,
@@ -524,7 +699,7 @@ function renderStride(stride, opts) {
   if (start < interval && tiles) {
     return cadence + " from " + getNumber(start, opts) + " " + pluralize(start, unit) + " past the " + anchor;
   }
-  const num = seriesNumber([start, last], opts);
+  const num = seriesNumber();
   return cadence + " from " + num(start) + through(opts) + num(last) + " " + pluralize(last, unit) + " past the " + anchor;
 }
 function singleValues(segments) {
@@ -651,9 +826,9 @@ function hourCadence(ir, minute, opts) {
   if (ir.pattern.second === "0" && fires <= maxClockTimes && offsetCleanStride(stride)) {
     return null;
   }
-  const confinement = minute === 0 && subMinuteSecond(ir) && cleanStrideSegment(ir);
-  if (confinement) {
-    return secondsClause(ir, "minute", opts) + " for one minute " + everyNthHour(confinement, opts) + trailingQualifier(ir, opts);
+  const minuteZeroStride = minute === 0 && subMinuteSecond(ir) && cleanStrideSegment(ir);
+  if (minuteZeroStride) {
+    return secondsClause(ir, "minute", opts) + " for one minute " + everyNthHour(minuteZeroStride, opts) + trailingQualifier(ir, opts);
   }
   if (minute === 0 && ir.pattern.second === "0") {
     return hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
@@ -675,26 +850,22 @@ function hasHourWindow(ir) {
 }
 function hourRangeWindowTail(ir, opts) {
   const windows = [];
-  const singles = [];
+  const outliers = collectHourOutliers(ir);
   ir.analyses.segments.hour.forEach(function classify(segment) {
     if (segment.kind === "range") {
-      windows.push("from " + getTime(
-        { hour: +segment.bounds[0], minute: 0 },
+      windows.push(rangeWindow(
+        +segment.bounds[0],
+        +segment.bounds[1],
+        0,
         opts
-      ) + through(opts) + getTime({ hour: +segment.bounds[1], minute: 0 }, opts));
-    } else if (segment.kind === "step") {
-      singles.push(...segment.fires);
-    } else {
-      singles.push(+segment.value);
+      ));
     }
   });
-  let phrase = "every hour " + joinList(windows, opts);
-  if (singles.length) {
-    phrase += " and at " + joinList(singles.map(function time(hour) {
-      return getTime({ hour, minute: 0 }, opts);
-    }), opts);
-  }
-  return phrase;
+  const phrase = "every hour " + joinList(windows, opts);
+  const times = outliers.hours.map(function time(hour) {
+    return getTime({ hour, minute: 0 }, opts);
+  });
+  return phrase + outlierTail(times, outliers.pureStrays, opts);
 }
 function hourRangeCadence(ir, minute, opts) {
   if (minute !== 0 || !hasHourWindow(ir)) {
@@ -708,25 +879,29 @@ function hourRangeCadence(ir, minute, opts) {
   }
   return hourCadenceLead(ir, minute, opts) + ", " + hourRangeWindowTail(ir, opts) + trailingQualifier(ir, opts);
 }
-function seriesNumber(values, opts) {
-  const anyBig = values.some(function big(v) {
-    return +v > 10;
-  });
+function seriesNumber() {
   return function format(n) {
-    return anyBig ? "" + n : getNumber(n, opts);
+    return "" + n;
+  };
+}
+function listNumber(count, opts) {
+  return count > 1 ? function asNumeral(n) {
+    return "" + n;
+  } : function spelled(n) {
+    return getNumber(n, opts);
   };
 }
 function numberWords(fires, opts) {
-  return fires.map(seriesNumber(fires, opts));
+  return fires.map(listNumber(fires.length, opts));
 }
 function segmentWords(segments, opts) {
-  const values = segments.flatMap(function collect(segment) {
+  const count = segments.reduce(function tally(sum, segment) {
     if (segment.kind === "range") {
-      return segment.bounds;
+      return sum + 1;
     }
-    return segment.kind === "step" ? segment.fires : [segment.value];
-  });
-  const num = seriesNumber(values, opts);
+    return sum + (segment.kind === "step" ? segment.fires.length : 1);
+  }, 0);
+  const num = listNumber(count, opts);
   return segments.flatMap(function word(segment) {
     if (segment.kind === "range") {
       return [num(segment.bounds[0]) + through(opts) + num(segment.bounds[1])];
@@ -758,6 +933,9 @@ function hourTimes(hours, opts) {
   });
   return joinList(times, opts);
 }
+function singleHourFire(times) {
+  return times.kind === "fires" && times.fires.length === 1;
+}
 function hourTimesFromPlan(ir, times, atContext, opts) {
   if (times.kind === "fires") {
     return hourTimes(times.fires, opts);
@@ -805,28 +983,47 @@ function disambiguateTimes(pieces, segments, atContext) {
     return index === 0 ? piece : "at " + piece;
   });
 }
-function joinList(items, opts) {
+function joinWith(items, conjunction, opts) {
   if (items.length <= 1) {
     return items.join("");
   }
   if (items.length === 2) {
-    return items[0] + " and " + items[1];
+    return items[0] + conjunction + items[1];
   }
-  const and = opts.style.serialComma ? ", and " : " and ";
-  return items.slice(0, -1).join(", ") + and + items[items.length - 1];
+  const tail = opts.style.serialComma ? "," + conjunction : conjunction;
+  return items.slice(0, -1).join(", ") + tail + items[items.length - 1];
 }
-var trailingWords = { all: "", month: "in ", stepDate: "on ", weekday: "on " };
+function joinList(items, opts) {
+  return joinWith(items, " and ", opts);
+}
+function joinOr(items, opts) {
+  return joinWith(items, " or ", opts);
+}
+var trailingWords = {
+  all: "",
+  month: "in ",
+  recurringWeekday: true,
+  stepDate: "on ",
+  weekday: "on "
+};
 var leadingWords = {
   all: "every day",
   month: "every day in ",
+  recurringWeekday: false,
   stepDate: "",
   weekday: "every "
 };
 function trailingQualifier(ir, opts) {
+  if (isDayUnion(ir, opts)) {
+    return dayUnionCondition(ir, opts);
+  }
   const phrase = dayQualifier(ir, trailingWords, opts);
   return phrase && " " + phrase;
 }
 function interpretDayQualifier(ir, opts) {
+  if (isDayUnion(ir, opts)) {
+    return "";
+  }
   return dayQualifier(ir, leadingWords, opts) + " ";
 }
 function dayQualifier(ir, words, opts) {
@@ -838,7 +1035,11 @@ function dayQualifier(ir, words, opts) {
     return datePhrase(ir, words, opts);
   }
   if (pattern.weekday !== "*") {
-    const weekdays = quartzWeekdayPhrase(pattern.weekday, opts) || words.weekday + weekdayPhrase(ir, opts);
+    const quartzWeekday = quartzWeekdayPhrase(pattern.weekday, opts);
+    if (quartzWeekday) {
+      return monthScopeForRecurrence(quartzWeekday, ir, opts);
+    }
+    const weekdays = words.weekday + weekdayPhrase(ir, words.recurringWeekday, opts);
     return weekdays + monthScope(ir, opts);
   }
   if (pattern.month !== "*") {
@@ -850,10 +1051,14 @@ function datePhrase(ir, words, opts) {
   const pattern = ir.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
   if (quartzDate) {
-    return quartzDate + monthScope(ir, opts);
+    return monthScopeForRecurrence(quartzDate, ir, opts);
   }
   if (isOpenStep(pattern.date)) {
-    return words.stepDate + stepDates(pattern.date) + monthScope(ir, opts);
+    return monthScopeForRecurrence(
+      words.stepDate + stepDates(pattern.date),
+      ir,
+      opts
+    );
   }
   if (pattern.month !== "*" && !monthFoldsIntoDate(ir)) {
     return "on the " + dateOrdinals(ir, opts) + monthScope(ir, opts);
@@ -869,20 +1074,105 @@ function monthFoldsIntoDate(ir) {
     return segment.kind !== "range";
   });
 }
+function isDayUnion(ir, opts) {
+  return ir.pattern.date !== "*" && ir.pattern.weekday !== "*" && !!opts.style.untilWindow && !opts.short;
+}
+function dayUnionCondition(ir, opts) {
+  const pieces = [
+    ...dayUnionDatePieces(ir, opts),
+    ...dayUnionWeekdayPieces(ir, opts)
+  ];
+  return " whenever the day is " + joinOr(pieces, opts);
+}
+function dayUnionMonthLead(ir, opts) {
+  if (ir.pattern.month === "*") {
+    return "";
+  }
+  return "in " + monthName(ir, opts) + " ";
+}
+function dayUnionDatePieces(ir, opts) {
+  const dateField = ir.pattern.date;
+  const quartz = quartzDatePhrase(dateField, opts);
+  if (quartz) {
+    return [quartz.replace(/^on /, "")];
+  }
+  const oddEven = oddEvenDay(dateField);
+  if (oddEven) {
+    return [oddEven];
+  }
+  const pieces = [];
+  ir.analyses.segments.date.forEach(function expand(segment) {
+    if (segment.kind === "range") {
+      pieces.push("from the " + getOrdinal(segment.bounds[0]) + through(opts) + "the " + getOrdinal(segment.bounds[1]));
+    } else if (segment.kind === "step") {
+      segment.fires.forEach(function fire(value) {
+        pieces.push("the " + getOrdinal(value));
+      });
+    } else {
+      pieces.push("the " + getOrdinal(segment.value));
+    }
+  });
+  return pieces;
+}
+function dayUnionWeekdayPieces(ir, opts) {
+  const weekdayField = ir.pattern.weekday;
+  const quartz = quartzWeekdayPhrase(weekdayField, opts);
+  if (quartz) {
+    return [quartz.replace(/^on /, "")];
+  }
+  const pieces = [];
+  ir.analyses.segments.weekday.forEach(function expand(segment) {
+    if (segment.kind === "range" && segment.bounds[0] === "1" && segment.bounds[1] === "5") {
+      pieces.push("a weekday");
+    } else if (segment.kind === "range") {
+      pieces.push("a " + getWeekday(segment.bounds[0], opts) + through(opts) + "a " + getWeekday(segment.bounds[1], opts));
+    } else if (segment.kind === "step") {
+      segment.fires.forEach(function fire(value) {
+        pieces.push("a " + getWeekday(value, opts));
+      });
+    } else {
+      pieces.push("a " + getWeekday(segment.value, opts));
+    }
+  });
+  return pieces;
+}
+function oddEvenDay(dateField) {
+  if (!isOpenStep(dateField)) {
+    return null;
+  }
+  const [start, step] = dateField.split("/");
+  if (+step !== 2) {
+    return null;
+  }
+  if (start === "*" || start === "1") {
+    return "an odd-numbered day";
+  }
+  return start === "2" ? "an even-numbered day" : null;
+}
 function dateOrWeekday(ir, opts) {
   const pattern = ir.pattern;
-  const weekdayPart = quartzWeekdayPhrase(pattern.weekday, opts) || "on " + weekdayPhrase(ir, opts);
+  const weekdayPart = quartzWeekdayPhrase(pattern.weekday, opts) || "on " + weekdayPhrase(ir, false, opts);
+  if (pattern.month !== "*" && monthFoldsIntoDate(ir) && !quartzDatePhrase(pattern.date, opts) && !isOpenStep(pattern.date)) {
+    return "on " + monthDatePhrase(ir, opts) + " or " + weekdayPart + " in " + monthName(ir, opts);
+  }
+  return datePart(ir, opts) + " or " + weekdayPart + orMonthScope(ir, opts);
+}
+function datePart(ir, opts) {
+  const pattern = ir.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
   if (quartzDate) {
-    return quartzDate + monthScope(ir, opts) + " or " + weekdayPart;
+    return quartzDate;
   }
   if (isOpenStep(pattern.date)) {
-    return stepDates(pattern.date) + monthScope(ir, opts) + " or " + weekdayPart;
+    return stepDates(pattern.date);
   }
-  if (pattern.month !== "*" && monthFoldsIntoDate(ir)) {
-    return "on " + monthDatePhrase(ir, opts) + " or " + weekdayPart + " in " + monthName(ir, opts);
+  return "on the " + dateOrdinals(ir, opts);
+}
+function orMonthScope(ir, opts) {
+  if (ir.pattern.month === "*") {
+    return "";
   }
-  return "on the " + dateOrdinals(ir, opts) + " or " + weekdayPart + monthScope(ir, opts);
+  return ", in " + monthName(ir, opts);
 }
 function quartzDatePhrase(dateField, opts) {
   if (dateField === "L") {
@@ -916,6 +1206,9 @@ function monthDatePhrase(ir, opts) {
     opts.style.ordinals ? getOrdinal : cardinalDay,
     opts
   );
+  if (opts.style.dayFirst && ir.shapes.date === "single" && ir.shapes.month !== "single") {
+    return "the " + getOrdinal(ir.pattern.date) + " of " + month;
+  }
   return opts.style.dayFirst ? days + " " + month : month + " " + days;
 }
 function cardinalDay(value) {
@@ -927,6 +1220,19 @@ function monthScope(ir, opts) {
   }
   return " in " + monthName(ir, opts);
 }
+function monthScopeForRecurrence(phrase, ir, opts) {
+  if (ir.pattern.month === "*") {
+    return phrase;
+  }
+  const carriesRecurrence = phrase.indexOf(" of the month") !== -1;
+  if (carriesRecurrence && ir.shapes.month === "range") {
+    return phrase.replace(" of the month", " of each month") + " from " + monthName(ir, opts);
+  }
+  if (carriesRecurrence && (ir.shapes.month === "single" || ir.shapes.month === "step")) {
+    return phrase.replace(" of the month", "") + " in " + monthName(ir, opts);
+  }
+  return phrase + " in " + monthName(ir, opts);
+}
 function stepDates(dateField) {
   const parts = dateField.split("/");
   const interval = +parts[1];
@@ -963,10 +1269,21 @@ function oddEvenMonth(monthField) {
   }
   return start === "2" ? "every even-numbered month" : null;
 }
-function weekdayPhrase(ir, opts) {
-  return renderSegments(ir.analyses.segments.weekday, function name(value) {
+function weekdayPhrase(ir, recurring, opts) {
+  const segments = orderWeekdaysForDisplay(ir.analyses.segments.weekday);
+  const hasRange = segments.some(function range(segment) {
+    return segment.kind === "range";
+  });
+  const name = recurring && !hasRange ? function plural(value) {
+    return pluralWeekday(value, opts);
+  } : function singular(value) {
     return getWeekday(value, opts);
-  }, opts);
+  };
+  return renderSegments(segments, name, opts);
+}
+function pluralWeekday(value, opts) {
+  const name = getWeekday(value, opts);
+  return opts.short ? name : name + "s";
 }
 function renderSegments(segments, word, opts) {
   const pieces = [];
@@ -990,7 +1307,7 @@ function applyYear(description, ir, opts) {
     return description;
   }
   if (yearField.indexOf("/") !== -1) {
-    return description + " " + stepYears(yearField, opts);
+    return description + ", " + stepYears(yearField, opts);
   }
   const label = yearLabel(yearField, opts);
   if (yearField.indexOf("-") === -1 && yearField.indexOf(",") === -1 && ir.pattern.date !== "*" && description.indexOf(" at ") !== -1) {
@@ -1003,6 +1320,9 @@ function yearLabel(yearField, opts) {
   if (yearField.indexOf(",") !== -1) {
     return joinList(yearField.split(","), opts);
   }
+  if (yearField.indexOf("-") !== -1) {
+    return yearField.split("-").join(through(opts));
+  }
   return yearField;
 }
 function stepYears(yearField, opts) {
@@ -1012,7 +1332,7 @@ function stepYears(yearField, opts) {
   if (interval <= 1) {
     return "every year";
   }
-  let phrase = "every " + getNumber(interval, opts) + " years";
+  let phrase = interval === 2 ? "every other year" : "every " + getNumber(interval, opts) + " years";
   if (start !== "*" && start !== "0") {
     phrase += " from " + start;
   }