cronli5 0.2.0 → 0.3.1

package/dist/lang/en.cjs

@@ -24,7 +24,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/util.ts
+// src/core/cadence.ts
 function arithmeticStep(values) {
   if (values.length < 5) {
     return null;
@@ -40,6 +40,56 @@ function arithmeticStep(values) {
   }
   return { start: values[0], interval, last: values[values.length - 1] };
 }
+function segmentsOf(schedule, field) {
+  return schedule.analyses.segments[field] ?? [];
+}
+function stepSegment(schedule, field) {
+  return segmentsOf(schedule, field)[0];
+}
+function singleValues(segments) {
+  const values = [];
+  for (const segment of segments) {
+    if (segment.kind !== "single") {
+      return null;
+    }
+    values.push(+segment.value);
+  }
+  return values;
+}
+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;
+  }
+  const interval = values[1] - values[0];
+  if (interval < 2) {
+    return null;
+  }
+  for (let i = 2; i < values.length; i += 1) {
+    if (values[i] - values[i - 1] !== interval) {
+      return null;
+    }
+  }
+  if (values[0] !== 0 && values.length < 5) {
+    return null;
+  }
+  return { interval, last: values[values.length - 1], start: values[0] };
+}
+
+// src/core/weekday.ts
 function weekdayDisplayKey(value) {
   return value === 0 ? 7 : value;
 }
@@ -61,6 +111,11 @@ function orderWeekdaysForDisplay(segments) {
   });
 }
 
+// src/core/shapes.ts
+function isOpenStep(field) {
+  return field.indexOf("/") !== -1 && field.indexOf("-") === -1 && field.indexOf(",") === -1;
+}
+
 // src/core/specs.ts
 var maxClockTimes = 6;
 
@@ -193,72 +248,134 @@ function normalizeOptions(options) {
     years: !!options.years
   };
 }
