cronli5 0.2.1 → 0.3.4

package/dist/lang/fi.cjs

@@ -57,6 +57,16 @@ 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/core/cadence.ts
 function arithmeticStep(values) {
   if (values.length < 5) {
     return null;
@@ -72,34 +82,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 = [];
@@ -114,6 +101,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;
@@ -133,9 +131,26 @@ function hourListStride(values) {
   return { interval, last: values[values.length - 1], start: values[0] };
 }
 
-// src/core/shapes.ts
-function isOpenStep(field) {
-  return field.indexOf("/") !== -1 && field.indexOf("-") === -1 && field.indexOf(",") === -1;
+// 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/lang/fi/dialects.ts
@@ -292,94 +307,108 @@ function normalizeOptions(options) {
     years: !!options.years
   };
 }
-function restrictedMonthUnion(ir) {
-  return ir.pattern.date !== "*" && ir.pattern.weekday !== "*" && ir.pattern.month !== "*";
+function restrictedMonthUnion(schedule) {
+  return schedule.pattern.date !== "*" && schedule.pattern.weekday !== "*" && schedule.pattern.month !== "*";
 }
-function unionDateArm(ir) {
-  return quartzDatePhrase(ir.pattern.date) || dateWords(ir) + " p\xE4iv\xE4n\xE4";
+function oddDayUnion(dateField) {
+  if (!isOpenStep(dateField)) {
+    return null;
+  }
+  const [start, step] = dateField.split("/");
+  return (start === "*" || start === "1") && +step === 2 ? "kuukauden parittomina p\xE4ivin\xE4" : null;
+}
+function unionDateArm(schedule) {
+  return quartzDatePhrase(schedule.pattern.date) || oddDayUnion(schedule.pattern.date) || dateWords(schedule) + " p\xE4iv\xE4n\xE4";
 }
-function describe(ir, opts) {
-  if (restrictedMonthUnion(ir)) {
-    const timePart = render(ir, ir.plan, opts);
+function unionWeekdayArm(schedule) {
+  const segments = segmentsOf(schedule, "weekday");
+  if (segments.length === 1 && segments[0].kind === "range" && segments[0].bounds[0] === "1" && segments[0].bounds[1] === "5") {
+    return "arkisin";
+  }
+  return weekdayQualifier(schedule);
+}
+function describe(schedule, opts) {
+  if (restrictedMonthUnion(schedule)) {
+    const timePart = render(schedule, schedule.plan, opts);
     return applyYear(
-      monthPhrase(ir) + " " + timePart + " joko " + unionDateArm(ir) + " tai " + weekdayQualifier(ir),
-      ir,
+      monthPhrase(schedule) + " " + timePart + " " + unionDateArm(schedule) + " tai " + unionWeekdayArm(schedule),
+      schedule,
       opts
     );
   }
-  return applyYear(render(ir, ir.plan, opts), ir, opts);
+  return applyYear(render(schedule, schedule.plan, opts), schedule, opts);
 }
-function render(ir, plan, opts) {
+function render(schedule, plan, opts) {
   const renderer = renderers[plan.kind];
-  return renderer(ir, plan, opts);
+  return renderer(schedule, plan, opts);
 }
-function renderEverySecond(ir, plan, opts) {
-  return "joka sekunti" + trailingQualifier(ir, opts);
+function renderEverySecond(schedule, plan, opts) {
+  return "joka sekunti" + trailingQualifier(schedule, opts);
 }
-function renderStandaloneSeconds(ir, plan, opts) {
-  return secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+function renderStandaloneSeconds(schedule, plan, opts) {
+  return secondsLeadClause(schedule, opts) + trailingQualifier(schedule, opts);
 }
-function renderSecondPastMinute(ir, plan, opts) {
-  return atMarks(ir.pattern.second, units.second, true) + trailingQualifier(ir, opts);
+function renderSecondPastMinute(schedule, plan, opts) {
+  return atMarks(schedule.pattern.second, units.second, true) + trailingQualifier(schedule, opts);
 }
-function renderSecondsWithinMinute(ir, plan, opts) {
-  const minuteField = ir.pattern.minute;
+function renderSecondsWithinMinute(schedule, plan, opts) {
+  const minuteField = schedule.pattern.minute;
   if (plan.singleSecond) {
-    return units.minute.mark + " " + minuteField + " " + units.minute.gen + " ja " + ir.pattern.second + " " + units.second.gen + " kohdalla" + trailingQualifier(ir, opts);
+    return units.minute.mark + " " + minuteField + " " + units.minute.gen + " ja " + schedule.pattern.second + " " + units.second.gen + " kohdalla" + trailingQualifier(schedule, opts);
   }
-  return secondsLeadClause(ir, opts) + ", " + atMarks(minuteField, units.minute, true) + trailingQualifier(ir, opts);
+  return secondsLeadClause(schedule, opts) + ", " + atMarks(minuteField, units.minute, true) + trailingQualifier(schedule, opts);
 }
-function composeSecondsOverMinuteStep(ir, freq, opts) {
-  const seg = stepSegment(ir, "minute");
+function composeSecondsOverMinuteStep(schedule, freq, opts) {
+  const seg = stepSegment(schedule, "minute");
   const stepPhrase = stepCycle60(seg, units.minute, opts);
   if (freq.hours.kind === "during" && minuteStepIsAnchored(seg)) {
-    const bareHours = kloFromTimes(ir, freq.hours.times, opts);
-    return hoursFirstMinutes(bareHours, ir, opts) + ", " + secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+    const bareHours = kloFromTimes(schedule, freq.hours.times, opts);
+    return hoursFirstMinutes(bareHours, schedule, opts) + ", " + secondsLeadClause(schedule, opts) + trailingQualifier(schedule, opts);
   }
   let hourClause = "";
   if (freq.hours.kind === "during") {
-    hourClause = " " + hourWindowsFromTimes(ir, freq.hours.times, opts);
+    hourClause = " " + hourWindowsFromTimes(schedule, freq.hours.times, opts);
   } else if (freq.hours.kind === "window") {
     hourClause = " " + hourWindow(freq.hours, opts);
   } else if (freq.hours.kind === "step") {
-    hourClause = " " + everyNthHour(stepSegment(ir, "hour"), opts);
+    hourClause = " " + everyNthHour(stepSegment(schedule, "hour"), opts);
   }
-  return stepPhrase + ", " + secondsLeadClause(ir, opts) + hourClause + trailingQualifier(ir, opts);
+  return stepPhrase + ", " + secondsLeadClause(schedule, opts) + hourClause + trailingQualifier(schedule, opts);
 }
-function composeHourCadence(ir, plan, opts) {
+function composeHourCadence(schedule, plan, opts) {
   const clockRest = plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes";
-  if (!clockRest || ir.shapes.minute !== "single") {
+  if (!clockRest || schedule.shapes.minute !== "single") {
     return null;
   }
-  const minute = +ir.pattern.minute;
-  return hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
+  const minute = +schedule.pattern.minute;
+  return hourCadence(schedule, minute, opts) ?? hourRangeCadence(schedule, minute, opts);
 }
-function renderComposeSeconds(ir, plan, opts) {
-  const cadence = composeHourCadence(ir, plan, opts);
+function renderComposeSeconds(schedule, plan, opts) {
+  const cadence = composeHourCadence(schedule, plan, opts);
   if (cadence !== null) {
     return cadence;
   }
-  if (plan.rest.kind === "minuteFrequency" && ir.pattern.second !== "*") {
-    return composeSecondsOverMinuteStep(ir, plan.rest, opts);
+  if (plan.rest.kind === "minuteFrequency" && schedule.pattern.second !== "*") {
+    return composeSecondsOverMinuteStep(schedule, plan.rest, opts);
   }
   if (plan.rest.kind === "clockTimes" && plan.rest.times.every((time) => +time.minute === 0)) {
-    return composeMinuteZero(ir, plan.rest, opts);
+    return composeMinuteZero(schedule, plan.rest, opts);
   }
-  if (isEveryOtherMinuteSeconds(ir, plan)) {
-    return secondsLeadClause(ir, opts) + " joka toisena minuuttina";
+  if (isEveryOtherMinuteSeconds(schedule, plan)) {
+    return secondsLeadClause(schedule, opts) + " joka toisena minuuttina";
   }
-  const restOwnsLead = plan.rest.kind === "compactClockTimes" && ir.analyses.clockSecond;
-  const lead = restOwnsLead ? "" : secondsLeadClause(ir, opts) + ", ";
-  return lead + render(ir, plan.rest, opts);
+  const restOwnsLead = plan.rest.kind === "compactClockTimes" && schedule.analyses.clockSecond;
+  const lead = restOwnsLead ? "" : secondsLeadClause(schedule, opts) + ", ";
+  return lead + render(schedule, plan.rest, opts);
 }
-function isEveryOtherMinuteSeconds(ir, plan) {
-  if (plan.rest.kind !== "minuteFrequency" || ir.pattern.second !== "*" || ir.shapes.hour !== "wildcard") {
+function isEveryOtherMinuteSeconds(schedule, plan) {
+  if (plan.rest.kind !== "minuteFrequency" || schedule.pattern.second !== "*" || schedule.shapes.hour !== "wildcard") {
     return false;
   }
-  const seg = stepSegment(ir, "minute");
+  const seg = stepSegment(schedule, "minute");
   return seg.startToken === "*" && seg.interval === 2;
 }
-function composeMinuteZero(ir, rest, opts) {
+function composeMinuteZero(schedule, rest, opts) {
   const clocks = rest.times.map(function clock(time) {
     return clockDigits(
       { hour: time.hour, minute: time.minute },
@@ -387,54 +416,66 @@ function composeMinuteZero(ir, rest, opts) {
     );
   });
   const frame = clocks.length === 1 ? "minuutin " + clocks[0] : "minuuttien " + joinList(clocks);
-  const dayTrail = leadingQualifier(ir, opts).trimEnd();
-  return secondsLeadClause(ir, opts) + " " + frame + " aikana" + (dayTrail ? ", " + dayTrail : "");
+  const dayTrail = leadingQualifier(schedule, opts).trimEnd();
+  return secondsLeadClause(schedule, opts) + " " + frame + " aikana" + (dayTrail ? ", " + dayTrail : "");
 }
-function secondsLeadClause(ir, opts) {
-  const secondField = ir.pattern.second;
-  const shape = ir.shapes.second;
+function secondsLeadClause(schedule, opts) {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
   if (secondField === "*") {
     return "joka sekunti";
   }
   if (shape === "step") {
     return stepCycle60(
-      stepSegment(ir, "second"),
+      stepSegment(schedule, "second"),
       units.second,
       opts
     );
   }
-  const marked = ir.pattern.minute === "*";
+  const marked = schedule.pattern.minute === "*";
   if (shape === "single") {
     return atMarks(secondField, units.second, marked);
   }
-  return strideFromSegments(segmentsOf(ir, "second"), units.second, opts) ?? atMarks(
-    joinList(segmentWords(segmentsOf(ir, "second"))),
+  return strideFromSegments(
+    segmentsOf(schedule, "second"),
+    units.second,
+    opts
+  ) ?? atMarks(
+    joinList(segmentWords(segmentsOf(schedule, "second"))),
     units.second,
     marked
   );
 }
-function renderEveryMinute(ir, plan, opts) {
-  return "joka minuutti" + trailingQualifier(ir, opts);
+function renderEveryMinute(schedule, plan, opts) {
+  return "joka minuutti" + trailingQualifier(schedule, opts);
 }
-function renderSingleMinute(ir, plan, opts) {
-  return atMarks(ir.pattern.minute, units.minute, true) + trailingQualifier(ir, opts);
+function renderSingleMinute(schedule, plan, opts) {
+  return atMarks(schedule.pattern.minute, units.minute, true) + trailingQualifier(schedule, opts);
 }
-function renderRangeOfMinutes(ir, plan, opts) {
-  return minutesList(ir, opts) + trailingQualifier(ir, opts);
+function renderRangeOfMinutes(schedule, plan, opts) {
+  return minutesList(schedule, opts) + trailingQualifier(schedule, opts);
 }
-function renderMultipleMinutes(ir, plan, opts) {
-  return minutesList(ir, opts) + trailingQualifier(ir, opts);
+function renderMultipleMinutes(schedule, plan, opts) {
+  return minutesList(schedule, opts) + trailingQualifier(schedule, opts);
 }
-function minutesList(ir, opts) {
-  return strideFromSegments(segmentsOf(ir, "minute"), units.minute, opts) ?? atMarks(
-    joinList(segmentWords(segmentsOf(ir, "minute"))),
+function minutesList(schedule, opts) {
+  return strideFromSegments(
+    segmentsOf(schedule, "minute"),
+    units.minute,
+    opts
+  ) ?? atMarks(
+    joinList(segmentWords(segmentsOf(schedule, "minute"))),
     units.minute,
     true
   );
 }
-function bareMinutes(ir, opts) {
-  return strideFromSegments(segmentsOf(ir, "minute"), units.minute, opts) ?? atMarks(
-    joinList(segmentWords(segmentsOf(ir, "minute"))),
+function bareMinutes(schedule, opts) {
+  return strideFromSegments(
+    segmentsOf(schedule, "minute"),
+    units.minute,
+    opts
+  ) ?? atMarks(
+    joinList(segmentWords(segmentsOf(schedule, "minute"))),
     units.minute,
     false
   );
@@ -464,16 +505,16 @@ function hoursAreRangeIsolated(segments) {
   }
   return hasRange && hasSingle;
 }
-function hoursFirstMinutes(hoursStr, ir, opts) {
-  const stride = strideFromSegments(segmentsOf(ir, "minute"), units.minute, opts);
+function hoursFirstMinutes(hoursStr, schedule, opts) {
+  const stride = strideFromSegments(segmentsOf(schedule, "minute"), units.minute, opts);
   if (stride) {
     return hoursStr + " aina " + stride;
   }
-  return hoursStr + " aina minuuttien " + joinList(segmentWords(segmentsOf(ir, "minute"))) + " kohdalla";
+  return hoursStr + " aina minuuttien " + joinList(segmentWords(segmentsOf(schedule, "minute"))) + " kohdalla";
 }
-function hourSegmentTimesWithSeka(ir, minute, second, opts) {
+function hourSegmentTimesWithSeka(schedule, minute, second, opts) {
   const pieces = [];
-  segmentsOf(ir, "hour").forEach(function clock(segment) {
+  segmentsOf(schedule, "hour").forEach(function clock(segment) {
     if (segment.kind === "range") {
       pieces.push(rangeDigits(
         { hour: +segment.bounds[0], minute, second },
@@ -486,61 +527,61 @@ function hourSegmentTimesWithSeka(ir, minute, second, opts) {
   });
   return "klo " + pieces.slice(0, -1).join(", ") + " sek\xE4 klo " + pieces[pieces.length - 1];
 }
-function renderMinuteFrequency(ir, plan, opts) {
-  const seg = stepSegment(ir, "minute");
+function renderMinuteFrequency(schedule, plan, opts) {
+  const seg = stepSegment(schedule, "minute");
   if (plan.hours.kind === "during") {
-    const cadence = unevenHourCadence(ir, opts);
+    const cadence = unevenHourCadence(schedule, opts);
     if (cadence !== null) {
-      return stepCycle60(seg, units.minute, opts) + ", " + cadence + trailingQualifier(ir, opts);
+      return stepCycle60(seg, units.minute, opts) + ", " + cadence + trailingQualifier(schedule, opts);
     }
     if (minuteStepIsAnchored(seg)) {
-      const bareHours = kloFromTimes(ir, plan.hours.times, opts);
-      return hoursFirstMinutes(bareHours, ir, opts) + trailingQualifier(ir, opts);
+      const bareHours = kloFromTimes(schedule, plan.hours.times, opts);
+      return hoursFirstMinutes(bareHours, schedule, opts) + trailingQualifier(schedule, opts);
     }
-    return stepCycle60(seg, units.minute, opts) + " " + hourWindowsFromTimes(ir, plan.hours.times, opts) + trailingQualifier(ir, opts);
+    return stepCycle60(seg, units.minute, opts) + " " + hourWindowsFromTimes(schedule, plan.hours.times, opts) + trailingQualifier(schedule, opts);
   }
   let phrase = stepCycle60(seg, units.minute, opts);
   if (plan.hours.kind === "window") {
     phrase += " " + hourWindow(plan.hours, opts);
   } else if (plan.hours.kind === "step") {
-    phrase += " " + everyNthHour(stepSegment(ir, "hour"), opts);
+    phrase += " " + everyNthHour(stepSegment(schedule, "hour"), opts);
   }
-  return phrase + trailingQualifier(ir, opts);
+  return phrase + trailingQualifier(schedule, opts);
 }
-function renderMinuteSpanInHour(ir, plan, opts) {
-  if (ir.pattern.minute === "*") {
-    return "joka minuutti kello " + plan.hour + " aikana" + trailingQualifier(ir, opts);
+function renderMinuteSpanInHour(schedule, plan, opts) {
+  if (schedule.pattern.minute === "*") {
+    return "joka minuutti kello " + plan.hour + " aikana" + trailingQualifier(schedule, opts);
   }
   return "joka minuutti " + kloRange(
     { hour: plan.hour, minute: plan.span[0] },
     { hour: plan.hour, minute: plan.span[1] },
     opts
-  ) + trailingQualifier(ir, opts);
+  ) + trailingQualifier(schedule, opts);
 }
-function renderMinutesAcrossHours(ir, plan, opts) {
-  const cadence = unevenHourCadence(ir, opts);
+function renderMinutesAcrossHours(schedule, plan, opts) {
+  const cadence = unevenHourCadence(schedule, opts);
   if (plan.form === "wildcard") {
-    return cadence ? "joka minuutti, " + cadence + trailingQualifier(ir, opts) : "joka minuutti " + hourWindowsFromTimes(ir, plan.times, opts) + trailingQualifier(ir, opts);
+    return cadence ? "joka minuutti, " + cadence + trailingQualifier(schedule, opts) : "joka minuutti " + hourWindowsFromTimes(schedule, plan.times, opts) + trailingQualifier(schedule, opts);
   }
   if (cadence !== null) {
-    return bareMinutes(ir, opts) + ", " + cadence + trailingQualifier(ir, opts);
+    return bareMinutes(schedule, opts) + ", " + cadence + trailingQualifier(schedule, opts);
   }
-  if (hoursAreRangeIsolated(segmentsOf(ir, "hour"))) {
-    return bareMinutes(ir, opts) + " " + hourSegmentTimesWithSeka(ir, 0, null, opts) + trailingQualifier(ir, opts);
+  if (hoursAreRangeIsolated(segmentsOf(schedule, "hour"))) {
+    return bareMinutes(schedule, opts) + " " + hourSegmentTimesWithSeka(schedule, 0, null, opts) + trailingQualifier(schedule, opts);
   }
-  const hoursStr = kloFromTimes(ir, plan.times, opts);
-  return hoursFirstMinutes(hoursStr, ir, opts) + trailingQualifier(ir, opts);
+  const hoursStr = kloFromTimes(schedule, plan.times, opts);
+  return hoursFirstMinutes(hoursStr, schedule, opts) + trailingQualifier(schedule, opts);
 }
-function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
-  const segment = stepSegment(ir, "hour");
-  const cadence = unevenHourCadence(ir, opts);
+function renderMinuteSpanAcrossHourStep(schedule, plan, opts) {
+  const segment = stepSegment(schedule, "hour");
+  const cadence = unevenHourCadence(schedule, opts);
   if (plan.form === "wildcard") {
-    return "joka minuutti " + everyNthHour(segment, opts) + trailingQualifier(ir, opts);
+    return "joka minuutti " + everyNthHour(segment, opts) + trailingQualifier(schedule, opts);
   }
   if (cadence !== null) {
-    return bareMinutes(ir, opts) + ", " + cadence + trailingQualifier(ir, opts);
+    return bareMinutes(schedule, opts) + ", " + cadence + trailingQualifier(schedule, opts);
   }
-  return bareMinutes(ir, opts) + hourStepTail(segment, opts) + trailingQualifier(ir, opts);
+  return bareMinutes(schedule, opts) + hourStepTail(segment, opts) + trailingQualifier(schedule, opts);
 }
 function plainHourStep(segment) {
   return segment.startToken === "*" && 24 % segment.interval === 0;
@@ -589,35 +630,35 @@ function hourStepTail(segment, opts) {
   const sep = plainHourStep(segment) ? " " : ", ";
   return sep + plainOrFullHourStep(segment, opts);
 }
-function renderEveryHour(ir, plan, opts) {
-  return "joka tunti" + trailingQualifier(ir, opts);
+function renderEveryHour(schedule, plan, opts) {
+  return "joka tunti" + trailingQualifier(schedule, opts);
 }
-function renderHourRange(ir, plan, opts) {
+function renderHourRange(schedule, plan, opts) {
   const window = hourWindow(boundedWindow(plan), opts);
   if (plan.minuteForm === "wildcard") {
-    return "joka minuutti " + window + trailingQualifier(ir, opts);
+    return "joka minuutti " + window + trailingQualifier(schedule, opts);
   }
   if (plan.minuteForm === "range") {
-    return hoursFirstMinutes(window, ir, opts) + trailingQualifier(ir, opts);
+    return hoursFirstMinutes(window, schedule, opts) + trailingQualifier(schedule, opts);
   }
-  if (ir.pattern.minute === "0") {
-    return "joka tunti " + window + trailingQualifier(ir, opts);
+  if (schedule.pattern.minute === "0") {
+    return "joka tunti " + window + trailingQualifier(schedule, opts);
   }
-  if (ir.shapes.minute === "single") {
-    return atMarks(ir.pattern.minute, units.minute, false) + " " + kloRange(
-      { hour: plan.from, minute: +ir.pattern.minute },
+  if (schedule.shapes.minute === "single") {
+    return atMarks(schedule.pattern.minute, units.minute, false) + " " + kloRange(
+      { hour: plan.from, minute: +schedule.pattern.minute },
       { hour: plan.to, minute: plan.last },
       opts
-    ) + trailingQualifier(ir, opts);
+    ) + trailingQualifier(schedule, opts);
   }
-  return hoursFirstMinutes(window, ir, opts) + trailingQualifier(ir, opts);
+  return hoursFirstMinutes(window, schedule, opts) + trailingQualifier(schedule, opts);
 }
-function renderHourStep(ir, plan, opts) {
-  const cadence = unevenHourCadence(ir, opts);
+function renderHourStep(schedule, plan, opts) {
+  const cadence = unevenHourCadence(schedule, opts);
   if (cadence !== null) {
-    return cadence + trailingQualifier(ir, opts);
+    return cadence + trailingQualifier(schedule, opts);
   }
-  return stepHours(stepSegment(ir, "hour"), opts) + trailingQualifier(ir, opts);
+  return stepHours(stepSegment(schedule, "hour"), opts) + trailingQualifier(schedule, opts);
 }
 function boundedWindow(plan) {
   return { from: plan.from, last: plan.boundMinute ?? 0, to: plan.to };
@@ -629,53 +670,62 @@ function hourWindow(window, opts) {
     opts
   );
 }
-function renderClockTimes(ir, plan, opts) {
-  if (ir.shapes.minute === "single") {
-    const minute = +ir.pattern.minute;
-    const cadence = hourCadence(ir, minute, opts) ?? hourRangeCadence(ir, minute, opts);
+function renderClockTimes(schedule, plan, opts) {
+  if (schedule.shapes.minute === "single") {
+    const minute = +schedule.pattern.minute;
+    const cadence = hourCadence(schedule, minute, opts) ?? hourRangeCadence(schedule, minute, opts);
     if (cadence !== null) {
       return cadence;
     }
   }
   if (plan.times.length === 1) {
     const time = plan.times[0];
-    return leadingQualifier(ir, opts) + timeWord(time.hour, time.minute, time.second, opts);
+    return leadingQualifier(schedule, opts) + timeWord(time.hour, time.minute, time.second, opts);
   }
   const digits = plan.times.map(function clock(time) {
     return timeDigits(time.hour, time.minute, time.second, opts);
   });
-  return leadingQualifier(ir, opts) + "klo " + joinList(digits);
+  return leadingQualifier(schedule, opts) + "klo " + joinList(digits);
 }
-function renderCompactClockTimes(ir, plan, opts) {
+function renderCompactClockTimes(schedule, plan, opts) {
   if (plan.fold) {
-    const cadence2 = hourCadence(ir, plan.minute, opts) ?? hourRangeCadence(ir, plan.minute, opts);
+    const cadence2 = hourCadence(schedule, plan.minute, opts) ?? hourRangeCadence(schedule, plan.minute, opts);
     if (cadence2 !== null) {
       return cadence2;
     }
   }
-  const hourSegs = segmentsOf(ir, "hour");
+  const hourSegs = segmentsOf(schedule, "hour");
   if (hoursAreRangeIsolated(hourSegs)) {
     if (plan.fold) {
-      return leadingQualifier(ir, opts) + hourSegmentTimesWithSeka(
-        ir,
+      return leadingQualifier(schedule, opts) + hourSegmentTimesWithSeka(
+        schedule,
         plan.minute,
-        ir.analyses.clockSecond,
+        schedule.analyses.clockSecond,
         opts
       );
     }
-    const phrase2 = bareMinutes(ir, opts) + " " + hourSegmentTimesWithSeka(ir, 0, null, opts) + trailingQualifier(ir, opts);
-    return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase2 : phrase2;
+    const phrase2 = bareMinutes(schedule, opts) + " " + hourSegmentTimesWithSeka(schedule, 0, null, opts) + trailingQualifier(schedule, opts);
+    return schedule.analyses.clockSecond ? secondsLeadClause(schedule, opts) + ", " + phrase2 : phrase2;
   }
   if (plan.fold) {
-    return leadingQualifier(ir, opts) + hourSegmentTimes(ir, plan.minute, ir.analyses.clockSecond, opts);
+    return leadingQualifier(schedule, opts) + hourSegmentTimes(
+      schedule,
+      plan.minute,
+      schedule.analyses.clockSecond,
+      opts
+    );
   }
-  const cadence = unevenHourCadence(ir, opts);
-  const phrase = cadence ? bareMinutes(ir, opts) + ", " + cadence + trailingQualifier(ir, opts) : (
+  const cadence = unevenHourCadence(schedule, opts);
+  const phrase = cadence ? bareMinutes(schedule, opts) + ", " + cadence + trailingQualifier(schedule, opts) : (
     // A minute list over purely enumerated hours (step fires, all singles) —
     // hours-first, drop "joka tunti".
-    hoursFirstMinutes(hourSegmentTimes(ir, 0, null, opts), ir, opts) + trailingQualifier(ir, opts)
+    hoursFirstMinutes(
+      hourSegmentTimes(schedule, 0, null, opts),
+      schedule,
+      opts
+    ) + trailingQualifier(schedule, opts)
   );
-  return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase : phrase;
+  return schedule.analyses.clockSecond ? secondsLeadClause(schedule, opts) + ", " + phrase : phrase;
 }
 var renderers = {
   clockTimes: renderClockTimes,
@@ -697,22 +747,19 @@ var renderers = {
   singleMinute: renderSingleMinute,
   standaloneSeconds: renderStandaloneSeconds
 };
-function renderStride(stride, opts) {
+function renderStride2(stride, opts) {
   const { interval, start, last, cycle, unit } = stride;
   const cadence = genitive(interval, opts) + " " + unit.gen + " v\xE4lein";
-  const tiles = cycle % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence;
-  }
-  if (start < interval && tiles) {
-    return cadence + " " + unit.anchor + " " + unit.ela + " " + start + " alkaen";
-  }
-  return cadence + " " + unit.ela + " " + start + " " + unit.ill + " " + last;
+  return renderStride({ start, interval, cycle }, {
+    bare: () => cadence,
+    offset: () => cadence + " " + unit.anchor + " " + unit.ela + " " + start + " alkaen",
+    bounded: () => cadence + " " + unit.ela + " " + start + " " + unit.ill + " " + last
+  });
 }
 function strideFromSegments(segments, unit, opts) {
   const values = singleValues(segments);
   const step = values && arithmeticStep(values);
-  return step ? renderStride({ ...step, cycle: 60, unit }, opts) : null;
+  return step ? renderStride2({ ...step, cycle: 60, unit }, opts) : null;
 }
 function stepCycle60(segment, unit, opts) {
   if (segment.startToken.indexOf("-") !== -1) {
@@ -722,7 +769,7 @@ function stepCycle60(segment, unit, opts) {
   if (start !== 0 && segment.fires.length <= 3) {
     return atMarks(joinList(wordList(segment.fires)), unit, true);
   }
-  return renderStride({
+  return renderStride2({
     interval: segment.interval,
     start,
     last: segment.fires[segment.fires.length - 1],
@@ -748,17 +795,14 @@ function stepHours(segment, opts) {
 function hourStrideCadence(stride, opts) {
   const { start, interval, last } = stride;
   const cadence = genitive(interval, opts) + " tunnin v\xE4lein";
-  const tiles = 24 % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence;
-  }
-  if (start < interval && tiles) {
-    return cadence + " klo " + hourElatives[start] + " alkaen";
-  }
-  return cadence + " " + kloRange({ hour: start, minute: 0 }, { hour: last, minute: 0 }, opts);
+  return renderStride({ start, interval, cycle: 24 }, {
+    bare: () => cadence,
+    offset: () => cadence + " klo " + hourElatives[start] + " alkaen",
+    bounded: () => cadence + " " + kloRange({ hour: start, minute: 0 }, { hour: last, minute: 0 }, opts)
+  });
 }
-function hourStride(ir) {
-  const segments = ir.analyses.segments.hour;
+function hourStride(schedule) {
+  const segments = schedule.analyses.segments.hour;
   if (!segments) {
     return null;
   }
@@ -773,47 +817,47 @@ function hourStride(ir) {
   const values = singleValues(segments);
   return values && hourListStride(values);
 }
-function unevenHourCadence(ir, opts) {
-  const stride = hourStride(ir);
+function unevenHourCadence(schedule, opts) {
+  const stride = hourStride(schedule);
   if (!stride || offsetCleanStride(stride)) {
     return null;
   }
   return hourStrideCadence(stride, opts);
 }
-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, opts) {
+function hourCadenceLead(schedule, minute, opts) {
   if (minute === 0) {
-    if (subMinuteSecond(ir)) {
-      return secondsLeadClause(ir, opts) + " minuutin ajan";
+    if (subMinuteSecond(schedule)) {
+      return secondsLeadClause(schedule, opts) + " minuutin ajan";
     }
-    return secondsLeadClause(ir, opts);
+    return secondsLeadClause(schedule, opts);
   }
   const minutePhrase = atMarks(String(minute), units.minute, false);
-  if (ir.pattern.second === "0") {
+  if (schedule.pattern.second === "0") {
     return minutePhrase;
   }
-  return secondsLeadClause(ir, opts) + ", " + minutePhrase;
+  return secondsLeadClause(schedule, opts) + ", " + minutePhrase;
 }
-function hourCadence(ir, minute, opts) {
-  const stride = hourStride(ir);
+function hourCadence(schedule, minute, opts) {
+  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" && cleanHourStride(segment);
+  const segment = segmentsOf(schedule, "hour")[0];
+  const confined = minute === 0 && subMinuteSecond(schedule) && segmentsOf(schedule, "hour").length === 1 && segment.kind === "step" && cleanHourStride(segment);
   if (confined) {
-    return secondsLeadClause(ir, opts) + " minuutin ajan " + everyNthHour(segment, opts) + trailingQualifier(ir, opts);
+    return secondsLeadClause(schedule, opts) + " minuutin ajan " + everyNthHour(segment, opts) + trailingQualifier(schedule, opts);
   }
-  if (minute === 0 && ir.pattern.second === "0") {
-    return hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+  if (minute === 0 && schedule.pattern.second === "0") {
+    return hourStrideCadence(stride, opts) + trailingQualifier(schedule, opts);
   }
-  return hourCadenceLead(ir, minute, opts) + ", " + hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+  return hourCadenceLead(schedule, minute, opts) + ", " + hourStrideCadence(stride, opts) + trailingQualifier(schedule, opts);
 }
 function cleanHourStride(segment) {
   if (segment.startToken.indexOf("-") !== -1) {
@@ -822,22 +866,22 @@ function cleanHourStride(segment) {
   const start = segment.startToken === "*" ? 0 : +segment.startToken;
   return 24 % segment.interval === 0 && start < segment.interval;
 }
-function hasHourWindow(ir) {
-  const segments = ir.analyses.segments.hour;
+function hasHourWindow(schedule) {
+  const segments = schedule.analyses.segments.hour;
   return !!segments && segments.some(function range(segment) {
     return segment.kind === "range";
   });
 }
-function hourRangeWindowTail(ir, opts) {
-  return segmentsOf(ir, "hour").length === 1 ? hourSegmentTimes(ir, 0, null, opts) : hourSegmentTimesWithSeka(ir, 0, null, opts);
+function hourRangeWindowTail(schedule, opts) {
+  return segmentsOf(schedule, "hour").length === 1 ? hourSegmentTimes(schedule, 0, null, opts) : hourSegmentTimesWithSeka(schedule, 0, null, opts);
 }
-function hourRangeCadence(ir, minute, opts) {
-  if (minute !== 0 || !hasHourWindow(ir) || ir.pattern.second === "0") {
+function hourRangeCadence(schedule, minute, opts) {
+  if (minute !== 0 || !hasHourWindow(schedule) || schedule.pattern.second === "0") {
     return null;
   }
-  const tail = hourRangeWindowTail(ir, opts);
-  const joiner = subMinuteSecond(ir) ? " " : ", ";
-  return hourCadenceLead(ir, minute, opts) + joiner + tail + trailingQualifier(ir, opts);
+  const tail = hourRangeWindowTail(schedule, opts);
+  const joiner = subMinuteSecond(schedule) ? " " : ", ";
+  return hourCadenceLead(schedule, minute, opts) + joiner + tail + trailingQualifier(schedule, opts);
 }
 function kloList(hours, opts) {
   if (hours.length === 1) {
@@ -847,17 +891,17 @@ function kloList(hours, opts) {
     return timeDigits(hour, 0, null, opts);
   }));
 }
-function kloFromTimes(ir, times, opts) {
+function kloFromTimes(schedule, times, opts) {
   if (times.kind === "fires") {
     return kloList(times.fires, opts);
   }
-  return hourSegmentTimes(ir, 0, null, opts);
+  return hourSegmentTimes(schedule, 0, null, opts);
 }
-function hourWindowsFromTimes(ir, times, opts) {
+function hourWindowsFromTimes(schedule, times, opts) {
   if (times.kind === "fires") {
     return kloList(times.fires, opts);
   }
-  const segments = segmentsOf(ir, "hour");
+  const segments = segmentsOf(schedule, "hour");
   if (!segments.some(function ranged(segment) {
     return segment.kind === "range";
   })) {
@@ -895,9 +939,9 @@ function hourSegmentFires(segments) {
 function hourWindowDigits(hour, opts) {
   return rangeDigits({ hour, minute: 0 }, { hour, minute: 59 }, opts);
 }
-function hourSegmentTimes(ir, minute, second, opts) {
+function hourSegmentTimes(schedule, minute, second, opts) {
   const pieces = [];
-  segmentsOf(ir, "hour").forEach(function clock(segment) {
+  segmentsOf(schedule, "hour").forEach(function clock(segment) {
     if (segment.kind === "step") {
       pieces.push(...segment.fires.map(function each(hour) {
         return timeDigits(hour, minute, second, opts);
@@ -947,53 +991,54 @@ function timeDigits(hour, minute, second, opts) {
     { lean: true, sep: opts.style.sep }
   );
 }
-function leadingQualifier(ir, opts) {
-  const pattern = ir.pattern;
-  if (restrictedMonthUnion(ir)) {
+function leadingQualifier(schedule, opts) {
+  const pattern = schedule.pattern;
+  if (restrictedMonthUnion(schedule)) {
     return "";
   }
   if (pattern.date !== "*" && pattern.weekday !== "*") {
-    return dateOrWeekday(ir, opts) + " ";
+    return dateOrWeekday(schedule, opts) + " ";
   }
   if (pattern.date !== "*") {
-    return datePhrase(ir, opts) + " ";
+    return datePhrase(schedule, opts) + " ";
   }
   if (pattern.weekday !== "*") {
-    return weekdayQualifier(ir) + monthScope(ir) + " ";
+    return weekdayQualifier(schedule) + monthScope(schedule) + " ";
   }
   if (pattern.month !== "*") {
-    return "joka p\xE4iv\xE4 " + monthPhrase(ir) + " ";
+    return "joka p\xE4iv\xE4 " + monthPhrase(schedule) + " ";
   }
   return "joka p\xE4iv\xE4 ";
 }
-function trailingQualifier(ir, opts) {
-  const pattern = ir.pattern;
-  if (restrictedMonthUnion(ir)) {
+function trailingQualifier(schedule, opts) {
+  const pattern = schedule.pattern;
+  if (restrictedMonthUnion(schedule)) {
     return "";
   }
   if (pattern.date !== "*" && pattern.weekday !== "*") {
-    return " " + dateOrWeekday(ir, opts);
+    return " " + dateOrWeekday(schedule, opts);
   }
   if (pattern.date !== "*") {
-    return " " + datePhrase(ir, opts);
+    return " " + datePhrase(schedule, opts);
   }
   if (pattern.weekday !== "*") {
-    return " " + weekdayQualifier(ir) + monthScope(ir);
+    return " " + weekdayQualifier(schedule) + monthScope(schedule);
   }
   if (pattern.month !== "*") {
-    return " " + monthPhrase(ir);
+    return " " + monthPhrase(schedule);
   }
   return "";
 }
-function dateOrWeekday(ir, opts) {
-  return datePhrase(ir, opts) + " tai " + weekdayQualifier(ir) + monthScope(ir);
+function dateOrWeekday(schedule, opts) {
+  const dateArm = oddDayUnion(schedule.pattern.date) || datePhrase(schedule, opts);
+  return dateArm + " tai " + unionWeekdayArm(schedule) + monthScope(schedule);
 }
-function weekdayQualifier(ir) {
-  const quartz = quartzWeekdayPhrase(ir.pattern.weekday);
+function weekdayQualifier(schedule) {
+  const quartz = quartzWeekdayPhrase(schedule.pattern.weekday);
   if (quartz) {
     return quartz;
   }
-  const segments = orderWeekdaysForDisplay(segmentsOf(ir, "weekday"));
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, "weekday"));
   return joinList(segments.map(function piece(segment) {
     if (segment.kind === "range") {
       return weekdays[weekdayNumber(segment.bounds[0])].ela + " " + weekdays[weekdayNumber(segment.bounds[1])].ill;
@@ -1001,8 +1046,8 @@ function weekdayQualifier(ir) {
     return weekdays[weekdayNumber(segment.value)].isin;
   }));
 }
-function monthPhrase(ir) {
-  const segments = flattenSteps(segmentsOf(ir, "month"));
+function monthPhrase(schedule) {
+  const segments = flattenSteps(segmentsOf(schedule, "month"));
   return joinList(segments.map(function piece(segment) {
     if (segment.kind === "range") {
       return monthStems[monthNumber(segment.bounds[0])] + "kuusta " + monthStems[monthNumber(segment.bounds[1])] + "kuuhun";
@@ -1010,11 +1055,11 @@ function monthPhrase(ir) {
     return monthStems[monthNumber(segment.value)] + "kuussa";
   }));
 }
-function monthScope(ir) {
-  if (ir.pattern.month === "*") {
+function monthScope(schedule) {
+  if (schedule.pattern.month === "*") {
     return "";
   }
-  return " " + monthPhrase(ir);
+  return " " + monthPhrase(schedule);
 }
 function flattenSteps(segments) {
   return segments.flatMap(function flat(segment) {
@@ -1023,16 +1068,16 @@ function flattenSteps(segments) {
     }) : [segment];
   });
 }
-function datePhrase(ir, opts) {
-  const pattern = ir.pattern;
+function datePhrase(schedule, opts) {
+  const pattern = schedule.pattern;
   const quartz = quartzDatePhrase(pattern.date);
   if (quartz) {
-    return quartz + monthScope(ir);
+    return quartz + monthScope(schedule);
   }
   if (isOpenStep(pattern.date)) {
-    return stepDates(pattern.date, opts) + monthScope(ir);
+    return stepDates(pattern.date, opts) + monthScope(schedule);
   }
-  return monthAnchor(ir, opts) + " " + dateWords(ir) + " p\xE4iv\xE4n\xE4" + foldedYear(ir) + monthStepStart(pattern.month) + rangedMonthScope(ir);
+  return monthAnchor(schedule, opts) + " " + dateWords(schedule) + " p\xE4iv\xE4n\xE4" + foldedYear(schedule) + monthStepStart(pattern.month) + rangedMonthScope(schedule);
 }
 function monthStepStart(monthField) {
   if (!isOpenStep(monthField)) {
@@ -1044,30 +1089,30 @@ function monthStepStart(monthField) {
   }
   return " " + monthStems[monthNumber(start)] + "kuusta alkaen";
 }
-function monthAnchor(ir, opts) {
-  const monthField = ir.pattern.month;
-  if (monthField === "*" || monthRanged(ir)) {
+function monthAnchor(schedule, opts) {
+  const monthField = schedule.pattern.month;
+  if (monthField === "*" || monthRanged(schedule)) {
     return "kuukauden";
   }
   if (isOpenStep(monthField)) {
     return stepMonths(monthField, opts);
   }
-  const segments = flattenSteps(segmentsOf(ir, "month"));
+  const segments = flattenSteps(segmentsOf(schedule, "month"));
   return joinList(segments.map(function genitiveOf(segment) {
     const single = segment;
     return monthStems[monthNumber(single.value)] + "kuun";
   }));
 }
-function rangedMonthScope(ir) {
-  return monthRanged(ir) ? " " + monthPhrase(ir) : "";
+function rangedMonthScope(schedule) {
+  return monthRanged(schedule) ? " " + monthPhrase(schedule) : "";
 }
-function monthRanged(ir) {
-  return ir.pattern.month !== "*" && segmentsOf(ir, "month").some(function range(segment) {
+function monthRanged(schedule) {
+  return schedule.pattern.month !== "*" && segmentsOf(schedule, "month").some(function range(segment) {
     return segment.kind === "range";
   });
 }
-function dateWords(ir) {
-  return joinList(segmentsOf(ir, "date").flatMap(
+function dateWords(schedule) {
+  return joinList(segmentsOf(schedule, "date").flatMap(
     function word(segment) {
       if (segment.kind === "range") {
         return [segment.bounds[0] + ".\u2013" + segment.bounds[1] + "."];
@@ -1123,15 +1168,15 @@ function weekdayNumber(token) {
 function monthNumber(token) {
   return +token;
 }
-function applyYear(description, ir, opts) {
-  const yearField = ir.pattern.year;
+function applyYear(description, schedule, opts) {
+  const yearField = schedule.pattern.year;
   if (yearField === "*") {
     return description;
   }
   if (yearField.indexOf("/") !== -1) {
     return description + " " + stepYears(yearField, opts);
   }
-  if (foldedYear(ir) && ir.pattern.date !== "*") {
+  if (foldedYear(schedule) && schedule.pattern.date !== "*") {
     return description;
   }
   if (yearField.indexOf(",") !== -1) {
@@ -1151,8 +1196,8 @@ function stepYears(yearField, opts) {
   }
   return phrase;
 }
-function foldedYear(ir) {
-  const yearField = ir.pattern.year;
+function foldedYear(schedule) {
+  const yearField = schedule.pattern.year;
   if (yearField === "*" || yearField.indexOf("/") !== -1 || yearField.indexOf("-") !== -1 || yearField.indexOf(",") !== -1) {
     return "";
   }