cronli5 0.2.1 → 0.3.4

package/dist/lang/zh.cjs

@@ -24,11 +24,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/util.ts
-function isNonNegativeInteger(value) {
-  const digits = /^\d+$/;
-  return digits.test(value);
-}
+// src/core/cadence.ts
 function arithmeticStep(values) {
   if (values.length < 5) {
     return null;
@@ -44,6 +40,70 @@ 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/util.ts
+function isNonNegativeInteger(value) {
+  const digits = /^\d+$/;
+  return digits.test(value);
+}
+function toFieldNumber(token, numberMap) {
+  return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
+}
+
+// src/core/shapes.ts
+function isOpenStep(field) {
+  return field.indexOf("/") !== -1 && field.indexOf("-") === -1 && field.indexOf(",") === -1;
+}
+
+// src/core/weekday.ts
 function weekdayDisplayKey(value) {
   return value === 0 ? 7 : value;
 }
@@ -64,25 +124,6 @@ function orderWeekdaysForDisplay(segments) {
     return pair[0];
   });
 }
-function toFieldNumber(token, numberMap) {
-  return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
-}
-function segmentsOf(ir, field) {
-  return ir.analyses.segments[field] ?? [];
-}
-function stepSegment(ir, field) {
-  return segmentsOf(ir, field)[0];
-}
-function singleValues(segments) {
-  const values = [];
-  for (const segment of segments) {
-    if (segment.kind !== "single") {
-      return null;
-    }
-    values.push(+segment.value);
-  }
-  return values;
-}
 
 // src/core/specs.ts
 var weekdayNumbers = {
@@ -133,19 +174,19 @@ function joinAnd(items) {
 function cadence(interval, unit) {
   return interval === 1 ? "\u6BCF" + unit : "\u6BCF" + interval + unit;
 }
-function renderStride(stride) {
+function renderStride2(stride) {
   const { interval, start, last, cycle, unit, mark, anchor } = stride;
-  const tiles = cycle % interval === 0;
-  if (start === 0 && tiles) {
-    return cadence(interval, unit);
-  }
   const lead = anchor + "\u4ECE" + start + mark + "\u8D77" + cadence(interval, unit);
-  return start < interval && tiles ? lead : lead + "\uFF0C\u81F3" + last + mark;
+  return renderStride({ start, interval, cycle }, {
+    bare: () => cadence(interval, unit),
+    offset: () => lead,
+    bounded: () => lead + "\uFF0C\u81F3" + last + mark
+  });
 }
 function strideFromSegments(segments, unit, mark, anchor) {
   const values = singleValues(segments);
   const step = values && arithmeticStep(values);
-  return step ? renderStride({ ...step, cycle: 60, unit, mark, anchor }) : null;
+  return step ? renderStride2({ ...step, cycle: 60, unit, mark, anchor }) : null;
 }
 function stepClause(segment, unit, mark, anchor) {
   const start = segment.startToken === "*" ? 0 : +segment.startToken;
@@ -153,7 +194,7 @@ function stepClause(segment, unit, mark, anchor) {
   if (segment.startToken.indexOf("-") !== -1 || short) {
     return anchor + segment.fires.join("\u3001") + mark;
   }
-  return renderStride({
+  return renderStride2({
     interval: segment.interval,
     start,
     last: segment.fires[segment.fires.length - 1],
@@ -203,9 +244,9 @@ function hourWord(hour) {
   }
   return hour === 12 ? "\u6B63\u5348" : hour + "\u70B9";
 }
-function hourFires(ir) {
+function hourFires(schedule) {
   const fires = [];
-  segmentsOf(ir, "hour").forEach(function expand(segment) {
+  segmentsOf(schedule, "hour").forEach(function expand(segment) {
     if (segment.kind === "step") {
       fires.push(...segment.fires);
     } else if (segment.kind === "range") {
@@ -259,15 +300,15 @@ function renderEveryMinute() {
 function renderEveryHour() {
   return "\u6BCF\u5C0F\u65F6";
 }
-function minuteHourClause(ir) {
-  const segments = segmentsOf(ir, "minute");
-  if (ir.shapes.minute === "step") {
-    return stepClause(stepSegment(ir, "minute"), "\u5206\u949F", "\u5206", "\u6BCF\u5C0F\u65F6");
+function minuteHourClause(schedule) {
+  const segments = segmentsOf(schedule, "minute");
+  if (schedule.shapes.minute === "step") {
+    return stepClause(stepSegment(schedule, "minute"), "\u5206\u949F", "\u5206", "\u6BCF\u5C0F\u65F6");
   }
   return strideFromSegments(segments, "\u5206\u949F", "\u5206", "\u6BCF\u5C0F\u65F6") ?? "\u6BCF\u5C0F\u65F6" + valueList(segments, "\u5206");
 }
-function renderMinutePast(ir) {
-  return minuteHourClause(ir);
+function renderMinutePast(schedule) {
+  return minuteHourClause(schedule);
 }
 function hourSegmentWords(segment) {
   if (segment.kind === "range") {
@@ -278,62 +319,62 @@ function hourSegmentWords(segment) {
   }
   return [hourWord(+segment.value)];
 }
-function hourList(ir) {
-  const words = segmentsOf(ir, "hour").flatMap(hourSegmentWords);
+function hourList(schedule) {
+  const words = segmentsOf(schedule, "hour").flatMap(hourSegmentWords);
   return joinAnd(words);
 }
-function hourFrame(ir) {
-  if (ir.shapes.hour === "range") {
-    const [from, to] = segmentsOf(ir, "hour")[0].bounds;
+function hourFrame(schedule) {
+  if (schedule.shapes.hour === "range") {
+    const [from, to] = segmentsOf(schedule, "hour")[0].bounds;
     return "\u5728" + hourWord(+from) + "\u81F3" + hourWord(+to) + "\u4E4B\u95F4\uFF0C";
   }
-  return "\u5728" + hourList(ir) + "\uFF0C";
+  return "\u5728" + hourList(schedule) + "\uFF0C";
 }
-function renderMinuteFrequency(ir, plan) {
-  const minuteStep = stepSegment(ir, "minute");
+function renderMinuteFrequency(schedule, plan) {
+  const minuteStep = stepSegment(schedule, "minute");
   const base = stepClause(minuteStep, UNITS.minute, "\u5206", "\u6BCF\u5C0F\u65F6");
   const { hours } = plan;
   if (hours.kind === "step" || hours.kind === "during") {
-    const hourCad = hourCadencePhrase(ir);
+    const hourCad = unevenHourCadence(schedule);
     if (hourCad !== null) {
       return hourCad + (hourCad.indexOf("\u81F3") === -1 ? "" : "\uFF0C") + base;
     }
   }
-  if (hours.kind === "single" || hours.kind === "window" && hours.from === hours.to) {
+  if (hours.kind === "window" && hours.from === hours.to) {
     return "\u5728" + hourWord(hours.from) + "\u81F3" + hours.from + "\u70B9" + hours.last + "\u5206\u4E4B\u95F4\uFF0C" + base;
   }
   if (hours.kind === "window") {
     return "\u5728" + hourWord(hours.from) + "\u81F3" + hourWord(hours.to) + "\u4E4B\u95F4\uFF0C" + base;
   }
   if (hours.kind === "during") {
-    return "\u5728" + hourList(ir) + "\uFF0C" + base;
+    return "\u5728" + hourList(schedule) + "\uFF0C" + base;
   }
   return base;
 }
-function renderMinuteSpanInHour(ir, plan) {
+function renderMinuteSpanInHour(schedule, plan) {
   const span = plan;
-  if (ir.pattern.minute === "*") {
+  if (schedule.pattern.minute === "*") {
     return hourWord(span.hour) + "\u7684\u6BCF\u4E00\u5206\u949F";
   }
   return "\u5728" + hourWord(span.hour) + "\u81F3" + span.hour + "\u70B9" + span.span[1] + "\u5206\u4E4B\u95F4\uFF0C\u6BCF\u5206\u949F";
 }
-function renderMinutesAcrossHours(ir, plan) {
+function renderMinutesAcrossHours(schedule, plan) {
   const { form } = plan;
-  const hourCad = hourCadencePhrase(ir);
+  const hourCad = unevenHourCadence(schedule);
   if (form === "wildcard") {
-    return hourCad === null ? "\u5728" + hourList(ir) + "\uFF0C\u6BCF\u5206\u949F" : hourCad + "\uFF0C\u6BCF\u5206\u949F";
+    return hourCad === null ? "\u5728" + hourList(schedule) + "\uFF0C\u6BCF\u5206\u949F" : hourCad + "\uFF0C\u6BCF\u5206\u949F";
   }
-  return (hourCad ?? hourList(ir)) + "\uFF0C" + minuteHourClause(ir) + "\uFF0C\u6BCF\u5206\u949F";
+  return (hourCad ?? hourList(schedule)) + "\uFF0C" + minuteHourClause(schedule) + "\uFF0C\u6BCF\u5206\u949F";
 }
-function renderMinuteSpanAcrossHourStep(ir, plan) {
-  const hourStep = stepSegment(ir, "hour");
+function renderMinuteSpanAcrossHourStep(schedule, plan) {
+  const hourStep = stepSegment(schedule, "hour");
   const { form } = plan;
   if (form === "list") {
-    return hourCadencePhrase(ir) + "\uFF0C" + renderMinutePast(ir);
+    return hourCadencePhrase(schedule) + "\uFF0C" + renderMinutePast(schedule);
   }
-  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : minuteHourClause(ir) + "\uFF0C\u6BCF\u5206\u949F";
+  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : minuteHourClause(schedule) + "\uFF0C\u6BCF\u5206\u949F";
   if (hourStep.startToken !== "*") {
-    return hourCadencePhrase(ir) + "\uFF0C" + minuteTail;
+    return hourCadencePhrase(schedule) + "\uFF0C" + minuteTail;
   }
   if (hourStep.interval === 2 && form === "wildcard") {
     return "\u5728\u5076\u6570\u5C0F\u65F6\uFF0C" + minuteTail;
@@ -341,62 +382,62 @@ function renderMinuteSpanAcrossHourStep(ir, plan) {
   const cad = cadence(hourStep.interval, UNITS.hour);
   return form === "wildcard" ? cad + "\u5185\uFF0C" + minuteTail : cad + "\uFF0C" + minuteTail;
 }
-function renderClockTimes(ir, plan, opts) {
-  const cad = hourCadenceText(ir);
+function renderClockTimes(schedule, plan, opts) {
+  const cad = hourCadenceText(schedule);
   if (cad !== null) {
     return cad;
   }
   const { times } = plan;
   return joinAnd(times.map((t) => clockTime(t.hour, t.minute, t.second, opts)));
 }
-function renderCompactClockTimes(ir, plan) {
-  const cad = hourCadenceText(ir);
+function renderCompactClockTimes(schedule, plan) {
+  const cad = hourCadenceText(schedule);
   if (cad !== null) {
     return cad;
   }
   const compact = plan;
-  const secs = segmentsOf(ir, "second");
-  const tail = secs.length && ir.pattern.second !== "0" ? "\uFF0C\u7B2C" + valueText(secs) + "\u79D2" : "";
+  const secs = segmentsOf(schedule, "second");
+  const tail = secs.length && schedule.pattern.second !== "0" ? "\uFF0C\u7B2C" + valueText(secs) + "\u79D2" : "";
   if (!compact.fold) {
-    const hourCad = hourCadencePhrase(ir);
-    return hourCad === null ? minuteHourClause(ir) + "\uFF0C\u5728" + hourList(ir) + tail : hourCad + "\uFF0C" + minuteHourClause(ir) + tail;
+    const hourCad = unevenHourCadence(schedule);
+    return hourCad === null ? minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail : hourCad + "\uFF0C" + minuteHourClause(schedule) + tail;
   }
   if (compact.minute > 0) {
-    return minuteHourClause(ir) + "\uFF0C\u5728" + hourList(ir) + tail;
+    return minuteHourClause(schedule) + "\uFF0C\u5728" + hourList(schedule) + tail;
   }
-  return hourList(ir) + tail;
+  return hourList(schedule) + tail;
 }
-function renderHourRange(ir, plan) {
+function renderHourRange(schedule, plan) {
   const range = plan;
   if (range.minuteForm === "lead") {
-    const minuteSegs = segmentsOf(ir, "minute");
-    const past = minuteSegs.length && ir.pattern.minute !== "0" ? minuteHourClause(ir) : "\u6BCF\u5C0F\u65F6";
+    const minuteSegs = segmentsOf(schedule, "minute");
+    const past = minuteSegs.length && schedule.pattern.minute !== "0" ? minuteHourClause(schedule) : "\u6BCF\u5C0F\u65F6";
     return "\u5728" + hourWord(range.from) + "\u81F3" + hourWord(range.to) + "\u4E4B\u95F4\uFF0C" + past;
   }
   if (range.minuteForm === "range") {
-    return "\u5728" + hourWord(range.from) + "\u81F3" + hourWord(range.to) + "\u4E4B\u95F4\uFF0C\u6BCF\u5C0F\u65F6" + valueList(segmentsOf(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+    return "\u5728" + hourWord(range.from) + "\u81F3" + hourWord(range.to) + "\u4E4B\u95F4\uFF0C\u6BCF\u5C0F\u65F6" + valueList(segmentsOf(schedule, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
   }
   return "\u5728" + hourWord(range.from) + "\u81F3" + range.to + "\u70B9" + range.last + "\u5206\u4E4B\u95F4\uFF0C\u6BCF\u5206\u949F";
 }
-function renderHourStep(ir) {
-  const segment = stepSegment(ir, "hour");
+function renderHourStep(schedule) {
+  const segment = stepSegment(schedule, "hour");
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
-  return hourCadencePhrase(ir);
+  return hourCadencePhrase(schedule);
 }
-function hourStride(ir) {
-  const segments = segmentsOf(ir, "hour");
+function hourStride(schedule) {
+  const segments = segmentsOf(schedule, "hour");
   if (segments.length === 1 && segments[0].kind === "step") {
     const { fires, interval } = segments[0];
     return { interval, start: fires[0], last: fires[fires.length - 1] };
   }
   const values = singleValues(segments);
-  return values && arithmeticStep(values);
+  return values && hourListStride(values);
 }
-function hourCadencePhrase(ir) {
-  const stride = hourStride(ir);
-  return stride && renderStride({
+function hourCadencePhrase(schedule) {
+  const stride = hourStride(schedule);
+  return stride && renderStride2({
     ...stride,
     cycle: 24,
     unit: UNITS.hour,
@@ -404,76 +445,90 @@ function hourCadencePhrase(ir) {
     anchor: ""
   });
 }
-function minuteZeroConfinement(ir, stride, prefix) {
+function unevenHourCadence(schedule) {
+  const stride = hourStride(schedule);
+  if (!stride) {
+    return null;
+  }
+  if (schedule.shapes.hour !== "step" && offsetCleanStride(stride)) {
+    return null;
+  }
+  return hourCadencePhrase(schedule);
+}
+function shortCleanHourStride(stride) {
+  const fires = (stride.last - stride.start) / stride.interval + 1;
+  return fires <= maxClockTimes && offsetCleanStride(stride);
+}
+function minuteZeroConfinement(schedule, stride, prefix) {
   if (stride.interval === 2 && stride.start === 0) {
-    return "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(ir);
+    return "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(schedule);
   }
   if (prefix.indexOf("\u4ECE") !== -1) {
-    return prefix + "0\u5206" + secondTail(ir);
+    return prefix + "0\u5206" + secondTail(schedule);
   }
   return null;
 }
-function hourCadence(ir) {
-  const stride = hourStride(ir);
+function hourCadence(schedule) {
+  const stride = hourStride(schedule);
   if (!stride) {
     return null;
   }
-  const fires = (stride.last - stride.start) / stride.interval + 1;
-  if (ir.pattern.second === "0" && fires <= maxClockTimes) {
+  if (schedule.pattern.second === "0" && shortCleanHourStride(stride)) {
     return null;
   }
-  const prefix = hourCadencePhrase(ir);
+  const prefix = hourCadencePhrase(schedule);
   if (prefix.indexOf("\u81F3") !== -1) {
     return null;
   }
-  const minute = +ir.pattern.minute;
-  const subMinute = ir.pattern.second === "*" || ir.shapes.second === "step";
+  const minute = +schedule.pattern.minute;
+  const subMinute = schedule.pattern.second === "*" || schedule.shapes.second === "step";
   if (minute === 0 && subMinute) {
-    return minuteZeroConfinement(ir, stride, prefix);
+    return minuteZeroConfinement(schedule, stride, prefix);
   }
   if (minute === 0) {
-    return prefix + "0\u5206" + secondTail(ir);
+    return prefix + "0\u5206" + secondTail(schedule);
   }
-  return ir.pattern.second === "0" ? prefix + minute + "\u5206" : prefix + minute + "\u5206" + secondTail(ir);
+  return schedule.pattern.second === "0" ? prefix + minute + "\u5206" : prefix + minute + "\u5206" + secondTail(schedule);
 }
-function hourCadenceText(ir) {
-  if (ir.shapes.minute !== "single") {
+function hourCadenceText(schedule) {
+  if (schedule.shapes.minute !== "single") {
     return null;
   }
-  if (+ir.pattern.minute === 0 && ir.pattern.second === "0") {
-    return hourCadencePhrase(ir);
+  if (+schedule.pattern.minute === 0 && schedule.pattern.second === "0") {
+    const stride = hourStride(schedule);
+    return stride && !shortCleanHourStride(stride) ? hourCadencePhrase(schedule) : null;
   }
-  return hourCadence(ir);
+  return hourCadence(schedule);
 }
-function secondTail(ir) {
-  const sec = secondClause(ir);
+function secondTail(schedule) {
+  const sec = secondClause(schedule);
   return sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
 }
-function renderRangeOfMinutes(ir) {
-  return minuteHourClause(ir) + "\uFF0C\u6BCF\u5206\u949F";
+function renderRangeOfMinutes(schedule) {
+  return minuteHourClause(schedule) + "\uFF0C\u6BCF\u5206\u949F";
 }
-function renderStandaloneSeconds(ir) {
-  const segs = segmentsOf(ir, "second");
+function renderStandaloneSeconds(schedule) {
+  const segs = segmentsOf(schedule, "second");
   const first = segs[0];
   if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
     return cadence(first.interval, UNITS.second);
   }
   return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u6BCF\u5206\u949F\u7B2C" + valueText(segs) + "\u79D2";
 }
-function renderSecondPastMinute(ir) {
-  return "\u6BCF\u5206\u949F\u7B2C" + valueText(segmentsOf(ir, "second")) + "\u79D2";
+function renderSecondPastMinute(schedule) {
+  return "\u6BCF\u5206\u949F\u7B2C" + valueText(segmentsOf(schedule, "second")) + "\u79D2";
 }
-function renderSecondsWithinMinute(ir) {
-  const base = "\u6BCF\u5C0F\u65F6" + ir.pattern.minute + "\u5206";
-  const segs = segmentsOf(ir, "second");
+function renderSecondsWithinMinute(schedule) {
+  const base = "\u6BCF\u5C0F\u65F6" + schedule.pattern.minute + "\u5206";
+  const segs = segmentsOf(schedule, "second");
   const first = segs[0];
   if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
     return base + "\uFF0C" + cadence(first.interval, UNITS.second);
   }
   return base + "\u7B2C" + valueText(segs) + "\u79D2";
 }
-function secondClause(ir) {
-  const segs = segmentsOf(ir, "second");
+function secondClause(schedule) {
+  const segs = segmentsOf(schedule, "second");
   if (!segs.length) {
     return "\u6BCF\u79D2";
   }
@@ -483,34 +538,34 @@ function secondClause(ir) {
   }
   return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u7B2C" + valueText(segs) + "\u79D2";
 }
-function minuteClause(ir) {
-  if (ir.pattern.minute === "*") {
+function minuteClause(schedule) {
+  if (schedule.pattern.minute === "*") {
     return "\u6BCF\u5206\u949F";
   }
-  if (ir.shapes.minute === "step") {
-    return cadence(stepSegment(ir, "minute").interval, UNITS.minute);
+  if (schedule.shapes.minute === "step") {
+    return cadence(stepSegment(schedule, "minute").interval, UNITS.minute);
   }
-  return valueList(segmentsOf(ir, "minute"), "\u5206");
+  return valueList(segmentsOf(schedule, "minute"), "\u5206");
 }
 function clockRestCarriesSecond(rest) {
   return rest.kind === "clockTimes" && rest.times.some((time) => Boolean(time.second));
 }
-function composeSecondsOnHour(ir, plan, opts) {
-  const sec = secondClause(ir);
+function composeSecondsOnHour(schedule, plan, opts) {
+  const sec = secondClause(schedule);
   const { rest } = plan;
   const composedClock = rest.kind === "clockTimes" || rest.kind === "compactClockTimes";
   if (composedClock) {
-    const hourCad = hourCadence(ir);
+    const hourCad = hourCadence(schedule);
     if (hourCad !== null) {
       return hourCad;
     }
   }
-  if (composedClock && ir.pattern.minute === "0") {
-    return composeMinuteZeroClocks(ir, sec);
+  if (composedClock && schedule.pattern.minute === "0") {
+    return composeMinuteZeroClocks(schedule, sec);
   }
-  const restText = render(ir, rest, opts);
+  const restText = render(schedule, rest, opts);
   const secTail = clockRestCarriesSecond(rest) ? "" : sec;
-  if (composedClock && isDaily(ir)) {
+  if (composedClock && isDaily(schedule)) {
     return "\u6BCF\u5929" + restText + secTail;
   }
   if (rest.kind === "singleMinute") {
@@ -518,79 +573,79 @@ function composeSecondsOnHour(ir, plan, opts) {
   }
   return restText + secTail;
 }
-function composeMinuteZeroClocks(ir, sec) {
-  if (hasHourWindow(ir)) {
-    return isDaily(ir) ? "\u6BCF\u5929" + hourRangeWindow(ir, sec) : hourRangeWindow(ir, sec);
+function composeMinuteZeroClocks(schedule, sec) {
+  if (hasHourWindow(schedule)) {
+    return isDaily(schedule) ? "\u6BCF\u5929" + hourRangeWindow(schedule, sec) : hourRangeWindow(schedule, sec);
   }
-  const clocks = hourFires(ir).map(function clock(hour) {
+  const clocks = hourFires(schedule).map(function clock(hour) {
     return hour === 12 ? "\u6B63\u5348" : hourWord(hour) + "0\u5206";
   });
-  const nested = strideFromSegments(segmentsOf(ir, "second"), "\u79D2", "\u79D2", "");
+  const nested = strideFromSegments(segmentsOf(schedule, "second"), "\u79D2", "\u79D2", "");
   const tail = sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + (nested ?? sec);
   const core = joinAnd(clocks) + tail;
-  return isDaily(ir) ? "\u6BCF\u5929" + core : core;
+  return isDaily(schedule) ? "\u6BCF\u5929" + core : core;
 }
-function hasHourWindow(ir) {
-  return segmentsOf(ir, "hour").some(function range(segment) {
+function hasHourWindow(schedule) {
+  return segmentsOf(schedule, "hour").some(function range(segment) {
     return segment.kind === "range";
   });
 }
-function hourRangeWindow(ir, sec) {
-  const span = hourList(ir);
-  if (ir.pattern.second === "*" || ir.shapes.second === "step") {
+function hourRangeWindow(schedule, sec) {
+  const span = hourList(schedule);
+  if (schedule.pattern.second === "*" || schedule.shapes.second === "step") {
     return span + "0\u5206" + (sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec);
   }
   return span + "\uFF0C" + sec;
 }
-function composeSecondsCadence(ir) {
-  const sec = secondClause(ir);
-  const tail = minuteClause(ir) + sec;
-  const hourCad = hourCadencePhrase(ir);
+function composeSecondsCadence(schedule) {
+  const sec = secondClause(schedule);
+  const tail = minuteClause(schedule) + sec;
+  const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
     return hourCad + (hourCad.indexOf("\u81F3") === -1 ? "\u7684" : "\uFF0C") + tail;
   }
-  if (ir.shapes.hour === "single") {
-    return hourWord(hourFires(ir)[0]) + "\u7684" + tail;
+  if (schedule.shapes.hour === "single") {
+    return hourWord(hourFires(schedule)[0]) + "\u7684" + tail;
   }
-  if (ir.shapes.hour === "wildcard") {
-    if (ir.shapes.minute === "step" && sec === "\u6BCF\u79D2") {
-      const minuteStep = stepSegment(ir, "minute");
+  if (schedule.shapes.hour === "wildcard") {
+    if (schedule.shapes.minute === "step" && sec === "\u6BCF\u79D2") {
+      const minuteStep = stepSegment(schedule, "minute");
       if (minuteStep.startToken === "*" && minuteStep.interval === 2) {
         return "\u6BCF\u5076\u6570\u5206\u949F\u7684\u6BCF\u4E00\u79D2";
       }
     }
-    return sec + "\uFF0C" + minuteClause(ir);
+    return sec + "\uFF0C" + minuteClause(schedule);
   }
-  return hourFrame(ir) + tail;
+  return hourFrame(schedule) + tail;
 }
-function composeSecondsListed(ir) {
-  const sec = secondClause(ir);
-  const minutes = minuteHourClause(ir);
-  if (ir.shapes.hour === "single" && sec === "\u6BCF\u79D2") {
-    const minuteSegs = segmentsOf(ir, "minute");
+function composeSecondsListed(schedule) {
+  const sec = secondClause(schedule);
+  const minutes = minuteHourClause(schedule);
+  if (schedule.shapes.hour === "single" && sec === "\u6BCF\u79D2") {
+    const minuteSegs = segmentsOf(schedule, "minute");
     const minuteCad = strideFromSegments(minuteSegs, "\u5206\u949F", "\u5206", "") ?? valueList(minuteSegs, "\u5206");
-    return hourWord(hourFires(ir)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
+    return hourWord(hourFires(schedule)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
-  if (ir.shapes.hour === "wildcard") {
+  if (schedule.shapes.hour === "wildcard") {
     return minutes + "\uFF0C" + sec;
   }
-  const hourCad = hourCadencePhrase(ir);
+  const hourCad = unevenHourCadence(schedule);
   if (hourCad !== null) {
     return hourCad + "\uFF0C" + minutes + "\uFF0C" + sec;
   }
-  return hourFrame(ir) + minutes + "\uFF0C" + sec;
+  return hourFrame(schedule) + minutes + "\uFF0C" + sec;
 }
-function renderComposeSeconds(ir, plan, opts) {
+function renderComposeSeconds(schedule, plan, opts) {
   const { rest } = plan;
   const composedClock = rest.kind === "clockTimes" || rest.kind === "compactClockTimes";
-  if (ir.pattern.minute === "0" || composedClock && ir.shapes.minute === "single") {
-    return composeSecondsOnHour(ir, plan, opts);
+  if (schedule.pattern.minute === "0" || composedClock && schedule.shapes.minute === "single") {
+    return composeSecondsOnHour(schedule, plan, opts);
   }
-  const minuteCadence = ir.pattern.minute === "*" || ir.shapes.minute === "step" && stepSegment(ir, "minute").startToken === "*";
+  const minuteCadence = schedule.pattern.minute === "*" || schedule.shapes.minute === "step" && stepSegment(schedule, "minute").startToken === "*";
   if (minuteCadence) {
-    return composeSecondsCadence(ir);
+    return composeSecondsCadence(schedule);
   }
-  return composeSecondsListed(ir);
+  return composeSecondsListed(schedule);
 }
 var renderers = {
   clockTimes: renderClockTimes,
@@ -612,20 +667,27 @@ var renderers = {
   singleMinute: renderMinutePast,
   standaloneSeconds: renderStandaloneSeconds
 };
-function render(ir, plan, opts) {
+function render(schedule, plan, opts) {
   return renderers[plan.kind](
-    ir,
+    schedule,
     plan,
     opts
   );
 }
-function monthPhrase(ir) {
-  if (ir.pattern.month === "*") {
+function boundedParityMonth(schedule) {
+  if (schedule.shapes.month !== "step" || isOpenStep(schedule.pattern.month)) {
+    return false;
+  }
+  const segs = segmentsOf(schedule, "month");
+  return segs.length === 1 && segs[0].kind === "step" && segs[0].interval === 2;
+}
+function monthPhrase(schedule) {
+  if (schedule.pattern.month === "*") {
     return "";
   }
-  const segs = segmentsOf(ir, "month");
+  const segs = segmentsOf(schedule, "month");
   const first = segs[0];
-  if (segs.length === 1 && first.kind === "step" && first.interval === 2) {
+  if (segs.length === 1 && first.kind === "step" && first.interval === 2 && isOpenStep(schedule.pattern.month)) {
     return "\u6BCF\u4E2A" + (first.fires[0] % 2 ? "\u5947" : "\u5076") + "\u6570\u6708";
   }
   if (segs.length === 1 && first.kind === "range") {
@@ -641,16 +703,16 @@ function monthPhrase(ir) {
   });
   return nums.join("\u3001") + "\u6708";
 }
-function dayList(ir) {
-  const segs = segmentsOf(ir, "date");
-  if (segs.every((seg) => seg.kind === "single")) {
-    return segs.map((seg) => seg.value).join("\u3001") + "\u65E5";
+function dayList(schedule) {
+  const segs = segmentsOf(schedule, "date");
+  if (segs.every((seg) => seg.kind === "single" || seg.kind === "step")) {
+    return fireValues(segs).join("\u3001") + "\u65E5";
   }
   return segs.map(function day(seg) {
     if (seg.kind === "range") {
       return seg.bounds[0] + "\u65E5\u81F3" + seg.bounds[1] + "\u65E5";
     }
-    return seg.value + "\u65E5";
+    return seg.kind === "step" ? seg.fires.join("\u3001") + "\u65E5" : seg.value + "\u65E5";
   }).join("\u3001");
 }
 function quartzDate(token, monthPrefix) {
@@ -665,32 +727,46 @@ function quartzDate(token, monthPrefix) {
   }
   return monthPrefix + "\u6700\u63A5\u8FD1" + token.slice(0, -1) + "\u65E5\u7684\u5DE5\u4F5C\u65E5";
 }
-function datePhrase(ir) {
-  const month = monthPhrase(ir);
-  const date = ir.pattern.date;
+function oddEvenDay(dateField, monthLead) {
+  if (!isOpenStep(dateField)) {
+    return null;
+  }
+  const [start, step] = dateField.split("/");
+  if (+step !== 2) {
+    return null;
+  }
+  const lead = monthLead ? "\u6BCF\u6708" : "";
+  if (start === "*" || start === "1") {
+    return lead + "\u5355\u6570\u65E5";
+  }
+  return start === "2" ? lead + "\u53CC\u6570\u65E5" : null;
+}
+function datePhrase(schedule) {
+  const month = monthPhrase(schedule);
+  const date = schedule.pattern.date;
   if (date === "*" || date === "?") {
     return month;
   }
-  if (ir.shapes.date === "quartz") {
+  if (schedule.shapes.date === "quartz") {
     return quartzDate(date, month || "\u672C\u6708");
   }
-  if (ir.shapes.date === "step") {
-    return month + cadence(stepSegment(ir, "date").interval, "\u5929");
+  if (schedule.shapes.date === "step" && isOpenStep(date)) {
+    return month + cadence(stepSegment(schedule, "date").interval, "\u5929");
   }
   if (!month) {
-    return "\u6BCF\u6708" + dayList(ir);
+    return "\u6BCF\u6708" + dayList(schedule);
   }
-  const monthMulti = ir.shapes.month === "range" || ir.shapes.month === "list";
-  return month + (monthMulti ? "\uFF0C" : "") + dayList(ir);
+  const monthMulti = schedule.shapes.month === "range" || schedule.shapes.month === "list" || boundedParityMonth(schedule);
+  return month + (monthMulti ? "\uFF0C" : "") + dayList(schedule);
 }
-function dateCore(ir, quartzPrefix) {
-  if (ir.shapes.date === "quartz") {
-    return quartzDate(ir.pattern.date, quartzPrefix);
+function dateCore(schedule, quartzPrefix) {
+  if (schedule.shapes.date === "quartz") {
+    return quartzDate(schedule.pattern.date, quartzPrefix);
   }
-  if (ir.shapes.date === "step") {
-    return cadence(stepSegment(ir, "date").interval, "\u5929");
+  if (schedule.shapes.date === "step" && isOpenStep(schedule.pattern.date)) {
+    return cadence(stepSegment(schedule, "date").interval, "\u5929");
   }
-  return dayList(ir);
+  return dayList(schedule);
 }
 function weekdayName(token) {
   const number = toFieldNumber(token, weekdayNumbers);
@@ -713,11 +789,11 @@ function quartzWeekday(token, monthPrefix) {
   const [day, nth] = token.split("#");
   return "\u7B2C" + nth + "\u4E2A" + weekdayName(day);
 }
-function weekdayPhrase(ir, orContext, monthPrefix) {
-  if (ir.shapes.weekday === "quartz") {
-    return quartzWeekday(ir.pattern.weekday, monthPrefix);
+function weekdayPhrase(schedule, orContext, monthPrefix) {
+  if (schedule.shapes.weekday === "quartz") {
+    return quartzWeekday(schedule.pattern.weekday, monthPrefix);
   }
-  const segs = segmentsOf(ir, "weekday");
+  const segs = segmentsOf(schedule, "weekday");
   if (segs.length === 1 && segs[0].kind === "range") {
     const [from, to] = segs[0].bounds;
     return "\u6BCF" + weekdayName(from) + "\u81F3" + weekdayName(to);
@@ -734,84 +810,88 @@ function weekdayPhrase(ir, orContext, monthPrefix) {
 function isSet(token) {
   return token !== "*" && token !== "?";
 }
-function qualifier(ir) {
-  const dateSet = isSet(ir.pattern.date);
-  const weekdaySet = isSet(ir.pattern.weekday);
+function qualifier(schedule) {
+  const dateSet = isSet(schedule.pattern.date);
+  const weekdaySet = isSet(schedule.pattern.weekday);
   if (dateSet && weekdaySet) {
-    const month = monthPhrase(ir);
+    const month = monthPhrase(schedule);
     if (month) {
-      return month + "\uFF0C" + dateCore(ir, "") + "\u6216" + weekdayPhrase(ir, true, "");
+      const date2 = oddEvenDay(schedule.pattern.date, false) || dateCore(schedule, "");
+      return month + "\uFF0C" + date2 + "\u6216" + weekdayPhrase(schedule, true, "");
     }
-    return datePhrase(ir) + "\u6216" + weekdayPhrase(ir, true, "\u672C\u6708");
+    const date = oddEvenDay(schedule.pattern.date, true) || datePhrase(schedule);
+    return date + "\u6216" + weekdayPhrase(schedule, true, "\u672C\u6708");
   }
   if (dateSet) {
-    return datePhrase(ir);
+    return datePhrase(schedule);
   }
   if (weekdaySet) {
-    const month = monthPhrase(ir);
-    if (ir.shapes.weekday === "quartz") {
-      return quartzWeekday(ir.pattern.weekday, month || "\u672C\u6708");
+    const month = monthPhrase(schedule);
+    if (schedule.shapes.weekday === "quartz") {
+      return quartzWeekday(schedule.pattern.weekday, month || "\u672C\u6708");
     }
-    return month + weekdayPhrase(ir, false, "\u672C\u6708");
+    return month + weekdayPhrase(schedule, false, "\u672C\u6708");
   }
-  return monthPhrase(ir);
+  return monthPhrase(schedule);
 }
-function isDaily(ir) {
-  return !isSet(ir.pattern.date) && !isSet(ir.pattern.weekday);
+function isDaily(schedule) {
+  return !isSet(schedule.pattern.date) && !isSet(schedule.pattern.weekday);
 }
-function composePoint(ir, core) {
-  const qual = qualifier(ir);
-  if (isDaily(ir)) {
+function composePoint(schedule, core) {
+  const qual = qualifier(schedule);
+  if (isDaily(schedule)) {
     return qual + "\u6BCF\u5929" + core;
   }
-  const dateSet = isSet(ir.pattern.date);
-  const weekdaySet = isSet(ir.pattern.weekday);
-  const comma = dateSet && weekdaySet || ir.shapes.date === "step";
+  const dateSet = isSet(schedule.pattern.date);
+  const weekdaySet = isSet(schedule.pattern.weekday);
+  const dateCadence = schedule.shapes.date === "step" && isOpenStep(schedule.pattern.date);
+  const comma = dateSet && weekdaySet || dateCadence;
   return qual + (comma ? "\uFF0C" : "") + core;
 }
-function composeCadence(ir, core) {
-  const qual = qualifier(ir);
+function composeCadence(schedule, core) {
+  const qual = qualifier(schedule);
   if (!qual) {
     return core;
   }
-  if (ir.plan.kind === "minuteFrequency") {
-    const lead = ir.plan.hours.kind !== "none";
+  if (schedule.plan.kind === "minuteFrequency") {
+    const lead = schedule.plan.hours.kind !== "none";
     return lead ? qual + "\uFF0C" + core : core + "\uFF0C" + qual;
   }
-  if (ir.plan.kind === "compactClockTimes") {
+  if (schedule.plan.kind === "compactClockTimes") {
     return qual + "\uFF0C" + core;
   }
-  const dateSet = isSet(ir.pattern.date);
-  const weekdaySet = isSet(ir.pattern.weekday);
-  const trail = dateSet && (ir.shapes.date !== "step" || weekdaySet);
+  const dateSet = isSet(schedule.pattern.date);
+  const weekdaySet = isSet(schedule.pattern.weekday);
+  const trail = dateSet && (schedule.shapes.date !== "step" || weekdaySet);
   return trail ? core + "\uFF0C" + qual : qual + "\uFF0C" + core;
 }
-function composeWindow(ir, core) {
-  return qualifier(ir) + core;
+function composeWindow(schedule, core) {
+  const union = isSet(schedule.pattern.date) && isSet(schedule.pattern.weekday);
+  return qualifier(schedule) + (union ? "\uFF0C" : "") + core;
 }
-function hourCadenceApplies(ir) {
-  return hourCadenceText(ir) !== null;
+function hourCadenceApplies(schedule) {
+  return hourCadenceText(schedule) !== null;
 }
-function describe(ir, opts) {
-  const { kind } = ir.plan;
-  const core = render(ir, ir.plan, opts);
+function describe(schedule, opts) {
+  const { kind } = schedule.plan;
+  const core = render(schedule, schedule.plan, opts);
   let composed = core;
-  if (hourCadenceApplies(ir)) {
-    composed = composeCadence(ir, core);
-  } else if (kind === "clockTimes" || kind === "compactClockTimes" && ir.pattern.minute === "0") {
-    composed = composePoint(ir, core);
+  if (hourCadenceApplies(schedule)) {
+    composed = composeCadence(schedule, core);
+  } else if (kind === "clockTimes" || kind === "compactClockTimes" && schedule.pattern.minute === "0") {
+    composed = composePoint(schedule, core);
   } else if (kind === "hourStep" || kind === "minuteFrequency" || kind === "minuteSpanAcrossHourStep" || kind === "compactClockTimes") {
-    composed = composeCadence(ir, core);
+    composed = composeCadence(schedule, core);
   } else if (kind === "hourRange") {
-    composed = composeWindow(ir, core);
+    composed = composeWindow(schedule, core);
   } else {
-    const qual = qualifier(ir);
-    composed = qual ? composeCadence(ir, core) : core;
+    const qual = qualifier(schedule);
+    composed = qual ? composeCadence(schedule, core) : core;
   }
-  if (ir.pattern.year === "*") {
+  if (schedule.pattern.year === "*") {
     return composed;
   }
-  const year = segmentsOf(ir, "year").map(function part(seg) {
+  const year = segmentsOf(schedule, "year").map(function part(seg) {
     if (seg.kind === "range") {
       return seg.bounds[0] + "\u5E74\u81F3" + seg.bounds[1] + "\u5E74";
     }