-function describe(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 describe(schedule, opts) {
+  const dense = denseCadence(schedule, opts);
+  if (dense !== null) {
+    return applyYear(dense, schedule, opts);
+  }
+  const body = confinement(schedule, opts) ?? render(schedule, schedule.plan, opts);
+  const lead = isDayUnion(schedule, opts) ? dayUnionMonthLead(schedule, opts) : "";
+  return applyYear(lead + body, 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 "every second" + trailingQualifier(ir, opts);
+function isCadenceShape(shape) {
+  return shape === "step" || shape === "range" || shape === "list";
+}
+function isDenseCadence(schedule, opts) {
+  if (!opts.style.untilWindow || opts.short || schedule.plan.kind !== "composeSeconds" || schedule.plan.rest.kind === "clockTimes" || isDayUnion(schedule, opts)) {
+    return false;
+  }
+  const { shapes } = schedule;
+  return isCadenceShape(shapes.second) && isCadenceShape(shapes.minute) && isCadenceShape(shapes.hour);
 }
-function renderStandaloneSeconds(ir, plan, opts) {
-  return secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+function denseHourFragment(schedule, opts) {
+  const stride = hourStride(schedule);
+  if (stride) {
+    return hourStrideCadence(stride, opts);
+  }
+  if (schedule.shapes.hour === "range") {
+    const segment = segmentsOf(schedule, "hour").find(function range(part) {
+      return part.kind === "range";
+    });
+    return rangeWindow({
+      continuous: false,
+      from: +segment.bounds[0],
+      throughMinute: 0,
+      to: +segment.bounds[1]
+    }, opts);
+  }
+  return "during the " + hourSegmentTimes(schedule, { minute: 0, second: null }, false, opts) + " hours";
+}
+function denseMinuteFragment(schedule, opts) {
+  if (schedule.shapes.minute === "step") {
+    return stepCycle60(stepSegment(schedule, "minute"), "minute", "hour", opts);
+  }
+  if (schedule.shapes.minute === "range") {
+    return minuteRangeLead(schedule.pattern.minute, opts);
+  }
+  return strideFromSegments(
+    segmentsOf(schedule, "minute"),
+    "minute",
+    "hour",
+    opts
+  ) ?? listPastThe(
+    segmentWords(segmentsOf(schedule, "minute"), opts),
+    "minute",
+    "hour",
+    opts
+  );
+}
+function denseCadence(schedule, opts) {
+  if (!isDenseCadence(schedule, opts)) {
+    return null;
+  }
+  const hour = denseHourFragment(schedule, opts);
+  const minute = denseMinuteFragment(schedule, opts);
+  const second = secondsClause(schedule, "minute", opts);
+  const nested = hour + ", " + minute + ", and within each of those minutes, " + second;
+  const anchor = trailingQualifier(schedule, opts).trim();
+  return anchor ? anchor + ", " + nested : nested;
 }
-function renderSecondPastMinute(ir, plan, opts) {
-  const secondField = ir.pattern.second;
-  return getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the minute, every minute" + trailingQualifier(ir, opts);
+function renderEverySecond(schedule, plan, opts) {
+  return "every second" + trailingQualifier(schedule, opts);
 }
-function renderSecondsWithinMinute(ir, plan, opts) {
-  const minuteField = ir.pattern.minute;
+function renderStandaloneSeconds(schedule, plan, opts) {
+  return secondsLeadClause(schedule, opts) + trailingQualifier(schedule, opts);
+}
+function renderSecondPastMinute(schedule, plan, opts) {
+  const secondField = schedule.pattern.second;
+  return getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the minute, every minute" + trailingQualifier(schedule, opts);
+}
+function renderSecondsWithinMinute(schedule, plan, opts) {
+  const minuteField = schedule.pattern.minute;
   const minuteWord = getNumber(minuteField, opts);
   const minuteUnit = pluralize(minuteField, "minute");
   if (plan.singleSecond) {
-    const secondField = ir.pattern.second;
-    return minuteWord + " " + minuteUnit + " and " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the hour, every hour" + trailingQualifier(ir, opts);
+    const secondField = schedule.pattern.second;
+    return minuteWord + " " + minuteUnit + " and " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the hour, every hour" + trailingQualifier(schedule, opts);
   }
-  return secondsLeadClause(ir, opts) + ", " + minuteWord + " " + minuteUnit + " past the hour, every hour" + trailingQualifier(ir, opts);
+  return secondsLeadClause(schedule, opts) + ", " + minuteWord + " " + minuteUnit + " past the hour, every hour" + 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 clockTimesConfinement(ir, rest, opts) {
-  if (+rest.times[0].minute === 0 && ir.shapes.minute === "single") {
-    return secondsLeadClause(ir, opts) + " for one minute at " + durationHours(ir, rest, opts);
+function clockTimesConfinement(schedule, rest, opts) {
+  if (+rest.times[0].minute === 0 && schedule.shapes.minute === "single") {
+    return secondsLeadClause(schedule, opts) + " for one minute at " + durationHours(schedule, rest, opts);
   }
-  return secondsLeadClause(ir, opts) + " of " + clockTimesOf(ir, rest, opts);
+  return secondsLeadClause(schedule, opts) + " of " + clockTimesOf(schedule, rest, 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 === "clockTimes" && (ir.shapes.second === "wildcard" || ir.shapes.second === "step")) {
-    return clockTimesConfinement(ir, plan.rest, opts);
+  if (plan.rest.kind === "clockTimes" && (schedule.shapes.second === "wildcard" || schedule.shapes.second === "step")) {
+    return clockTimesConfinement(schedule, plan.rest, opts);
   }
-  if (ir.shapes.second === "wildcard" && plan.rest.kind === "minuteFrequency" && plan.rest.hours.kind === "none" && ir.pattern.minute === "*/2") {
-    return "every second of every other minute" + trailingQualifier(ir, opts);
+  if (schedule.shapes.second === "wildcard" && plan.rest.kind === "minuteFrequency" && plan.rest.hours.kind === "none" && schedule.pattern.minute === "*/2") {
+    return "every second of every other minute" + trailingQualifier(schedule, opts);
   }
-  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 durationHours(ir, plan, opts) {
+function durationHours(schedule, plan, opts) {
   const hours = plan.times.map(function clock(time) {
     return getTime({ hour: time.hour, minute: 0 }, opts);
   });
-  const trail = dayQualifier(ir, leadingWords, opts);
+  const trail = dayQualifier(schedule, leadingWords, opts);
   return joinList(hours, opts) + (trail && ", " + trail);
 }
-function clockTimesOf(ir, plan, opts) {
+function clockTimesOf(schedule, plan, opts) {
   const times = plan.times.map(function clock(time) {
     return getTime({
       hour: time.hour,
@@ -267,21 +384,21 @@ function clockTimesOf(ir, plan, opts) {
       explicit: true
     }, opts);
   });
-  const trail = dayQualifier(ir, leadingWords, opts);
+  const trail = dayQualifier(schedule, leadingWords, opts);
   return joinList(times, opts) + (trail && ", " + trail);
 }
-function secondsLeadClause(ir, opts) {
-  return secondsClause(ir, "minute", opts);
+function secondsLeadClause(schedule, opts) {
+  return secondsClause(schedule, "minute", opts);
 }
-function secondsClause(ir, anchor, opts) {
-  const secondField = ir.pattern.second;
-  const shape = ir.shapes.second;
+function secondsClause(schedule, anchor, opts) {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
   if (secondField === "*") {
     return "every second";
   }
   if (shape === "step") {
     return stepCycle60(
-      ir.analyses.segments.second[0],
+      stepSegment(schedule, "second"),
       "second",
       anchor,
       opts
@@ -296,86 +413,96 @@ function secondsClause(ir, anchor, opts) {
     return "at " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the " + anchor;
   }
   return strideFromSegments(
-    ir.analyses.segments.second,
+    segmentsOf(schedule, "second"),
     "second",
     anchor,
     opts
   ) ?? listPastThe(
-    segmentWords(ir.analyses.segments.second, opts),
+    segmentWords(segmentsOf(schedule, "second"), opts),
     "second",
     anchor,
     opts
   );
 }
-function renderEveryMinute(ir, plan, opts) {
-  return "every minute" + trailingQualifier(ir, opts);
+function renderEveryMinute(schedule, plan, opts) {
+  return "every minute" + trailingQualifier(schedule, opts);
 }
-function renderSingleMinute(ir, plan, opts) {
-  const minuteField = ir.pattern.minute;
-  return getNumber(minuteField, opts) + " " + pluralize(minuteField, "minute") + " past the hour, every hour" + trailingQualifier(ir, opts);
+function renderSingleMinute(schedule, plan, opts) {
+  const minuteField = schedule.pattern.minute;
+  return getNumber(minuteField, opts) + " " + pluralize(minuteField, "minute") + " past the hour, every hour" + trailingQualifier(schedule, opts);
 }
-function renderRangeOfMinutes(ir, plan, opts) {
-  return minuteRangeLead(ir.pattern.minute, opts) + trailingQualifier(ir, opts);
+function renderRangeOfMinutes(schedule, plan, opts) {
+  return minuteRangeLead(schedule.pattern.minute, opts) + trailingQualifier(schedule, opts);
 }
-function renderMultipleMinutes(ir, plan, opts) {
-  const stride = strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts);
+function renderMultipleMinutes(schedule, plan, opts) {
+  const stride = strideFromSegments(segmentsOf(schedule, "minute"), "minute", "hour", opts);
   return (stride ?? listPastThe(segmentWords(
-    ir.analyses.segments.minute,
+    segmentsOf(schedule, "minute"),
     opts
-  ), "minute", "hour", opts)) + trailingQualifier(ir, opts);
+  ), "minute", "hour", opts)) + trailingQualifier(schedule, opts);
 }
-function renderMinuteFrequency(ir, plan, opts) {
+function renderMinuteFrequency(schedule, plan, opts) {
   let phrase = stepCycle60(
-    ir.analyses.segments.minute[0],
+    stepSegment(schedule, "minute"),
     "minute",
     "hour",
     opts
   );
   if (plan.hours.kind === "during") {
-    const cadence = unevenHourCadence(ir, opts);
-    phrase += cadence ? ", " + cadence : " during the " + hourTimesFromPlan(ir, plan.hours.times, false, opts) + " hours";
+    const cadence = unevenHourCadence(schedule, opts);
+    phrase += cadence ? ", " + cadence : " during the " + hourTimesFromPlan(schedule, plan.hours.times, false, opts) + " hours";
   } else if (plan.hours.kind === "window") {
-    phrase += " " + hourWindow(plan.hours, opts);
+    phrase += " " + rangeWindow({
+      continuous: false,
+      from: plan.hours.from,
+      throughMinute: plan.hours.last,
+      to: plan.hours.to
+    }, opts);
   } else if (plan.hours.kind === "step") {
-    phrase += " " + everyNthHour(ir.analyses.segments.hour[0], 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 "every minute of the " + getTime({ hour: plan.hour, minute: 0 }, opts) + " hour" + trailingQualifier(ir, opts);
+function renderMinuteSpanInHour(schedule, plan, opts) {
+  if (schedule.pattern.minute === "*") {
+    return "every minute of the " + getTime({ hour: plan.hour, minute: 0 }, opts) + " hour" + trailingQualifier(schedule, opts);
   }
-  return "every minute from " + getTime({ hour: plan.hour, minute: plan.span[0] }, opts) + through(opts) + getTime({ hour: plan.hour, minute: plan.span[1] }, opts) + trailingQualifier(ir, opts);
+  return "every minute from " + getTime({ hour: plan.hour, minute: plan.span[0] }, opts) + through(opts) + getTime({ hour: plan.hour, minute: plan.span[1] }, 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") {
     if (cadence !== null) {
-      return "every minute, " + cadence + trailingQualifier(ir, opts);
+      return "every minute, " + cadence + trailingQualifier(schedule, opts);
     }
-    return "every minute during the " + hourTimesFromPlan(ir, plan.times, false, opts) + " hours" + trailingQualifier(ir, opts);
+    return "every minute during the " + hourTimesFromPlan(schedule, plan.times, false, opts) + " hours" + trailingQualifier(schedule, opts);
   }
   if (plan.form === "range") {
-    const lead2 = minuteRangeLead(ir.pattern.minute, opts);
+    const lead2 = minuteRangeLead(schedule.pattern.minute, opts);
     if (cadence !== null) {
-      return lead2 + ", " + cadence + trailingQualifier(ir, opts);
+      return lead2 + ", " + cadence + trailingQualifier(schedule, opts);
     }
     if (singleHourFire(plan.times)) {
-      return lead2 + ", at " + hourTimesFromPlan(ir, plan.times, true, opts) + trailingQualifier(ir, opts);
+      return lead2 + ", at " + hourTimesFromPlan(schedule, plan.times, true, opts) + trailingQualifier(schedule, opts);
     }
-    return lead2 + " during the " + hourTimesFromPlan(ir, plan.times, false, opts) + " hours" + trailingQualifier(ir, opts);
+    return lead2 + " during the " + hourTimesFromPlan(schedule, plan.times, false, opts) + " hours" + trailingQualifier(schedule, opts);
   }
-  const lead = strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
-    segmentWords(ir.analyses.segments.minute, opts),
+  const lead = strideFromSegments(
+    segmentsOf(schedule, "minute"),
+    "minute",
+    "hour",
+    opts
+  ) ?? listPastThe(
+    segmentWords(segmentsOf(schedule, "minute"), opts),
     "minute",
     "hour",
     opts
   );
   if (cadence !== null) {
-    return lead + ", " + cadence + trailingQualifier(ir, opts);
+    return lead + ", " + cadence + trailingQualifier(schedule, opts);
   }
-  const times = hourTimesFromPlan(ir, plan.times, true, opts);
-  return lead + ", at " + times + trailingQualifier(ir, opts);
+  const times = hourTimesFromPlan(schedule, plan.times, true, opts);
+  return lead + ", at " + times + trailingQualifier(schedule, opts);
 }
 var stepOrdinals = {
   2: "other",
@@ -390,79 +517,91 @@ function everyNthHour(segment, opts) {
   const start = segment.startToken === "*" ? 0 : +segment.startToken;
   return start === 0 ? base : base + " starting at " + getTime({ hour: start, minute: 0 }, opts);
 }
-function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
-  const segment = ir.analyses.segments.hour[0];
+function renderMinuteSpanAcrossHourStep(schedule, plan, opts) {
+  const segment = stepSegment(schedule, "hour");
   if (plan.form === "wildcard") {
-    return "every minute " + everyNthHour(segment, opts) + trailingQualifier(ir, opts);
+    return "every minute " + everyNthHour(segment, opts) + trailingQualifier(schedule, opts);
   }
-  const lead = plan.form === "list" ? strideFromSegments(ir.analyses.segments.minute, "minute", "hour", opts) ?? listPastThe(
-    segmentWords(ir.analyses.segments.minute, opts),
+  const lead = plan.form === "list" ? strideFromSegments(
+    segmentsOf(schedule, "minute"),
     "minute",
     "hour",
     opts
-  ) : minuteRangeLead(ir.pattern.minute, opts);
-  const cadence = unevenHourCadence(ir, opts);
-  return lead + ", " + (cadence ?? stepHours(segment, opts)) + trailingQualifier(ir, opts);
+  ) ?? listPastThe(
+    segmentWords(segmentsOf(schedule, "minute"), opts),
+    "minute",
+    "hour",
+    opts
+  ) : minuteRangeLead(schedule.pattern.minute, opts);
+  const cadence = unevenHourCadence(schedule, opts);
+  return lead + ", " + (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
 }
 function minuteRangeLead(minuteField, opts) {
   const bounds = minuteField.split("-");
   const num = seriesNumber();
   return "every minute from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the hour";
 }
-function renderEveryHour(ir, plan, opts) {
-  return "every hour" + trailingQualifier(ir, opts);
+function renderEveryHour(schedule, plan, opts) {
+  return "every hour" + trailingQualifier(schedule, opts);
 }
-function renderHourRange(ir, plan, opts) {
+function renderHourRange(schedule, plan, opts) {
   const window = hourWindow(boundedWindow(plan), opts);
   if (plan.minuteForm === "wildcard") {
-    return "every minute " + window + trailingQualifier(ir, opts);
+    return "every minute " + window + trailingQualifier(schedule, opts);
   }
   if (plan.minuteForm === "range") {
-    return minuteRangeLead(ir.pattern.minute, opts) + ", " + window + trailingQualifier(ir, opts);
+    return minuteRangeLead(schedule.pattern.minute, opts) + ", " + window + trailingQualifier(schedule, opts);
   }
-  return rangeMinuteLead(ir, opts) + " " + window + trailingQualifier(ir, opts);
+  return rangeMinuteLead(schedule, opts) + " " + window + trailingQualifier(schedule, opts);
 }
-function rangeMinuteLead(ir, opts) {
-  if (ir.pattern.minute === "0") {
+function rangeMinuteLead(schedule, opts) {
+  if (schedule.pattern.minute === "0") {
     return "every hour";
   }
   return strideFromSegments(
-    ir.analyses.segments.minute,
+    segmentsOf(schedule, "minute"),
     "minute",
     "hour",
     opts
   ) ?? listPastThe(
-    segmentWords(ir.analyses.segments.minute, opts),
+    segmentWords(segmentsOf(schedule, "minute"), opts),
     "minute",
     "hour",
     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(ir.analyses.segments.hour[0], opts) + trailingQualifier(ir, opts);
+  return stepHours(stepSegment(schedule, "hour"), opts) + trailingQualifier(schedule, opts);
 }
 function boundedWindow(plan) {
-  const last = plan.minuteForm === "wildcard" ? plan.boundMinute ?? 0 : 0;
-  return { from: plan.from, last, to: plan.to };
+  const continuous = plan.minuteForm === "wildcard";
+  const closeMinute = continuous ? plan.boundMinute ?? 0 : 0;
+  return { from: plan.from, closeMinute, to: plan.to, continuous };
 }
-function rangeWindow(from, to, throughMinute, opts) {
+function rangeWindow(window, opts) {
+  const { from, to, throughMinute, continuous } = window;
   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 continuous ? open + " until " + getTime({ hour: (to + 1) % 24, minute: 0 }, opts) : open + through(opts) + getTime({ hour: to, minute: 0 }, opts);
   }
   return open + through(opts) + getTime({ hour: to, minute: throughMinute }, opts);
 }
 function hourWindow(window, opts) {
-  return rangeWindow(window.from, window.to, window.last, opts);
+  return rangeWindow({
+    continuous: window.continuous,
+    from: window.from,
+    throughMinute: window.closeMinute,
+    to: window.to
+  }, 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;
     }
@@ -476,93 +615,94 @@ function renderClockTimes(ir, plan, opts) {
       plain
     }, opts);
   });
-  return interpretDayQualifier(ir, opts) + "at " + joinList(times, opts) + dayUnionTrail(ir, opts);
+  return interpretDayQualifier(schedule, opts) + "at " + joinList(times, opts) + dayUnionTrail(schedule, opts);
 }
-function dayUnionTrail(ir, opts) {
-  return isDayUnion(ir, opts) ? dayUnionCondition(ir, opts) : "";
+function dayUnionTrail(schedule, opts) {
+  return isDayUnion(schedule, opts) ? dayUnionCondition(schedule, opts) : "";
 }
-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 hasRange = ir.analyses.segments.hour.some(function range(segment) {
+    const hasRange = segmentsOf(schedule, "hour").some(function range(segment) {
       return segment.kind === "range";
     });
-    if (hasRange && !ir.analyses.clockSecond) {
-      return foldedHourWindows(ir, plan, opts) + trailingQualifier(ir, opts);
+    if (hasRange && !schedule.analyses.clockSecond) {
+      return foldedHourWindows(schedule, plan, opts) + trailingQualifier(schedule, opts);
     }
-    const fold = { minute: plan.minute, second: ir.analyses.clockSecond };
-    return interpretDayQualifier(ir, opts) + "at " + hourSegmentTimes(ir, fold, true, opts) + dayUnionTrail(ir, opts);
+    const fold = { minute: plan.minute, second: schedule.analyses.clockSecond };
+    return interpretDayQualifier(schedule, opts) + "at " + hourSegmentTimes(schedule, fold, true, opts) + dayUnionTrail(schedule, opts);
   }
   const minuteLead = (
     // The non-fold branch 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),
+    strideFromSegments(
+      segmentsOf(schedule, "minute"),
+      "minute",
+      "hour",
+      opts
+    ) ?? listPastThe(
+      segmentWords(segmentsOf(schedule, "minute"), opts),
       "minute",
       "hour",
       opts
     )
   );
-  const cadence = unevenHourCadence(ir, opts);
-  const phrase = cadence ? minuteLead + ", " + cadence + trailingQualifier(ir, opts) : minuteLead + ", at " + hourSegmentTimes(ir, { minute: 0, second: null }, true, opts) + trailingQualifier(ir, opts);
-  return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase : phrase;
+  const cadence = unevenHourCadence(schedule, opts);
+  const phrase = cadence ? minuteLead + ", " + cadence + trailingQualifier(schedule, opts) : minuteLead + ", at " + hourSegmentTimes(schedule, { minute: 0, second: null }, true, opts) + trailingQualifier(schedule, opts);
+  return schedule.analyses.clockSecond ? secondsLeadClause(schedule, opts) + ", " + phrase : phrase;
 }
-function foldedHourWindows(ir, plan, opts) {
+function foldedHourWindows(schedule, plan, opts) {
   const minute = plan.minute;
   const windows = [];
-  const outliers = collectHourOutliers(ir);
-  const times = outliers.hours.map(function time(hour) {
+  const times = collectHourOutliers(schedule).map(function time(hour) {
     return getTime({ hour, minute }, opts);
   });
-  ir.analyses.segments.hour.forEach(function classify(segment) {
+  segmentsOf(schedule, "hour").forEach(function classify(segment) {
     if (segment.kind === "range") {
-      windows.push(rangeWindow(
-        +segment.bounds[0],
-        +segment.bounds[1],
-        minute,
-        opts
-      ));
+      windows.push(rangeWindow({
+        continuous: false,
+        from: +segment.bounds[0],
+        throughMinute: minute,
+        to: +segment.bounds[1]
+      }, opts));
     }
   });
-  const phrase = rangeMinuteLead(ir, opts) + " " + joinList(windows, opts);
-  return phrase + outlierTail(times, outliers.pureStrays, opts);
+  const phrase = rangeMinuteLead(schedule, opts) + " " + joinList(windows, opts);
+  return phrase + outlierTail(times, opts);
 }
-function collectHourOutliers(ir) {
+function collectHourOutliers(schedule) {
   const hours = [];
-  let pureStrays = true;
-  ir.analyses.segments.hour.forEach(function classify(segment) {
+  segmentsOf(schedule, "hour").forEach(function classify(segment) {
     if (segment.kind === "step") {
       hours.push(...segment.fires);
-      pureStrays = false;
     } else if (segment.kind !== "range") {
       hours.push(+segment.value);
     }
   });
-  return { hours, pureStrays };
+  return hours;
 }
-function outlierTail(times, pureStrays, opts) {
+function outlierTail(times, opts) {
   if (!times.length) {
     return "";
   }
-  const connector = pureStrays && opts.style.untilWindow && !opts.short ? " plus " : " and at ";
-  return connector + joinList(times, opts);
+  return " and at " + joinList(times, opts);
 }
 function isCadenceField(token) {
   return token === "*" || token.startsWith("*/") && token.indexOf("-") === -1;
 }
-function leadingCadence(ir, opts) {
-  const { second, minute } = ir.pattern;
+function leadingCadence(schedule, opts) {
+  const { second, minute } = schedule.pattern;
   if (isCadenceField(second)) {
-    return { secondLead: true, text: secondsClause(ir, "minute", opts) };
+    return { secondLead: true, text: secondsClause(schedule, "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],
+        stepSegment(schedule, "minute"),
         "minute",
         "hour",
         opts
@@ -572,19 +712,19 @@ function leadingCadence(ir, opts) {
   }
   return null;
 }
-function minuteConfinement(ir, opts) {
-  const minute = ir.pattern.minute;
+function minuteConfinement(schedule, opts) {
+  const minute = schedule.pattern.minute;
   if (minute === "*") {
     return "";
   }
   if (isCadenceField(minute)) {
     return " of every other minute";
   }
-  const segments = ir.analyses.segments.minute;
-  if (ir.shapes.minute === "single") {
+  const segments = segmentsOf(schedule, "minute");
+  if (schedule.shapes.minute === "single") {
     return " during minute :" + pad(minute);
   }
-  if (ir.shapes.minute === "range") {
+  if (schedule.shapes.minute === "range") {
     const bounds = minute.split("-");
     return " during minutes :" + pad(bounds[0]) + through(opts) + ":" + pad(bounds[1]);
   }
@@ -593,59 +733,61 @@ function minuteConfinement(ir, opts) {
   });
   return " during minutes " + joinList(values, opts);
 }
-function hourConfinement(ir, opts) {
-  const hour = ir.pattern.hour;
+function hourConfinement(schedule, opts) {
+  const hour = schedule.pattern.hour;
   if (hour === "*") {
-    const minutePinned = ir.pattern.minute !== "*" && !isCadenceField(ir.pattern.minute);
+    const minutePinned = schedule.pattern.minute !== "*" && !isCadenceField(schedule.pattern.minute);
     return minutePinned ? " of every hour" : "";
   }
   if (isCadenceField(hour)) {
     return hour === "*/2" ? " of every other hour" : "";
   }
-  if (ir.shapes.hour === "single") {
+  if (schedule.shapes.hour === "single") {
     const h = +hour;
-    if (ir.shapes.minute === "step") {
+    if (schedule.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)) {
+    if (schedule.pattern.minute !== "*" && !isCadenceField(schedule.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") {
+  if (schedule.shapes.hour === "range") {
     const bounds = hour.split("-");
-    return " " + rangeWindow(+bounds[0], +bounds[1], 0, opts);
+    return " " + rangeWindow({
+      continuous: schedule.pattern.minute === "*",
+      from: +bounds[0],
+      throughMinute: 0,
+      to: +bounds[1]
+    }, opts);
   }
-  return " during the " + hourSegmentTimes(ir, { minute: 0, second: null }, false, opts) + " hours";
+  return " during the " + hourSegmentTimes(schedule, { minute: 0, second: null }, false, opts) + " hours";
 }
-function isContiguousHourRange(ir) {
-  return ir.shapes.hour === "range";
-}
-function confinableHour(ir) {
-  if (ir.shapes.hour !== "step") {
+function confinableHour(schedule) {
+  if (schedule.shapes.hour !== "step") {
     return true;
   }
-  const segment = ir.analyses.segments.hour[0];
-  return ir.pattern.hour === "*/2" || segment.startToken.indexOf("-") !== -1;
+  const segment = stepSegment(schedule, "hour");
+  return schedule.pattern.hour === "*/2" || segment.startToken.indexOf("-") !== -1;
 }
-function isMinuteStride(ir) {
-  if (ir.shapes.minute !== "list") {
+function isMinuteStride(schedule) {
+  if (schedule.shapes.minute !== "list") {
     return false;
   }
-  const values = singleValues(ir.analyses.segments.minute);
+  const values = singleValues(segmentsOf(schedule, "minute"));
   return values !== null && arithmeticStep(values) !== null;
 }
-function confinementEligible(ir, lead) {
-  const { minute, hour } = ir.pattern;
+function confinementEligible(schedule, lead) {
+  const { minute, hour } = schedule.pattern;
   const minuteStep = isCadenceField(minute) && minute !== "*";
-  if (!confinableHour(ir)) {
+  if (!confinableHour(schedule)) {
     return false;
   }
   if (lead.secondLead) {
     if (minuteStep) {
-      return minute === "*/2" && !isContiguousHourRange(ir);
+      return minute === "*/2" && schedule.shapes.hour !== "range";
     }
-    if (isMinuteStride(ir) || ir.shapes.minute === "list" && ir.shapes.hour === "list") {
+    if (isMinuteStride(schedule) || schedule.shapes.minute === "list" && schedule.shapes.hour === "list") {
       return false;
     }
     return true;
@@ -653,21 +795,21 @@ function confinementEligible(ir, lead) {
   if (hour === "*/2") {
     return true;
   }
-  return ir.shapes.hour === "single" && minute === "*/2";
+  return schedule.shapes.hour === "single" && minute === "*/2";
 }
-function confinement(ir, opts) {
+function confinement(schedule, opts) {
   if (!opts.style.untilWindow || opts.short) {
     return null;
   }
-  if (ir.pattern.minute === "*" && ir.pattern.hour === "*") {
+  if (schedule.pattern.minute === "*" && schedule.pattern.hour === "*") {
     return null;
   }
-  const lead = leadingCadence(ir, opts);
-  if (!lead || !confinementEligible(ir, lead)) {
+  const lead = leadingCadence(schedule, opts);
+  if (!lead || !confinementEligible(schedule, lead)) {
     return null;
   }
-  const minutePart = lead.secondLead ? minuteConfinement(ir, opts) : "";
-  return lead.text + minutePart + hourConfinement(ir, opts) + trailingQualifier(ir, opts);
+  const minutePart = lead.secondLead ? minuteConfinement(schedule, opts) : "";
+  return lead.text + minutePart + hourConfinement(schedule, opts) + trailingQualifier(schedule, opts);
 }
 var renderers = {
   clockTimes: renderClockTimes,
@@ -689,33 +831,25 @@ var renderers = {
   singleMinute: renderSingleMinute,
   standaloneSeconds: renderStandaloneSeconds
 };
-function renderStride(stride, opts) {
+function renderStride2(stride, opts) {
   const { interval, start, last, cycle, unit, anchor } = stride;
   const cadence = "every " + getNumber(interval, opts) + " " + unit + "s";
-  const tiles = cycle % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence;
-  }
-  if (start < interval && tiles) {
-    return cadence + " from " + getNumber(start, opts) + " " + pluralize(start, unit) + " past the " + anchor;
-  }
-  const num = seriesNumber();
-  return cadence + " from " + num(start) + through(opts) + num(last) + " " + pluralize(last, unit) + " past the " + anchor;
-}
-function singleValues(segments) {
-  const values = [];
-  for (const segment of segments) {
-    if (segment.kind !== "single") {
-      return null;
+  return renderStride({ start, interval, cycle }, {
+    bare: () => cadence,
+    // A clean wrap from a non-zero offset: name the start, no endpoint.
+    offset: () => cadence + " from " + getNumber(start, opts) + " " + pluralize(start, unit) + " past the " + anchor,
+    // A bounded, non-wrapping set: pin both endpoints. Each bound is a value,
+    // so it reads as a digit, matching the range idiom ("from 0 through 30").
+    bounded: () => {
+      const num = seriesNumber();
+      return cadence + " from " + num(start) + through(opts) + num(last) + " " + pluralize(last, unit) + " past the " + anchor;
     }
-    values.push(+segment.value);
-  }
-  return values;
+  });
 }
 function strideFromSegments(segments, unit, anchor, opts) {
   const values = singleValues(segments);
   const step = values && arithmeticStep(values);
-  return step ? renderStride({ ...step, cycle: 60, unit, anchor }, opts) : null;
+  return step ? renderStride2({ ...step, cycle: 60, unit, anchor }, opts) : null;
 }
 function stepCycle60(segment, unit, anchor, opts) {
   if (segment.startToken.indexOf("-") !== -1) {
@@ -725,7 +859,7 @@ function stepCycle60(segment, unit, anchor, opts) {
   if (start !== 0 && segment.fires.length <= 3) {
     return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
   }
-  return renderStride({
+  return renderStride2({
     interval: segment.interval,
     start,
     last: segment.fires[segment.fires.length - 1],
@@ -751,45 +885,21 @@ function stepHours(segment, opts) {
 function hourStrideCadence(stride, opts) {
   const { start, interval, last } = stride;
   const cadence = "every " + getNumber(interval, opts) + " hours";
-  const tiles = 24 % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence;
-  }
-  if (start < interval && tiles) {
-    return cadence + " from " + getTime({ hour: start, minute: 0 }, opts);
-  }
-  return cadence + " from " + getTime({ hour: start, minute: 0 }, opts) + through(opts) + getTime({ hour: last, minute: 0 }, opts);
-}
-function offsetCleanStride(stride) {
-  return stride.start < stride.interval && 24 % stride.interval === 0;
+  return renderStride({ start, interval, cycle: 24 }, {
+    bare: () => cadence,
+    offset: () => cadence + " from " + getTime({ hour: start, minute: 0 }, opts),
+    bounded: () => cadence + " from " + getTime({ hour: start, minute: 0 }, opts) + through(opts) + getTime({ hour: last, minute: 0 }, opts)
+  });
 }
-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 hourListStride(values) {
-  if (values.length < 2) {
-    return null;
-  }
-  const interval = values[1] - values[0];
-  if (interval < 2) {
-    return null;
-  }
-  for (let i = 2; i < values.length; i += 1) {
-    if (values[i] - values[i - 1] !== interval) {
-      return null;
-    }
-  }
-  if (values[0] !== 0 && values.length < 5) {
-    return null;
-  }
-  return { interval, last: values[values.length - 1], start: values[0] };
-}
-function hourStride(ir) {
-  const segments = ir.analyses.segments.hour;
+function hourStride(schedule) {
+  const segments = segmentsOf(schedule, "hour");
   if (segments.length === 1 && segments[0].kind === "step") {
     const segment = segments[0];
     if (segment.fires.length < 2) {
@@ -801,83 +911,83 @@ function hourStride(ir) {
   const values = singleValues(segments);
   return values && hourListStride(values);
 }
-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 secondsClause(ir, "minute", opts) + " for one minute";
+    if (subMinuteSecond(schedule)) {
+      return secondsClause(schedule, "minute", opts) + " for one minute";
     }
-    return secondsClause(ir, "hour", opts);
+    return secondsClause(schedule, "hour", opts);
   }
   const minutePhrase = getNumber(minute, opts) + " " + pluralize(minute, "minute") + " past the hour";
-  if (ir.pattern.second === "0") {
+  if (schedule.pattern.second === "0") {
     return minutePhrase;
   }
-  return secondsClause(ir, "minute", opts) + ", " + minutePhrase;
+  return secondsClause(schedule, "minute", 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 minuteZeroStride = minute === 0 && subMinuteSecond(ir) && cleanStrideSegment(ir);
+  const minuteZeroStride = minute === 0 && subMinuteSecond(schedule) && cleanStrideSegment(schedule);
   if (minuteZeroStride) {
-    return secondsClause(ir, "minute", opts) + " for one minute " + everyNthHour(minuteZeroStride, opts) + trailingQualifier(ir, opts);
+    return secondsClause(schedule, "minute", opts) + " for one minute " + everyNthHour(minuteZeroStride, 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 cleanStrideSegment(ir) {
-  const segments = ir.analyses.segments.hour;
+function cleanStrideSegment(schedule) {
+  const segments = segmentsOf(schedule, "hour");
   const segment = segments.length === 1 && segments[0];
   if (!segment || segment.kind !== "step" || segment.startToken.indexOf("-") !== -1 || !(segment.interval in stepOrdinals)) {
     return null;
   }
   return segment;
 }
-function hasHourWindow(ir) {
-  return ir.analyses.segments.hour.some(function range(segment) {
+function hasHourWindow(schedule) {
+  return segmentsOf(schedule, "hour").some(function range(segment) {
     return segment.kind === "range";
   });
 }
-function hourRangeWindowTail(ir, opts) {
+function hourRangeWindowTail(schedule, opts) {
   const windows = [];
-  const outliers = collectHourOutliers(ir);
-  ir.analyses.segments.hour.forEach(function classify(segment) {
+  const outlierHours = collectHourOutliers(schedule);
+  segmentsOf(schedule, "hour").forEach(function classify(segment) {
     if (segment.kind === "range") {
-      windows.push(rangeWindow(
-        +segment.bounds[0],
-        +segment.bounds[1],
-        0,
-        opts
-      ));
+      windows.push(rangeWindow({
+        continuous: false,
+        from: +segment.bounds[0],
+        throughMinute: 0,
+        to: +segment.bounds[1]
+      }, opts));
     }
   });
   const phrase = "every hour " + joinList(windows, opts);
-  const times = outliers.hours.map(function time(hour) {
+  const times = outlierHours.map(function time(hour) {
     return getTime({ hour, minute: 0 }, opts);
   });
-  return phrase + outlierTail(times, outliers.pureStrays, opts);
+  return phrase + outlierTail(times, opts);
 }
-function hourRangeCadence(ir, minute, opts) {
-  if (minute !== 0 || !hasHourWindow(ir)) {
+function hourRangeCadence(schedule, minute, opts) {
+  if (minute !== 0 || !hasHourWindow(schedule)) {
     return null;
   }
-  if (ir.pattern.second === "0") {
+  if (schedule.pattern.second === "0") {
     return null;
   }
-  if (subMinuteSecond(ir)) {
-    return secondsClause(ir, "minute", opts) + " for one minute during the " + hourSegmentTimes(ir, { minute: 0, second: null }, false, opts) + " hours" + trailingQualifier(ir, opts);
+  if (subMinuteSecond(schedule)) {
+    return secondsClause(schedule, "minute", opts) + " for one minute during the " + hourSegmentTimes(schedule, { minute: 0, second: null }, false, opts) + " hours" + trailingQualifier(schedule, opts);
   }
-  return hourCadenceLead(ir, minute, opts) + ", " + hourRangeWindowTail(ir, opts) + trailingQualifier(ir, opts);
+  return hourCadenceLead(schedule, minute, opts) + ", " + hourRangeWindowTail(schedule, opts) + trailingQualifier(schedule, opts);
 }
 function seriesNumber() {
   return function format(n) {
@@ -936,11 +1046,11 @@ function hourTimes(hours, opts) {
 function singleHourFire(times) {
   return times.kind === "fires" && times.fires.length === 1;
 }
-function hourTimesFromPlan(ir, times, atContext, opts) {
+function hourTimesFromPlan(schedule, times, atContext, opts) {
   if (times.kind === "fires") {
     return hourTimes(times.fires, opts);
   }
-  return hourSegmentTimes(ir, { minute: 0, second: null }, atContext, opts);
+  return hourSegmentTimes(schedule, { minute: 0, second: null }, atContext, opts);
 }
 function segmentHours(segment) {
   if (segment.kind === "range") {
@@ -948,9 +1058,9 @@ function segmentHours(segment) {
   }
   return segment.kind === "step" ? segment.fires : [segment.value];
 }
-function hourSegmentTimes(ir, fold, atContext, opts) {
+function hourSegmentTimes(schedule, fold, atContext, opts) {
   const { minute, second } = fold;
-  const segments = ir.analyses.segments.hour;
+  const segments = segmentsOf(schedule, "hour");
   const plain = mixedTwelve(segments.flatMap(function entries(segment) {
     return segmentHours(segment).map(function entry(hour) {
       return { hour: +hour, minute, second };
@@ -1013,85 +1123,85 @@ var leadingWords = {
   stepDate: "",
   weekday: "every "
 };
-function trailingQualifier(ir, opts) {
-  if (isDayUnion(ir, opts)) {
-    return dayUnionCondition(ir, opts);
+function trailingQualifier(schedule, opts) {
+  if (isDayUnion(schedule, opts)) {
+    return dayUnionCondition(schedule, opts);
   }
-  const phrase = dayQualifier(ir, trailingWords, opts);
+  const phrase = dayQualifier(schedule, trailingWords, opts);
   return phrase && " " + phrase;
 }
-function interpretDayQualifier(ir, opts) {
-  if (isDayUnion(ir, opts)) {
+function interpretDayQualifier(schedule, opts) {
+  if (isDayUnion(schedule, opts)) {
     return "";
   }
-  return dayQualifier(ir, leadingWords, opts) + " ";
+  return dayQualifier(schedule, leadingWords, opts) + " ";
 }
-function dayQualifier(ir, words, opts) {
-  const pattern = ir.pattern;
+function dayQualifier(schedule, words, opts) {
+  const pattern = schedule.pattern;
   if (pattern.date !== "*" && pattern.weekday !== "*") {
-    return dateOrWeekday(ir, opts);
+    return dateOrWeekday(schedule, opts);
   }
   if (pattern.date !== "*") {
-    return datePhrase(ir, words, opts);
+    return datePhrase(schedule, words, opts);
   }
   if (pattern.weekday !== "*") {
     const quartzWeekday = quartzWeekdayPhrase(pattern.weekday, opts);
     if (quartzWeekday) {
-      return monthScopeForRecurrence(quartzWeekday, ir, opts);
+      return monthScopeForRecurrence(quartzWeekday, schedule, opts);
     }
-    const weekdays = words.weekday + weekdayPhrase(ir, words.recurringWeekday, opts);
-    return weekdays + monthScope(ir, opts);
+    const weekdays = words.weekday + weekdayPhrase(schedule, words.recurringWeekday, opts);
+    return weekdays + monthScope(schedule, opts);
   }
   if (pattern.month !== "*") {
-    return words.month + monthName(ir, opts);
+    return words.month + monthName(schedule, opts);
   }
   return words.all;
 }
-function datePhrase(ir, words, opts) {
-  const pattern = ir.pattern;
+function datePhrase(schedule, words, opts) {
+  const pattern = schedule.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
   if (quartzDate) {
-    return monthScopeForRecurrence(quartzDate, ir, opts);
+    return monthScopeForRecurrence(quartzDate, schedule, opts);
   }
   if (isOpenStep(pattern.date)) {
     return monthScopeForRecurrence(
       words.stepDate + stepDates(pattern.date),
-      ir,
+      schedule,
       opts
     );
   }
-  if (pattern.month !== "*" && !monthFoldsIntoDate(ir)) {
-    return "on the " + dateOrdinals(ir, opts) + monthScope(ir, opts);
+  if (pattern.month !== "*" && !monthFoldsIntoDate(schedule)) {
+    return "on the " + dateOrdinals(schedule, opts) + monthScope(schedule, opts);
   }
   if (pattern.month !== "*") {
-    return "on " + monthDatePhrase(ir, opts);
+    return "on " + monthDatePhrase(schedule, opts);
   }
-  return "on the " + dateOrdinals(ir, opts);
+  return "on the " + dateOrdinals(schedule, opts);
 }
-function monthFoldsIntoDate(ir) {
-  return !oddEvenMonth(ir.pattern.month) && // Reached only with a restricted month, which has segments.
-  ir.analyses.segments.month.every(function flat(segment) {
+function monthFoldsIntoDate(schedule) {
+  return !oddEvenMonth(schedule.pattern.month) && // Reached only with a restricted month, which has segments.
+  segmentsOf(schedule, "month").every(function flat(segment) {
     return segment.kind !== "range";
   });
 }
-function isDayUnion(ir, opts) {
-  return ir.pattern.date !== "*" && ir.pattern.weekday !== "*" && !!opts.style.untilWindow && !opts.short;
+function isDayUnion(schedule, opts) {
+  return schedule.pattern.date !== "*" && schedule.pattern.weekday !== "*" && !!opts.style.untilWindow && !opts.short;
 }
-function dayUnionCondition(ir, opts) {
+function dayUnionCondition(schedule, opts) {
   const pieces = [
-    ...dayUnionDatePieces(ir, opts),
-    ...dayUnionWeekdayPieces(ir, opts)
+    ...dayUnionDatePieces(schedule, opts),
+    ...dayUnionWeekdayPieces(schedule, opts)
   ];
   return " whenever the day is " + joinOr(pieces, opts);
 }
-function dayUnionMonthLead(ir, opts) {
-  if (ir.pattern.month === "*") {
+function dayUnionMonthLead(schedule, opts) {
+  if (schedule.pattern.month === "*") {
     return "";
   }
-  return "in " + monthName(ir, opts) + " ";
+  return "in " + monthName(schedule, opts) + " ";
 }
-function dayUnionDatePieces(ir, opts) {
-  const dateField = ir.pattern.date;
+function dayUnionDatePieces(schedule, opts) {
+  const dateField = schedule.pattern.date;
   const quartz = quartzDatePhrase(dateField, opts);
   if (quartz) {
     return [quartz.replace(/^on /, "")];
@@ -1101,7 +1211,7 @@ function dayUnionDatePieces(ir, opts) {
     return [oddEven];
   }
   const pieces = [];
-  ir.analyses.segments.date.forEach(function expand(segment) {
+  segmentsOf(schedule, "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") {
@@ -1114,14 +1224,14 @@ function dayUnionDatePieces(ir, opts) {
   });
   return pieces;
 }
-function dayUnionWeekdayPieces(ir, opts) {
-  const weekdayField = ir.pattern.weekday;
+function dayUnionWeekdayPieces(schedule, opts) {
+  const weekdayField = schedule.pattern.weekday;
   const quartz = quartzWeekdayPhrase(weekdayField, opts);
   if (quartz) {
     return [quartz.replace(/^on /, "")];
   }
   const pieces = [];
-  ir.analyses.segments.weekday.forEach(function expand(segment) {
+  segmentsOf(schedule, "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") {
@@ -1149,16 +1259,16 @@ function oddEvenDay(dateField) {
   }
   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, 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);
+function dateOrWeekday(schedule, opts) {
+  const pattern = schedule.pattern;
+  const weekdayPart = quartzWeekdayPhrase(pattern.weekday, opts) || "on " + weekdayPhrase(schedule, false, opts);
+  if (pattern.month !== "*" && monthFoldsIntoDate(schedule) && !quartzDatePhrase(pattern.date, opts) && !isOpenStep(pattern.date)) {
+    return "on " + monthDatePhrase(schedule, opts) + " or " + weekdayPart + " in " + monthName(schedule, opts);
   }
-  return datePart(ir, opts) + " or " + weekdayPart + orMonthScope(ir, opts);
+  return datePart(schedule, opts) + " or " + weekdayPart + orMonthScope(schedule, opts);
 }
-function datePart(ir, opts) {
-  const pattern = ir.pattern;
+function datePart(schedule, opts) {
+  const pattern = schedule.pattern;
   const quartzDate = quartzDatePhrase(pattern.date, opts);
   if (quartzDate) {
     return quartzDate;
@@ -1166,13 +1276,13 @@ function datePart(ir, opts) {
   if (isOpenStep(pattern.date)) {
     return stepDates(pattern.date);
   }
-  return "on the " + dateOrdinals(ir, opts);
+  return "on the " + dateOrdinals(schedule, opts);
 }
-function orMonthScope(ir, opts) {
-  if (ir.pattern.month === "*") {
+function orMonthScope(schedule, opts) {
+  if (schedule.pattern.month === "*") {
     return "";
   }
-  return ", in " + monthName(ir, opts);
+  return ", in " + monthName(schedule, opts);
 }
 function quartzDatePhrase(dateField, opts) {
   if (dateField === "L") {
@@ -1199,39 +1309,39 @@ function quartzWeekdayPhrase(weekdayField, opts) {
     return "on the last " + getWeekday(weekdayField.slice(0, -1), opts) + " of the month";
   }
 }
-function monthDatePhrase(ir, opts) {
-  const month = monthName(ir, opts);
+function monthDatePhrase(schedule, opts) {
+  const month = monthName(schedule, opts);
   const days = renderSegments(
-    ir.analyses.segments.date,
+    segmentsOf(schedule, "date"),
     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;
+  if (opts.style.dayFirst && schedule.shapes.date === "single" && schedule.shapes.month !== "single") {
+    return "the " + getOrdinal(schedule.pattern.date) + " of " + month;
   }
   return opts.style.dayFirst ? days + " " + month : month + " " + days;
 }
 function cardinalDay(value) {
   return "" + value;
 }
-function monthScope(ir, opts) {
-  if (ir.pattern.month === "*") {
+function monthScope(schedule, opts) {
+  if (schedule.pattern.month === "*") {
     return "";
   }
-  return " in " + monthName(ir, opts);
+  return " in " + monthName(schedule, opts);
 }
-function monthScopeForRecurrence(phrase, ir, opts) {
-  if (ir.pattern.month === "*") {
+function monthScopeForRecurrence(phrase, schedule, opts) {
+  if (schedule.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 && schedule.shapes.month === "range") {
+    return phrase.replace(" of the month", " of each month") + " from " + monthName(schedule, opts);
   }
-  if (carriesRecurrence && (ir.shapes.month === "single" || ir.shapes.month === "step")) {
-    return phrase.replace(" of the month", "") + " in " + monthName(ir, opts);
+  if (carriesRecurrence && (schedule.shapes.month === "single" || schedule.shapes.month === "step")) {
+    return phrase.replace(" of the month", "") + " in " + monthName(schedule, opts);
   }
-  return phrase + " in " + monthName(ir, opts);
+  return phrase + " in " + monthName(schedule, opts);
 }
 function stepDates(dateField) {
   const parts = dateField.split("/");
@@ -1244,15 +1354,15 @@ function stepDates(dateField) {
   }
   return phrase;
 }
-function dateOrdinals(ir, opts) {
-  return renderSegments(ir.analyses.segments.date, getOrdinal, opts);
+function dateOrdinals(schedule, opts) {
+  return renderSegments(segmentsOf(schedule, "date"), getOrdinal, opts);
 }
-function monthName(ir, opts) {
-  const oddEven = oddEvenMonth(ir.pattern.month);
+function monthName(schedule, opts) {
+  const oddEven = oddEvenMonth(schedule.pattern.month);
   if (oddEven) {
     return oddEven;
   }
-  return renderSegments(ir.analyses.segments.month, function name(value) {
+  return renderSegments(segmentsOf(schedule, "month"), function name(value) {
     return getMonth(value, opts);
   }, opts);
 }
@@ -1269,8 +1379,8 @@ function oddEvenMonth(monthField) {
   }
   return start === "2" ? "every even-numbered month" : null;
 }
-function weekdayPhrase(ir, recurring, opts) {
-  const segments = orderWeekdaysForDisplay(ir.analyses.segments.weekday);
+function weekdayPhrase(schedule, recurring, opts) {
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, "weekday"));
   const hasRange = segments.some(function range(segment) {
     return segment.kind === "range";
   });
@@ -1298,11 +1408,8 @@ function renderSegments(segments, word, opts) {
   });
   return joinList(pieces, opts);
 }
-function isOpenStep(field) {
-  return field.indexOf("/") !== -1 && field.indexOf("-") === -1 && field.indexOf(",") === -1;
-}
-function applyYear(description, ir, opts) {
-  const yearField = ir.pattern.year;
+function applyYear(description, schedule, opts) {
+  const yearField = schedule.pattern.year;
   if (yearField === "*") {
     return description;
   }
@@ -1310,7 +1417,7 @@ function applyYear(description, ir, 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) {
+  if (yearField.indexOf("-") === -1 && yearField.indexOf(",") === -1 && schedule.pattern.date !== "*" && description.indexOf(" at ") !== -1) {
     const yearGlue = opts.style.dayFirst ? " " : ", ";
     return description.replace(" at ", yearGlue + label + " at ");
   }