cronli5 0.2.1 → 0.3.1

package/dist/lang/de.cjs

@@ -42,11 +42,7 @@ var weekdayNumbers = {
 };
 var maxClockTimes = 6;
 
-// src/core/util.ts
-function isNonNegativeInteger(value) {
-  const digits = /^\d+$/;
-  return digits.test(value);
-}
+// src/core/cadence.ts
 function arithmeticStep(values) {
   if (values.length < 5) {
     return null;
@@ -62,34 +58,11 @@ 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];
-  });
-}
-function toFieldNumber(token, numberMap) {
-  return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
+function segmentsOf(schedule, field) {
+  return schedule.analyses.segments[field] ?? [];
 }
-function segmentsOf(ir, field) {
-  return ir.analyses.segments[field] ?? [];
-}
-function stepSegment(ir, field) {
-  return segmentsOf(ir, field)[0];
+function stepSegment(schedule, field) {
+  return segmentsOf(schedule, field)[0];
 }
 function singleValues(segments) {
   const values = [];
@@ -104,6 +77,17 @@ function singleValues(segments) {
 function offsetCleanStride(stride) {
   return stride.start < stride.interval && 24 % stride.interval === 0;
 }
+function renderStride(spec, parts) {
+  const { start, interval, cycle } = spec;
+  const tiles = cycle % interval === 0;
+  if (start === 0 && tiles) {
+    return parts.bare();
+  }
+  if (start < interval && tiles) {
+    return parts.offset();
+  }
+  return parts.bounded();
+}
 function hourListStride(values) {
   if (values.length < 2) {
     return null;
@@ -123,6 +107,42 @@ function hourListStride(values) {
   return { interval, last: values[values.length - 1], start: values[0] };
 }
 
+// src/core/weekday.ts
+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/util.ts
+function isNonNegativeInteger(value) {
+  const digits = /^\d+$/;
+  return digits.test(value);
+}
+function toFieldNumber(token, numberMap) {
+  return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
+}
+
+// src/core/shapes.ts
+function isOpenStep(field) {
+  return field.indexOf("/") !== -1 && field.indexOf("-") === -1 && field.indexOf(",") === -1;
+}
+
 // src/lang/de/dialects.ts
 var months = [
   null,
@@ -185,18 +205,15 @@ function withAnchor(clause, anchor) {
 function cleanStep(segment, cycle) {
   return (segment.startToken === "*" || +segment.startToken === 0) && cycle % segment.interval === 0;
 }
-function renderStride(stride) {
+function renderStride2(stride) {
   const { interval, start, last, cycle, unit, anchor } = stride;
   const cadence = everyN(interval, unit);
-  const tiles = cycle % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence;
-  }
   const tail = anchor ? " " + anchor : "";
-  if (start < interval && tiles) {
-    return cadence + " ab " + unit.singular + " " + start + tail;
-  }
-  return cadence + " von " + unit.singular + " " + start + " bis " + last + tail;
+  return renderStride({ start, interval, cycle }, {
+    bare: () => cadence,
+    offset: () => cadence + " ab " + unit.singular + " " + start + tail,
+    bounded: () => cadence + " von " + unit.singular + " " + start + " bis " + last + tail
+  });
 }
 function stepClause(segment, unit, anchor) {
   const start = segment.startToken === "*" ? 0 : +segment.startToken;
@@ -207,7 +224,7 @@ function stepClause(segment, unit, anchor) {
       anchor
     );
   }
-  return renderStride({
+  return renderStride2({
     interval: segment.interval,
     start,
     last: segment.fires[segment.fires.length - 1],
@@ -219,7 +236,7 @@ function stepClause(segment, unit, anchor) {
 function strideFromSegments(segments, unit, anchor) {
   const values = singleValues(segments);
   const step = values && arithmeticStep(values);
-  return step ? renderStride({ ...step, cycle: 60, unit, anchor }) : null;
+  return step ? renderStride2({ ...step, cycle: 60, unit, anchor }) : null;
 }
 var weekdayNames = [
   "sonntags",
@@ -252,8 +269,8 @@ function weekdayName(token) {
 function weekdayRange(bounds) {
   return weekdayName(bounds[0]) + " bis " + weekdayName(bounds[1]);
 }
-function weekdayQualifier(ir) {
-  const segments = orderWeekdaysForDisplay(segmentsOf(ir, "weekday"));
+function weekdayQualifier(schedule) {
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, "weekday"));
   if (segments.length === 1 && segments[0].kind === "range") {
     return weekdayRange(segments[0].bounds);
   }
@@ -316,26 +333,39 @@ function quartzDate(field) {
   }
   return null;
 }
+function oddEvenDay(dateField) {
+  if (!isOpenStep(dateField)) {
+    return null;
+  }
+  const [start, step] = dateField.split("/");
+  if (+step !== 2) {
+    return null;
+  }
+  if (start === "*" || start === "1") {
+    return "an jedem ungeraden Tag des Monats";
+  }
+  return start === "2" ? "an jedem geraden Tag des Monats" : null;
+}
 function monthName(token, months2) {
   return months2[+token];
 }
 function monthRange(bounds, months2) {
   return "von " + monthName(bounds[0], months2) + " bis " + monthName(bounds[1], months2);
 }
-function monthNamesList(ir, months2) {
-  return joinList(flattenSteps(segmentsOf(ir, "month")).map(function name(segment) {
+function monthNamesList(schedule, months2) {
+  return joinList(flattenSteps(segmentsOf(schedule, "month")).map(function name(segment) {
     return segment.kind === "range" ? monthRange(segment.bounds, months2) : monthName(segment.value, months2);
   }));
 }
-function monthClause(ir, months2) {
-  const segments = flattenSteps(segmentsOf(ir, "month"));
+function monthClause(schedule, months2) {
+  const segments = flattenSteps(segmentsOf(schedule, "month"));
   if (segments.length === 1 && segments[0].kind === "range") {
     return monthRange(segments[0].bounds, months2);
   }
-  return "im " + monthNamesList(ir, months2);
+  return "im " + monthNamesList(schedule, months2);
 }
-function monthScope(ir, months2) {
-  return ir.pattern.month === "*" ? "" : " " + monthClause(ir, months2);
+function monthScope(schedule, months2) {
+  return schedule.pattern.month === "*" ? "" : " " + monthClause(schedule, months2);
 }
 function ordinalDay(value) {
   return value + ".";
@@ -343,8 +373,8 @@ function ordinalDay(value) {
 function dateRange(bounds) {
   return "vom " + ordinalDay(bounds[0]) + " bis zum " + ordinalDay(bounds[1]);
 }
-function dateClauseBare(ir) {
-  const segments = flattenSteps(segmentsOf(ir, "date"));
+function dateClauseBare(schedule) {
+  const segments = flattenSteps(segmentsOf(schedule, "date"));
   if (segments.length === 1 && segments[0].kind === "range") {
     return dateRange(segments[0].bounds);
   }
@@ -357,13 +387,13 @@ function dateClauseBare(ir) {
     return segment.kind === "range" ? dateRange(segment.bounds) : "am " + ordinalDay(segment.value);
   }));
 }
-function datePhrase(ir, months2) {
-  const clause = dateClauseBare(ir);
-  if (ir.pattern.month === "*") {
+function datePhrase(schedule, months2) {
+  const clause = dateClauseBare(schedule);
+  if (schedule.pattern.month === "*") {
     return clause;
   }
-  const monthRanged = flattenSteps(segmentsOf(ir, "month")).some((segment) => segment.kind === "range");
-  return monthRanged ? clause + ", " + monthClause(ir, months2) : clause + " " + monthNamesList(ir, months2);
+  const monthRanged = flattenSteps(segmentsOf(schedule, "month")).some((segment) => segment.kind === "range");
+  return monthRanged ? clause + ", " + monthClause(schedule, months2) : clause + " " + monthNamesList(schedule, months2);
 }
 function bareTime(time, sep) {
   if (time.second) {
@@ -382,32 +412,35 @@ function timesPhrase(times, sep) {
 function hourWindow(from, to, last, sep) {
   return "von " + bareTime({ hour: from, minute: 0 }, sep) + " bis " + bareTime({ hour: to, minute: last }, sep) + " Uhr";
 }
-function fieldValues(ir, field) {
-  return flattenSteps(segmentsOf(ir, field)).map(function value(segment) {
+function fieldValues(schedule, field) {
+  return flattenSteps(segmentsOf(schedule, field)).map(function value(segment) {
     return segment.kind === "range" ? segment.bounds[0] + " bis " + segment.bounds[1] : String(segment.value);
   });
 }
-function countedPhrase(ir, field, singular, plural) {
-  if (ir.shapes[field] === "single") {
-    return "in " + singular + " " + ir.pattern[field];
+function countedPhrase(schedule, field, singular, plural) {
+  if (schedule.shapes[field] === "single") {
+    return "in " + singular + " " + schedule.pattern[field];
   }
-  return "in den " + plural + " " + joinList(fieldValues(ir, field));
+  return "in den " + plural + " " + joinList(fieldValues(schedule, field));
 }
-function minuteAnchor(ir) {
-  return ir.pattern.minute === "*" ? "jeder Minute" : "";
+function minuteAnchor(schedule) {
+  return schedule.pattern.minute === "*" ? "jeder Minute" : "";
 }
-function secondsLead(ir) {
-  return secondsClause(ir, minuteAnchor(ir));
+function secondsLead(schedule) {
+  return secondsClause(schedule, minuteAnchor(schedule));
 }
-function secondsClause(ir, anchor) {
-  if (ir.pattern.second === "*") {
+function secondsClause(schedule, anchor) {
+  if (schedule.pattern.second === "*") {
     return "jede Sekunde";
   }
-  const segments = ir.analyses.segments.second;
-  if (ir.shapes.second === "step") {
-    return stepClause(stepSegment(ir, "second"), UNITS.second, anchor);
+  const segments = schedule.analyses.segments.second;
+  if (schedule.shapes.second === "step") {
+    return stepClause(stepSegment(schedule, "second"), UNITS.second, anchor);
   }
-  return strideFromSegments(segments, UNITS.second, anchor) ?? withAnchor(countedPhrase(ir, "second", "Sekunde", "Sekunden"), anchor);
+  return strideFromSegments(segments, UNITS.second, anchor) ?? withAnchor(
+    countedPhrase(schedule, "second", "Sekunde", "Sekunden"),
+    anchor
+  );
 }
 function spanTime(hour, minute, sep) {
   return hour + sep + pad(minute);
@@ -415,8 +448,8 @@ function spanTime(hour, minute, sep) {
 function atHours(hours) {
   return "um " + joinList(hours.map(String)) + " Uhr";
 }
-function hourFires(ir) {
-  return flattenSteps(segmentsOf(ir, "hour")).map(function fire(segment) {
+function hourFires(schedule) {
+  return flattenSteps(segmentsOf(schedule, "hour")).map(function fire(segment) {
     return segment.kind === "range" ? +segment.bounds[0] : +segment.value;
   });
 }
@@ -426,8 +459,8 @@ function partTime(hour, minute, second, sep) {
   }
   return minute === 0 ? String(hour) : hour + sep + pad(minute);
 }
-function hourSegmentParts(ir, minute, second, sep) {
-  return segmentsOf(ir, "hour").map(function part(segment) {
+function hourSegmentParts(schedule, minute, second, sep) {
+  return segmentsOf(schedule, "hour").map(function part(segment) {
     if (segment.kind === "range") {
       return "von " + partTime(+segment.bounds[0], minute, second, sep) + " bis " + partTime(+segment.bounds[1], minute, second, sep) + " Uhr";
     }
@@ -439,13 +472,13 @@ function hourSegmentParts(ir, minute, second, sep) {
     return "um " + partTime(+segment.value, minute, second, sep) + " Uhr";
   });
 }
-function duringWindows(ir, times, sep) {
+function duringWindows(schedule, times, sep) {
   if (times.kind === "fires") {
     return times.fires.map(function each(hour) {
       return hourWindow(hour, hour, 59, sep);
     });
   }
-  return segmentsOf(ir, "hour").flatMap(function part(segment) {
+  return segmentsOf(schedule, "hour").flatMap(function part(segment) {
     if (segment.kind === "range") {
       return [hourWindow(+segment.bounds[0], +segment.bounds[1], 59, sep)];
     }
@@ -457,8 +490,8 @@ function duringWindows(ir, times, sep) {
     return [hourWindow(+segment.value, +segment.value, 59, sep)];
   });
 }
-function duringHours(ir, times, sep) {
-  const windows = duringWindows(ir, times, sep);
+function duringHours(schedule, times, sep) {
+  const windows = duringWindows(schedule, times, sep);
   if (windows.length <= 3 || times.kind !== "fires") {
     return joinList(windows);
   }
@@ -473,24 +506,24 @@ function renderEveryMinute() {
 function renderEveryHour() {
   return everyUnit(UNITS.hour);
 }
-function renderSeconds(ir) {
-  return secondsLead(ir);
+function renderSeconds(schedule) {
+  return secondsLead(schedule);
 }
-function minutePastClause(ir) {
+function minutePastClause(schedule) {
   return strideFromSegments(
-    segmentsOf(ir, "minute"),
+    segmentsOf(schedule, "minute"),
     UNITS.minute,
     "jeder Stunde"
-  ) ?? countedPhrase(ir, "minute", "Minute", "Minuten") + " jeder Stunde";
+  ) ?? countedPhrase(schedule, "minute", "Minute", "Minuten") + " jeder Stunde";
 }
-function renderMinutePast(ir) {
-  return minutePastClause(ir);
+function renderMinutePast(schedule) {
+  return minutePastClause(schedule);
 }
-function renderSecondsWithinMinute(ir, plan) {
+function renderSecondsWithinMinute(schedule, plan) {
   if (plan.singleSecond) {
-    return "in Minute " + ir.pattern.minute + " und Sekunde " + ir.pattern.second + " jeder Stunde";
+    return "in Minute " + schedule.pattern.minute + " und Sekunde " + schedule.pattern.second + " jeder Stunde";
   }
-  return secondsLead(ir) + ", in Minute " + ir.pattern.minute + " jeder Stunde";
+  return secondsLead(schedule) + ", in Minute " + schedule.pattern.minute + " jeder Stunde";
 }
 function wholeHour(hour) {
   if (hour === 0) {
@@ -501,39 +534,39 @@ function wholeHour(hour) {
   }
   return "der " + hour + "-Uhr-Stunde";
 }
-function renderMinuteSpanInHour(ir, plan, opts) {
-  if (ir.pattern.minute === "*") {
+function renderMinuteSpanInHour(schedule, plan, opts) {
+  if (schedule.pattern.minute === "*") {
     return "jede Minute " + wholeHour(plan.hour);
   }
   const sep = opts.style.sep;
   return "jede Minute von " + spanTime(plan.hour, plan.span[0], sep) + " bis " + spanTime(plan.hour, plan.span[1], sep) + " Uhr";
 }
-function isEveryOtherMinuteSeconds(ir, plan) {
-  if (plan.rest.kind !== "minuteFrequency" || ir.shapes.second !== "wildcard" || ir.shapes.hour !== "wildcard") {
+function isEveryOtherMinuteSeconds(schedule, plan) {
+  if (plan.rest.kind !== "minuteFrequency" || schedule.shapes.second !== "wildcard" || schedule.shapes.hour !== "wildcard") {
     return false;
   }
-  const minuteStep = stepSegment(ir, "minute");
+  const minuteStep = stepSegment(schedule, "minute");
   return minuteStep.startToken === "*" && minuteStep.interval === 2;
 }
-function renderComposeSeconds(ir, plan, opts) {
-  if ((plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes") && ir.shapes.minute === "single") {
-    const minute = +ir.pattern.minute;
-    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
+function renderComposeSeconds(schedule, plan, opts) {
+  if ((plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes") && schedule.shapes.minute === "single") {
+    const minute = +schedule.pattern.minute;
+    const cadence = hourCadence(schedule, minute) ?? hourRangeCadence(schedule, minute);
     if (cadence !== null) {
       return cadence;
     }
   }
-  if (composeMinuteZero(ir, plan)) {
-    return secondsLead(ir) + " " + clockMinuteGenitive(plan.rest.times, opts.style.sep);
+  if (composeMinuteZero(schedule, plan)) {
+    return secondsLead(schedule) + " " + clockMinuteGenitive(plan.rest.times, opts.style.sep);
   }
-  if (isEveryOtherMinuteSeconds(ir, plan)) {
-    return secondsLead(ir) + " jeder zweiten Minute";
+  if (isEveryOtherMinuteSeconds(schedule, plan)) {
+    return secondsLead(schedule) + " jeder zweiten Minute";
   }
-  const restOwnsLead = plan.rest.kind === "compactClockTimes" && ir.analyses.clockSecond;
-  const lead = restOwnsLead ? "" : secondsLead(ir) + ", ";
-  return lead + render(ir, plan.rest, opts);
+  const restOwnsLead = plan.rest.kind === "compactClockTimes" && schedule.analyses.clockSecond;
+  const lead = restOwnsLead ? "" : secondsLead(schedule) + ", ";
+  return lead + render(schedule, plan.rest, opts);
 }
-function composeMinuteZero(ir, plan) {
+function composeMinuteZero(schedule, plan) {
   return plan.rest.kind === "clockTimes" && plan.rest.times.every((time) => +time.minute === 0);
 }
 function clockMinuteGenitive(times, sep) {
@@ -542,44 +575,49 @@ function clockMinuteGenitive(times, sep) {
   });
   return clocks.length === 1 ? "der Minute " + clocks[0] : "der Minuten " + joinList(clocks);
 }
-function renderMinutesAcrossHours(ir, plan, opts) {
+function renderMinutesAcrossHours(schedule, plan, opts) {
   const sep = opts.style.sep;
-  const cadence = unevenHourCadence(ir);
+  const cadence = unevenHourCadence(schedule);
   if (plan.form === "wildcard") {
-    return cadence ? "jede Minute, " + cadence : "jede Minute " + duringHours(ir, plan.times, sep);
+    return cadence ? "jede Minute, " + cadence : "jede Minute " + duringHours(schedule, plan.times, sep);
   }
-  const minuteLead = strideFromSegments(segmentsOf(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten");
+  const minuteLead = strideFromSegments(segmentsOf(schedule, "minute"), UNITS.minute, "") ?? countedPhrase(schedule, "minute", "Minute", "Minuten");
   if (cadence !== null) {
     return minuteLead + ", " + cadence;
   }
-  const hours = plan.times.kind === "fires" ? atHours(plan.times.fires) : joinList(hourSegmentParts(ir, 0, 0, sep));
+  const hours = plan.times.kind === "fires" ? atHours(plan.times.fires) : joinList(hourSegmentParts(schedule, 0, 0, sep));
   return minuteLead + ", " + hours;
 }
-function renderMinuteSpanAcrossHourStep(ir, plan) {
-  const cadence = unevenHourCadence(ir);
+function renderMinuteSpanAcrossHourStep(schedule, plan) {
+  const cadence = unevenHourCadence(schedule);
   if (plan.form === "wildcard") {
-    return "jede Minute " + everyNthHour(stepSegment(ir, "hour"));
+    return "jede Minute " + everyNthHour(stepSegment(schedule, "hour"));
   }
-  const segment = stepSegment(ir, "hour");
+  const segment = stepSegment(schedule, "hour");
   const hours = cadence ?? (confinedHourStride(segment) ? everyNthHour(segment) : atHours(segment.fires));
-  return (strideFromSegments(segmentsOf(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten")) + ", " + hours;
+  return (strideFromSegments(segmentsOf(schedule, "minute"), UNITS.minute, "") ?? countedPhrase(schedule, "minute", "Minute", "Minuten")) + ", " + hours;
 }
-function renderCompactClockTimes(ir, plan, opts) {
+function renderCompactClockTimes(schedule, plan, opts) {
   const sep = opts.style.sep;
   if (plan.fold) {
-    const cadence = hourCadence(ir, plan.minute) ?? hourRangeCadence(ir, plan.minute);
+    const cadence = hourCadence(schedule, plan.minute) ?? hourRangeCadence(schedule, plan.minute);
     if (cadence !== null) {
       return cadence;
     }
-    const hourly = segmentsOf(ir, "hour").some((segment) => segment.kind === "range");
-    return (hourly ? "st\xFCndlich " : "t\xE4glich ") + joinList(hourSegmentParts(ir, plan.minute, ir.analyses.clockSecond, sep));
+    const hourly = segmentsOf(schedule, "hour").some((segment) => segment.kind === "range");
+    return (hourly ? "st\xFCndlich " : "t\xE4glich ") + joinList(hourSegmentParts(
+      schedule,
+      plan.minute,
+      schedule.analyses.clockSecond,
+      sep
+    ));
   }
-  const hours = unevenHourCadence(ir) ?? (segmentsOf(ir, "hour").some((segment) => segment.kind === "range") ? joinList(hourSegmentParts(ir, 0, 0, sep)) : atHours(hourFires(ir)));
-  const lead = ir.analyses.clockSecond ? countedPhrase(ir, "second", "Sekunde", "Sekunden") + ", " : "";
-  return lead + (strideFromSegments(segmentsOf(ir, "minute"), UNITS.minute, "") ?? countedPhrase(ir, "minute", "Minute", "Minuten")) + ", " + hours;
+  const hours = unevenHourCadence(schedule) ?? (segmentsOf(schedule, "hour").some((segment) => segment.kind === "range") ? joinList(hourSegmentParts(schedule, 0, 0, sep)) : atHours(hourFires(schedule)));
+  const lead = schedule.analyses.clockSecond ? countedPhrase(schedule, "second", "Sekunde", "Sekunden") + ", " : "";
+  return lead + (strideFromSegments(segmentsOf(schedule, "minute"), UNITS.minute, "") ?? countedPhrase(schedule, "minute", "Minute", "Minuten")) + ", " + hours;
 }
-function renderMinuteFrequency(ir, plan, opts) {
-  const segment = stepSegment(ir, "minute");
+function renderMinuteFrequency(schedule, plan, opts) {
+  const segment = stepSegment(schedule, "minute");
   const sep = opts.style.sep;
   const clean = cleanStep(segment, 60);
   if (plan.hours.kind === "window") {
@@ -599,47 +637,44 @@ function renderMinuteFrequency(ir, plan, opts) {
   }
   const base = stepClause(segment, UNITS.minute, "jeder Stunde");
   if (plan.hours.kind === "during") {
-    const cadence = unevenHourCadence(ir);
-    return cadence ? base + ", " + cadence : base + " " + duringHours(ir, plan.hours.times, sep);
+    const cadence = unevenHourCadence(schedule);
+    return cadence ? base + ", " + cadence : base + " " + duringHours(schedule, plan.hours.times, sep);
   }
   if (plan.hours.kind === "step") {
-    return base + " " + everyNthHour(stepSegment(ir, "hour"));
+    return base + " " + everyNthHour(stepSegment(schedule, "hour"));
   }
   return base;
 }
-function hourStepPhrase(ir) {
-  const cadence = unevenHourCadence(ir);
+function hourStepPhrase(schedule) {
+  const cadence = unevenHourCadence(schedule);
   if (cadence !== null) {
     return cadence;
   }
-  const segment = stepSegment(ir, "hour");
+  const segment = stepSegment(schedule, "hour");
   if (cleanStep(segment, 24)) {
     return everyN(segment.interval, UNITS.hour);
   }
-  const stride = openOffsetCleanStride(ir, segment);
+  const stride = openOffsetCleanStride(schedule, segment);
   return stride ? hourStrideCadence(stride) : atHours(segment.fires);
 }
-function openOffsetCleanStride(ir, segment) {
+function openOffsetCleanStride(schedule, segment) {
   if (segment.startToken.indexOf("-") !== -1) {
     return null;
   }
-  const stride = hourStride(ir);
+  const stride = hourStride(schedule);
   return stride && offsetCleanStride(stride) ? stride : null;
 }
 function hourStrideCadence(stride) {
   const { start, interval, last } = stride;
   const cadence = everyN(interval, UNITS.hour);
-  const tiles = 24 % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence;
-  }
-  if (start < interval && tiles) {
-    return cadence + " ab " + start + " Uhr";
-  }
-  return cadence + " von " + start + " bis " + last + " Uhr";
+  return renderStride({ start, interval, cycle: 24 }, {
+    bare: () => cadence,
+    offset: () => cadence + " ab " + start + " Uhr",
+    bounded: () => cadence + " von " + start + " bis " + last + " Uhr"
+  });
 }
-function hourStride(ir) {
-  const segments = segmentsOf(ir, "hour");
+function hourStride(schedule) {
+  const segments = segmentsOf(schedule, "hour");
   if (!segments) {
     return null;
   }
@@ -654,89 +689,95 @@ function hourStride(ir) {
   const values = singleValues(segments);
   return values && hourListStride(values);
 }
-function unevenHourCadence(ir) {
-  const stride = hourStride(ir);
+function unevenHourCadence(schedule) {
+  const stride = hourStride(schedule);
   if (!stride || offsetCleanStride(stride)) {
     return null;
   }
   return hourStrideCadence(stride);
 }
-function subMinuteSecond(ir) {
-  return ir.pattern.second === "*" || ir.shapes.second === "step";
+function subMinuteSecond(schedule) {
+  return schedule.pattern.second === "*" || schedule.shapes.second === "step";
 }
-function hourCadenceLead(ir, minute) {
+function hourCadenceLead(schedule, minute) {
   if (minute === 0) {
-    if (subMinuteSecond(ir)) {
-      return withAnchor(secondsClause(ir, minuteAnchor(ir)), "f\xFCr eine Minute");
+    if (subMinuteSecond(schedule)) {
+      return withAnchor(
+        secondsClause(schedule, minuteAnchor(schedule)),
+        "f\xFCr eine Minute"
+      );
     }
-    return secondsClause(ir, "jeder Stunde");
+    return secondsClause(schedule, "jeder Stunde");
   }
   const minutePhrase = "in Minute " + minute;
-  if (ir.pattern.second === "0") {
+  if (schedule.pattern.second === "0") {
     return minutePhrase;
   }
-  return secondsClause(ir, minuteAnchor(ir)) + ", " + minutePhrase;
+  return secondsClause(schedule, minuteAnchor(schedule)) + ", " + minutePhrase;
 }
-function hourCadence(ir, minute) {
-  const stride = hourStride(ir);
+function hourCadence(schedule, minute) {
+  const stride = hourStride(schedule);
   if (!stride) {
     return null;
   }
   const fires = (stride.last - stride.start) / stride.interval + 1;
-  if (ir.pattern.second === "0" && fires <= maxClockTimes && offsetCleanStride(stride)) {
+  if (schedule.pattern.second === "0" && fires <= maxClockTimes && offsetCleanStride(stride)) {
     return null;
   }
-  const segment = segmentsOf(ir, "hour")[0];
-  const confined = minute === 0 && subMinuteSecond(ir) && segmentsOf(ir, "hour").length === 1 && segment.kind === "step" && confinedHourStride(segment);
+  const segment = segmentsOf(schedule, "hour")[0];
+  const confined = minute === 0 && subMinuteSecond(schedule) && segmentsOf(schedule, "hour").length === 1 && segment.kind === "step" && confinedHourStride(segment);
   if (confined) {
-    return withAnchor(secondsClause(ir, minuteAnchor(ir)), "f\xFCr eine Minute") + " " + everyNthHour(segment);
+    return withAnchor(
+      secondsClause(schedule, minuteAnchor(schedule)),
+      "f\xFCr eine Minute"
+    ) + " " + everyNthHour(segment);
   }
-  if (minute === 0 && ir.pattern.second === "0") {
+  if (minute === 0 && schedule.pattern.second === "0") {
     return hourStrideCadence(stride);
   }
-  return hourCadenceLead(ir, minute) + ", " + hourStrideCadence(stride);
+  return hourCadenceLead(schedule, minute) + ", " + hourStrideCadence(stride);
 }
-function hourCadenceApplies(ir) {
-  if (ir.shapes.minute !== "single") {
+function hourCadenceApplies(schedule) {
+  if (schedule.shapes.minute !== "single") {
     return false;
   }
-  const minute = +ir.pattern.minute;
-  return hourCadence(ir, minute) !== null || hourRangeCadence(ir, minute) !== null;
+  const minute = +schedule.pattern.minute;
+  return hourCadence(schedule, minute) !== null || hourRangeCadence(schedule, minute) !== null;
 }
-function hasHourWindow(ir) {
-  const segments = segmentsOf(ir, "hour");
+function hasHourWindow(schedule) {
+  const segments = segmentsOf(schedule, "hour");
   return !!segments && segments.some(function range(segment) {
     return segment.kind === "range";
   });
 }
-function hourRangeCadence(ir, minute) {
-  if (minute !== 0 || !hasHourWindow(ir) || ir.pattern.second === "0") {
+function hourRangeCadence(schedule, minute) {
+  if (minute !== 0 || !hasHourWindow(schedule) || schedule.pattern.second === "0") {
     return null;
   }
-  return hourCadenceLead(ir, minute) + ", " + hourRangeWindowTail(ir);
+  return hourCadenceLead(schedule, minute) + ", " + hourRangeWindowTail(schedule);
 }
-function hourRangeWindowTail(ir) {
-  return joinList(hourSegmentParts(ir, 0, 0, ":"));
+function hourRangeWindowTail(schedule) {
+  return joinList(hourSegmentParts(schedule, 0, 0, ":"));
 }
-function renderHourRange(ir, plan, opts) {
+function renderHourRange(schedule, plan, opts) {
   const last = plan.minuteForm === "wildcard" ? plan.boundMinute ?? 0 : 0;
   const window = hourWindow(plan.from, plan.to, last, opts.style.sep);
   if (plan.minuteForm === "wildcard") {
     return "jede Minute " + window;
   }
-  if (plan.minuteForm === "lead" && ir.pattern.minute === "0") {
+  if (plan.minuteForm === "lead" && schedule.pattern.minute === "0") {
     return "st\xFCndlich " + window;
   }
   return (strideFromSegments(
-    segmentsOf(ir, "minute"),
+    segmentsOf(schedule, "minute"),
     UNITS.minute,
     "jeder Stunde"
-  ) ?? countedPhrase(ir, "minute", "Minute", "Minuten") + " jeder Stunde") + ", " + window;
+  ) ?? countedPhrase(schedule, "minute", "Minute", "Minuten") + " jeder Stunde") + ", " + window;
 }
-function renderClockTimes(ir, plan, opts) {
-  if (ir.shapes.minute === "single") {
-    const minute = +ir.pattern.minute;
-    const cadence = hourCadence(ir, minute) ?? hourRangeCadence(ir, minute);
+function renderClockTimes(schedule, plan, opts) {
+  if (schedule.shapes.minute === "single") {
+    const minute = +schedule.pattern.minute;
+    const cadence = hourCadence(schedule, minute) ?? hourRangeCadence(schedule, minute);
     if (cadence !== null) {
       return cadence;
     }
@@ -763,48 +804,75 @@ var renderers = {
   singleMinute: renderMinutePast,
   standaloneSeconds: renderSeconds
 };
-function qualifier(ir, months2) {
-  const { date, month, weekday } = ir.pattern;
-  if (date !== "*" && weekday !== "*") {
-    const datePart = quartzDate(date) || dateClauseBare(ir);
-    const weekdayPart = quartzWeekday(weekday) || weekdayQualifier(ir);
-    return datePart + " oder " + weekdayPart + monthScope(ir, months2);
+function isDayUnion(schedule) {
+  return schedule.pattern.date !== "*" && schedule.pattern.weekday !== "*";
+}
+function dayUnionMonthLead(schedule, months2) {
+  return schedule.pattern.month === "*" ? "" : monthClause(schedule, months2) + " ";
+}
+function dayUnionDate(schedule) {
+  return quartzDate(schedule.pattern.date) || oddEvenDay(schedule.pattern.date) || dateClauseBare(schedule);
+}
+function dayUnionWeekday(schedule) {
+  const weekday = schedule.pattern.weekday;
+  const quartz = quartzWeekday(weekday);
+  if (quartz) {
+    return quartz;
+  }
+  const segments = segmentsOf(schedule, "weekday");
+  if (segments.length === 1 && segments[0].kind === "range" && segments[0].bounds[0] === "1" && segments[0].bounds[1] === "5") {
+    return "an einem Wochentag (Mo\u2013Fr)";
+  }
+  return weekdayQualifier(schedule);
+}
+function dateStepCadence(schedule) {
+  const date = schedule.pattern.date;
+  if (!isOpenStep(date)) {
+    return null;
+  }
+  const [start, step] = date.split("/");
+  return (start === "*" || start === "1") && +step === 2 ? "jeden zweiten Tag des Monats" : null;
+}
+function qualifier(schedule, months2) {
+  const { date, month, weekday } = schedule.pattern;
+  if (isDayUnion(schedule)) {
+    return dayUnionDate(schedule) + " oder " + dayUnionWeekday(schedule);
   }
   if (weekday !== "*") {
-    return (quartzWeekday(weekday) || weekdayQualifier(ir)) + monthScope(ir, months2);
+    return (quartzWeekday(weekday) || weekdayQualifier(schedule)) + monthScope(schedule, months2);
   }
   if (date !== "*") {
-    const quartz = quartzDate(date);
-    return quartz ? quartz + monthScope(ir, months2) : datePhrase(ir, months2);
+    const quartz = quartzDate(date) || dateStepCadence(schedule);
+    return quartz ? quartz + monthScope(schedule, months2) : datePhrase(schedule, months2);
   }
   if (month !== "*") {
-    return monthClause(ir, months2);
+    return monthClause(schedule, months2);
   }
   return "";
 }
 var LEADING_PLANS = /* @__PURE__ */ new Set(["clockTimes"]);
-function leadsQualifier(ir) {
-  return LEADING_PLANS.has(ir.plan.kind) || isComposeMinuteZero(ir);
+function leadsQualifier(schedule) {
+  return LEADING_PLANS.has(schedule.plan.kind) || isComposeMinuteZero(schedule);
 }
-function isComposeMinuteZero(ir) {
-  return ir.plan.kind === "composeSeconds" && composeMinuteZero(ir, ir.plan);
+function isComposeMinuteZero(schedule) {
+  return schedule.plan.kind === "composeSeconds" && composeMinuteZero(schedule, schedule.plan);
 }
-function needsDailyFrame(ir) {
-  if (hourCadenceApplies(ir)) {
+function needsDailyFrame(schedule) {
+  if (hourCadenceApplies(schedule)) {
     return false;
   }
-  if (ir.plan.kind === "clockTimes" || isComposeMinuteZero(ir)) {
+  if (schedule.plan.kind === "clockTimes" || isComposeMinuteZero(schedule)) {
     return true;
   }
-  if (ir.plan.kind !== "hourStep") {
+  if (schedule.plan.kind !== "hourStep") {
     return false;
   }
-  const segment = stepSegment(ir, "hour");
-  return !cleanStep(segment, 24) && !openOffsetCleanStride(ir, segment);
+  const segment = stepSegment(schedule, "hour");
+  return !cleanStep(segment, 24) && !openOffsetCleanStride(schedule, segment);
 }
-function render(ir, plan, opts) {
+function render(schedule, plan, opts) {
   return renderers[plan.kind](
-    ir,
+    schedule,
     plan,
     opts
   );
@@ -821,8 +889,8 @@ function normalizeOptions(options) {
     years: !!options.years
   };
 }
-function applyYear(description, ir) {
-  const year = ir.pattern.year;
+function applyYear(description, schedule) {
+  const year = schedule.pattern.year;
   if (year === "*") {
     return description;
   }
@@ -835,16 +903,19 @@ function applyYear(description, ir) {
   }
   return description + " im Jahr " + year;
 }
-function describe(ir, opts) {
-  const core = render(ir, ir.plan, opts);
-  const qual = qualifier(ir, opts.style.months);
+function describe(schedule, opts) {
+  const core = render(schedule, schedule.plan, opts);
+  const qual = qualifier(schedule, opts.style.months);
   let base = core;
   if (qual) {
-    base = leadsQualifier(ir) ? qual + " " + core : core + " " + qual;
-  } else if (needsDailyFrame(ir)) {
+    base = leadsQualifier(schedule) ? qual + " " + core : core + " " + qual;
+  } else if (needsDailyFrame(schedule)) {
     base = "t\xE4glich " + core;
   }
-  return applyYear(base, ir);
+  if (isDayUnion(schedule)) {
+    base = dayUnionMonthLead(schedule, opts.style.months) + base;
+  }
+  return applyYear(base, schedule);
 }
 var de2 = {
   describe,