cronli5 0.1.4 → 0.1.5

package/dist/lang/fi.js

@@ -24,12 +24,28 @@ var weekdayNumbers = {
   FRI: 5,
   SAT: 6
 };
+var maxClockTimes = 6;
 
 // src/core/util.ts
 function isNonNegativeInteger(value) {
   const digits = /^\d+$/;
   return digits.test(value);
 }
+function arithmeticStep(values) {
+  if (values.length < 5) {
+    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;
+    }
+  }
+  return { start: values[0], interval, last: values[values.length - 1] };
+}
 function toFieldNumber(token, numberMap) {
   return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
 }
@@ -165,12 +181,14 @@ var units = {
     mark: "joka tunti",
     anchor: "jokaisen tunnin",
     ela: "minuutista",
+    ill: "minuuttiin",
     gen: "minuutin"
   },
   second: {
     mark: "joka minuutti",
     anchor: "jokaisen minuutin",
     ela: "sekunnista",
+    ill: "sekuntiin",
     gen: "sekunnin"
   }
 };
@@ -226,29 +244,50 @@ function renderSecondsWithinMinute(ir, plan, opts) {
   }
   return secondsLeadClause(ir, opts) + ", " + atMarks(minuteField, units.minute, true) + trailingQualifier(ir, opts);
 }
+function composeSecondsOverMinuteStep(ir, freq, opts) {
+  const seg = stepSegment(ir.analyses.segments.minute);
+  const stepPhrase = stepCycle60(seg, units.minute, opts);
+  if (freq.hours.kind === "during" && minuteStepIsAnchored(seg)) {
+    const bareHours = kloFromTimes(ir, freq.hours.times, opts);
+    return hoursFirstMinutes(bareHours, ir, opts) + ", " + secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+  }
+  let hourClause = "";
+  if (freq.hours.kind === "during") {
+    hourClause = " " + hourWindowsFromTimes(ir, freq.hours.times, opts);
+  } else if (freq.hours.kind === "window") {
+    hourClause = " " + hourWindow(freq.hours, opts);
+  } else if (freq.hours.kind === "step") {
+    hourClause = " " + everyNthHour(stepSegment(ir.analyses.segments.hour), opts);
+  }
+  return stepPhrase + ", " + secondsLeadClause(ir, opts) + hourClause + trailingQualifier(ir, opts);
+}
+function composeHourCadence(ir, plan, opts) {
+  const clockRest = plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes";
+  return clockRest && ir.shapes.minute === "single" ? hourCadence(ir, +ir.pattern.minute, opts) : null;
+}
 function renderComposeSeconds(ir, plan, opts) {
+  const cadence = composeHourCadence(ir, plan, opts);
+  if (cadence !== null) {
+    return cadence;
+  }
   if (plan.rest.kind === "minuteFrequency" && ir.pattern.second !== "*") {
-    const freq = plan.rest;
-    const seg = stepSegment(ir.analyses.segments.minute);
-    const stepPhrase = stepCycle60(seg, units.minute, opts);
-    let hourClause = "";
-    if (freq.hours.kind === "during" && minuteStepIsAnchored(seg)) {
-      const bareHours = kloFromTimes(ir, freq.hours.times, opts);
-      return hoursFirstMinutes(bareHours, ir) + ", " + secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
-    } else if (freq.hours.kind === "during" && !minuteStepIsAnchored(seg)) {
-      hourClause = " " + hourWindowsFromTimes(ir, freq.hours.times, opts);
-    } else if (freq.hours.kind === "window") {
-      hourClause = " " + hourWindow(freq.hours, opts);
-    } else if (freq.hours.kind === "step") {
-      hourClause = " " + everyNthHour(stepSegment(ir.analyses.segments.hour), opts);
-    }
-    return stepPhrase + ", " + secondsLeadClause(ir, opts) + hourClause + trailingQualifier(ir, opts);
+    return composeSecondsOverMinuteStep(ir, plan.rest, opts);
   }
   if (plan.rest.kind === "clockTimes" && plan.rest.times.every((time) => +time.minute === 0)) {
     return composeMinuteZero(ir, plan.rest, opts);
   }
+  if (isEveryOtherMinuteSeconds(ir, plan)) {
+    return secondsLeadClause(ir, opts) + " joka toisena minuuttina";
+  }
   return secondsLeadClause(ir, opts) + ", " + render(ir, plan.rest, opts);
 }
+function isEveryOtherMinuteSeconds(ir, plan) {
+  if (plan.rest.kind !== "minuteFrequency" || ir.pattern.second !== "*" || ir.shapes.hour !== "wildcard") {
+    return false;
+  }
+  const seg = stepSegment(ir.analyses.segments.minute);
+  return seg.startToken === "*" && seg.interval === 2;
+}
 function composeMinuteZero(ir, rest, opts) {
   const clocks = rest.times.map(function clock(time) {
     return clockDigits(
@@ -277,7 +316,7 @@ function secondsLeadClause(ir, opts) {
   if (shape === "single") {
     return atMarks(secondField, units.second, marked);
   }
-  return atMarks(
+  return strideFromSegments(ir.analyses.segments.second, units.second, opts) ?? atMarks(
     joinList(segmentWords(ir.analyses.segments.second)),
     units.second,
     marked
@@ -290,20 +329,20 @@ function renderSingleMinute(ir, plan, opts) {
   return atMarks(ir.pattern.minute, units.minute, true) + trailingQualifier(ir, opts);
 }
 function renderRangeOfMinutes(ir, plan, opts) {
-  return minutesList(ir) + trailingQualifier(ir, opts);
+  return minutesList(ir, opts) + trailingQualifier(ir, opts);
 }
 function renderMultipleMinutes(ir, plan, opts) {
-  return minutesList(ir) + trailingQualifier(ir, opts);
+  return minutesList(ir, opts) + trailingQualifier(ir, opts);
 }
-function minutesList(ir) {
-  return atMarks(
+function minutesList(ir, opts) {
+  return strideFromSegments(ir.analyses.segments.minute, units.minute, opts) ?? atMarks(
     joinList(segmentWords(ir.analyses.segments.minute)),
     units.minute,
     true
   );
 }
-function bareMinutes(ir) {
-  return atMarks(
+function bareMinutes(ir, opts) {
+  return strideFromSegments(ir.analyses.segments.minute, units.minute, opts) ?? atMarks(
     joinList(segmentWords(ir.analyses.segments.minute)),
     units.minute,
     false
@@ -334,7 +373,11 @@ function hoursAreRangeIsolated(segments) {
   }
   return hasRange && hasSingle;
 }
-function hoursFirstMinutes(hoursStr, ir) {
+function hoursFirstMinutes(hoursStr, ir, opts) {
+  const stride = strideFromSegments(ir.analyses.segments.minute, units.minute, opts);
+  if (stride) {
+    return hoursStr + " aina " + stride;
+  }
   return hoursStr + " aina minuuttien " + joinList(segmentWords(ir.analyses.segments.minute)) + " kohdalla";
 }
 function hourSegmentTimesWithSeka(ir, minute, second, opts) {
@@ -357,7 +400,7 @@ function renderMinuteFrequency(ir, plan, opts) {
   if (plan.hours.kind === "during") {
     if (minuteStepIsAnchored(seg)) {
       const bareHours = kloFromTimes(ir, plan.hours.times, opts);
-      return hoursFirstMinutes(bareHours, ir) + trailingQualifier(ir, opts);
+      return hoursFirstMinutes(bareHours, ir, opts) + trailingQualifier(ir, opts);
     }
     return stepCycle60(seg, units.minute, opts) + " " + hourWindowsFromTimes(ir, plan.hours.times, opts) + trailingQualifier(ir, opts);
   }
@@ -384,10 +427,10 @@ function renderMinutesAcrossHours(ir, plan, opts) {
     return "joka minuutti " + hourWindowsFromTimes(ir, plan.times, opts) + trailingQualifier(ir, opts);
   }
   if (hoursAreRangeIsolated(ir.analyses.segments.hour)) {
-    return bareMinutes(ir) + " " + hourSegmentTimesWithSeka(ir, 0, null, opts) + trailingQualifier(ir, opts);
+    return bareMinutes(ir, opts) + " " + hourSegmentTimesWithSeka(ir, 0, null, opts) + trailingQualifier(ir, opts);
   }
   const hoursStr = kloFromTimes(ir, plan.times, opts);
-  return hoursFirstMinutes(hoursStr, ir) + trailingQualifier(ir, opts);
+  return hoursFirstMinutes(hoursStr, ir, opts) + trailingQualifier(ir, opts);
 }
 function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
   const segment = stepSegment(ir.analyses.segments.hour);
@@ -396,9 +439,9 @@ function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
   }
   if (segment.startToken.indexOf("-") !== -1) {
     const hoursStr = kloList(segment.fires, opts);
-    return hoursFirstMinutes(hoursStr, ir) + trailingQualifier(ir, opts);
+    return hoursFirstMinutes(hoursStr, ir, opts) + trailingQualifier(ir, opts);
   }
-  return bareMinutes(ir) + hourStepTail(segment, opts) + trailingQualifier(ir, opts);
+  return bareMinutes(ir, opts) + hourStepTail(segment, opts) + trailingQualifier(ir, opts);
 }
 function plainHourStep(segment) {
   return segment.startToken === "*" && 24 % segment.interval === 0;
@@ -456,7 +499,7 @@ function renderHourRange(ir, plan, opts) {
     return "joka minuutti " + window + trailingQualifier(ir, opts);
   }
   if (plan.minuteForm === "range") {
-    return hoursFirstMinutes(window, ir) + trailingQualifier(ir, opts);
+    return hoursFirstMinutes(window, ir, opts) + trailingQualifier(ir, opts);
   }
   if (ir.pattern.minute === "0") {
     return "joka tunti " + window + trailingQualifier(ir, opts);
@@ -468,7 +511,7 @@ function renderHourRange(ir, plan, opts) {
       opts
     ) + trailingQualifier(ir, opts);
   }
-  return hoursFirstMinutes(window, ir) + trailingQualifier(ir, opts);
+  return hoursFirstMinutes(window, ir, opts) + trailingQualifier(ir, opts);
 }
 function renderHourStep(ir, plan, opts) {
   return stepHours(stepSegment(ir.analyses.segments.hour), opts) + trailingQualifier(ir, opts);
@@ -484,6 +527,12 @@ function hourWindow(window, opts) {
   );
 }
 function renderClockTimes(ir, plan, opts) {
+  if (ir.shapes.minute === "single") {
+    const cadence = hourCadence(ir, +ir.pattern.minute, opts);
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
   if (plan.times.length === 1) {
     const time = plan.times[0];
     return leadingQualifier(ir, opts) + timeWord(time.hour, time.minute, time.second, opts);
@@ -494,6 +543,12 @@ function renderClockTimes(ir, plan, opts) {
   return leadingQualifier(ir, opts) + "klo " + joinList(digits);
 }
 function renderCompactClockTimes(ir, plan, opts) {
+  if (plan.fold) {
+    const cadence = hourCadence(ir, plan.minute, opts);
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
   const hourSegs = ir.analyses.segments.hour;
   if (hoursAreRangeIsolated(hourSegs)) {
     if (plan.fold) {
@@ -504,14 +559,14 @@ function renderCompactClockTimes(ir, plan, opts) {
         opts
       );
     }
-    const phrase2 = bareMinutes(ir) + " " + hourSegmentTimesWithSeka(ir, 0, null, opts) + trailingQualifier(ir, opts);
+    const phrase2 = bareMinutes(ir, opts) + " " + hourSegmentTimesWithSeka(ir, 0, null, opts) + trailingQualifier(ir, opts);
     return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase2 : phrase2;
   }
   if (plan.fold) {
     return leadingQualifier(ir, opts) + hourSegmentTimes(ir, plan.minute, ir.analyses.clockSecond, opts);
   }
   const hoursStr = hourSegmentTimes(ir, 0, null, opts);
-  const phrase = hoursFirstMinutes(hoursStr, ir) + trailingQualifier(ir, opts);
+  const phrase = hoursFirstMinutes(hoursStr, ir, opts) + trailingQualifier(ir, opts);
   return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase : phrase;
 }
 var renderers = {
@@ -534,20 +589,48 @@ var renderers = {
   singleMinute: renderSingleMinute,
   standaloneSeconds: renderStandaloneSeconds
 };
+function renderStride(stride, opts) {
+  const { interval, start, last, cycle, unit } = stride;
+  const cadence = genitive(interval, opts) + " " + unit.gen + " v\xE4lein";
+  const tiles = cycle % interval === 0;
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+  if (start < interval && tiles) {
+    return cadence + " " + unit.anchor + " " + unit.ela + " " + start + " alkaen";
+  }
+  return cadence + " " + unit.ela + " " + start + " " + unit.ill + " " + last;
+}
+function strideFromSegments(segments, unit, opts) {
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+  return step ? renderStride({ ...step, cycle: 60, unit }, opts) : null;
+}
+function singleValues(segments) {
+  const values = [];
+  for (const segment of segments) {
+    if (segment.kind !== "single") {
+      return null;
+    }
+    values.push(+segment.value);
+  }
+  return values;
+}
 function stepCycle60(segment, unit, opts) {
   if (segment.startToken.indexOf("-") !== -1) {
     return atMarks(joinList(wordList(segment.fires)), unit, true);
   }
   const start = segment.startToken === "*" ? 0 : +segment.startToken;
-  const interval = segment.interval;
-  const cadence = genitive(interval, opts) + " " + unit.gen + " v\xE4lein";
-  if (start !== 0) {
-    if (segment.fires.length <= 3) {
-      return atMarks(joinList(wordList(segment.fires)), unit, true);
-    }
-    return cadence + " " + unit.anchor + " " + unit.ela + " " + start + " alkaen";
+  if (start !== 0 && segment.fires.length <= 3) {
+    return atMarks(joinList(wordList(segment.fires)), unit, true);
   }
-  return cadence;
+  return renderStride({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit
+  }, opts);
 }
 function stepHours(segment, opts) {
   if (segment.startToken.indexOf("-") !== -1) {
@@ -564,6 +647,71 @@ function stepHours(segment, opts) {
   }
   return cadence + " klo " + hourElatives[start] + " alkaen";
 }
+function hourStrideCadence(stride, opts) {
+  const { start, interval, last } = stride;
+  const cadence = genitive(interval, opts) + " tunnin v\xE4lein";
+  const tiles = 24 % interval === 0;
+  if (start === 0 && tiles) {
+    return cadence;
+  }
+  if (start < interval && tiles) {
+    return cadence + " klo " + hourElatives[start] + " alkaen";
+  }
+  return cadence + " " + kloRange({ hour: start, minute: 0 }, { hour: last, minute: 0 }, opts);
+}
+function hourStride(ir) {
+  const segments = ir.analyses.segments.hour;
+  if (!segments) {
+    return null;
+  }
+  if (segments.length === 1 && segments[0].kind === "step") {
+    const segment = segments[0];
+    const start = segment.startToken === "*" ? 0 : +segment.startToken.split("-")[0];
+    return { interval: segment.interval, last: segment.fires[segment.fires.length - 1], start };
+  }
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+  return step || null;
+}
+function subMinuteSecond(ir) {
+  return ir.pattern.second === "*" || ir.shapes.second === "step";
+}
+function hourCadenceLead(ir, minute, opts) {
+  if (minute === 0) {
+    if (subMinuteSecond(ir)) {
+      return secondsLeadClause(ir, opts) + " minuutin ajan";
+    }
+    return secondsLeadClause(ir, opts);
+  }
+  const minutePhrase = atMarks(String(minute), units.minute, false);
+  if (ir.pattern.second === "0") {
+    return minutePhrase;
+  }
+  return secondsLeadClause(ir, opts) + ", " + minutePhrase;
+}
+function hourCadence(ir, minute, opts) {
+  const stride = hourStride(ir);
+  if (!stride) {
+    return null;
+  }
+  const fires = (stride.last - stride.start) / stride.interval + 1;
+  if (ir.pattern.second === "0" && fires <= maxClockTimes) {
+    return null;
+  }
+  const segment = ir.analyses.segments.hour[0];
+  const confined = minute === 0 && subMinuteSecond(ir) && ir.analyses.segments.hour.length === 1 && segment.kind === "step" && cleanHourStride(segment);
+  if (confined) {
+    return secondsLeadClause(ir, opts) + " minuutin ajan " + everyNthHour(segment, opts) + trailingQualifier(ir, opts);
+  }
+  return hourCadenceLead(ir, minute, opts) + ", " + hourStrideCadence(stride, opts) + trailingQualifier(ir, opts);
+}
+function cleanHourStride(segment) {
+  if (segment.startToken.indexOf("-") !== -1) {
+    return false;
+  }
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  return 24 % segment.interval === 0 && start < segment.interval;
+}
 function kloList(hours, opts) {
   if (hours.length === 1) {
     return timeWord(hours[0], 0, null, opts);

package/dist/lang/zh.cjs

@@ -29,6 +29,21 @@ function isNonNegativeInteger(value) {
   const digits = /^\d+$/;
   return digits.test(value);
 }
+function arithmeticStep(values) {
+  if (values.length < 5) {
+    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;
+    }
+  }
+  return { start: values[0], interval, last: values[values.length - 1] };
+}
 function toFieldNumber(token, numberMap) {
   return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
 }
@@ -57,6 +72,7 @@ var monthNumbers = {
   NOV: 11,
   DEC: 12
 };
+var maxClockTimes = 6;
 
 // src/lang/zh/dialects.ts
 var zh = { variant: "Hans" };
@@ -87,6 +103,46 @@ function stepSegment(ir, field) {
 function cadence(interval, unit) {
   return interval === 1 ? "\u6BCF" + unit : "\u6BCF" + interval + unit;
 }
+function renderStride(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;
+}
+function singleValues(segments) {
+  const values = [];
+  for (const segment of segments) {
+    if (segment.kind !== "single") {
+      return null;
+    }
+    values.push(+segment.value);
+  }
+  return values;
+}
+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;
+}
+function stepClause(segment, unit, mark, anchor) {
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  const short = start !== 0 && segment.fires.length <= 3;
+  if (segment.startToken.indexOf("-") !== -1 || short) {
+    return anchor + segment.fires.join("\u3001") + mark;
+  }
+  return renderStride({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit,
+    mark,
+    anchor
+  });
+}
 function dayPeriod(hour) {
   if (hour < 6) {
     return "\u51CC\u6668";
@@ -183,8 +239,15 @@ function renderEveryMinute() {
 function renderEveryHour() {
   return "\u6BCF\u5C0F\u65F6";
 }
+function minuteHourClause(ir) {
+  const segments = fieldSegments(ir, "minute");
+  if (ir.shapes.minute === "step") {
+    return stepClause(stepSegment(ir, "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 "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206");
+  return minuteHourClause(ir);
 }
 function hourList(ir) {
   return joinAnd(hourFires(ir).map(hourWord));
@@ -198,7 +261,7 @@ function hourFrame(ir) {
 }
 function renderMinuteFrequency(ir, plan) {
   const minuteStep = stepSegment(ir, "minute");
-  const base = minuteStep.startToken === "*" ? cadence(minuteStep.interval, UNITS.minute) : renderMinutePast(ir);
+  const base = stepClause(minuteStep, UNITS.minute, "\u5206", "\u6BCF\u5C0F\u65F6");
   const { hours } = plan;
   if (hours.kind === "step") {
     const hourStep = stepSegment(ir, "hour");
@@ -227,12 +290,15 @@ function renderMinutesAcrossHours(ir, plan) {
   if (form === "wildcard") {
     return "\u5728" + hourList(ir) + "\uFF0C\u6BCF\u5206\u949F";
   }
-  return hourList(ir) + "\uFF0C\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  return hourList(ir) + "\uFF0C" + minuteHourClause(ir) + "\uFF0C\u6BCF\u5206\u949F";
 }
 function renderMinuteSpanAcrossHourStep(ir, plan) {
   const hourStep = stepSegment(ir, "hour");
   const { form } = plan;
-  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  if (form === "list") {
+    return renderMinutePast(ir) + "\uFF0C\u5728" + hourList(ir);
+  }
+  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : minuteHourClause(ir) + "\uFF0C\u6BCF\u5206\u949F";
   if (hourStep.startToken !== "*") {
     return form === "wildcard" ? "\u5728" + hourList(ir) + "\uFF0C" + minuteTail : hourList(ir) + "\uFF0C" + minuteTail;
   }
@@ -243,15 +309,27 @@ function renderMinuteSpanAcrossHourStep(ir, plan) {
   return form === "wildcard" ? cad + "\u5185\uFF0C" + minuteTail : cad + "\uFF0C" + minuteTail;
 }
 function renderClockTimes(ir, plan, opts) {
+  if (ir.shapes.minute === "single") {
+    const cad = hourCadence(ir);
+    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) {
+  if (ir.shapes.minute === "single") {
+    const cad = hourCadence(ir);
+    if (cad !== null) {
+      return cad;
+    }
+  }
   const { minute } = plan;
   const secs = fieldSegments(ir, "second");
   const tail = secs.length && ir.pattern.second !== "0" ? "\uFF0C\u7B2C" + valueText(secs) + "\u79D2" : "";
   if (minute > 0) {
-    return "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u5728" + hourList(ir) + tail;
+    return minuteHourClause(ir) + "\uFF0C\u5728" + hourList(ir) + tail;
   }
   return hourList(ir) + tail;
 }
@@ -259,7 +337,7 @@ function renderHourRange(ir, plan) {
   const range = plan;
   if (range.minuteForm === "lead") {
     const minuteSegs = fieldSegments(ir, "minute");
-    const past = minuteSegs.length && ir.pattern.minute !== "0" ? "\u6BCF\u5C0F\u65F6" + valueList(minuteSegs, "\u5206") : "\u6BCF\u5C0F\u65F6";
+    const past = minuteSegs.length && ir.pattern.minute !== "0" ? minuteHourClause(ir) : "\u6BCF\u5C0F\u65F6";
     return "\u5728" + hourWord(range.from) + "\u81F3" + hourWord(range.to) + "\u4E4B\u95F4\uFF0C" + past;
   }
   if (range.minuteForm === "range") {
@@ -277,8 +355,52 @@ function renderHourStep(ir) {
   }
   return cadence(segment.interval, UNITS.hour);
 }
+function hourStride(ir) {
+  const segments = fieldSegments(ir, "hour");
+  if (segments.length === 1 && segments[0].kind === "step") {
+    const segment = segments[0];
+    const start = segment.startToken === "*" ? 0 : +segment.startToken;
+    if (start !== 0 || 24 % segment.interval !== 0) {
+      return null;
+    }
+    return {
+      interval: segment.interval,
+      last: segment.fires[segment.fires.length - 1]
+    };
+  }
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+  if (!step || step.start !== 0 || 24 % step.interval !== 0) {
+    return null;
+  }
+  return { interval: step.interval, last: step.last };
+}
+function hourCadence(ir) {
+  const stride = hourStride(ir);
+  if (!stride) {
+    return null;
+  }
+  const fires = stride.last / stride.interval + 1;
+  if (ir.pattern.second === "0" && fires <= maxClockTimes) {
+    return null;
+  }
+  const prefix = cadence(stride.interval, UNITS.hour);
+  const minute = +ir.pattern.minute;
+  const subMinute = ir.pattern.second === "*" || ir.shapes.second === "step";
+  if (minute === 0 && subMinute) {
+    return stride.interval === 2 ? "\u5728\u5076\u6570\u5C0F\u65F60\u5206" + secondTail(ir) : null;
+  }
+  if (minute === 0) {
+    return prefix + "0\u5206" + secondTail(ir);
+  }
+  return ir.pattern.second === "0" ? prefix + minute + "\u5206" : prefix + minute + "\u5206" + secondTail(ir);
+}
+function secondTail(ir) {
+  const sec = secondClause(ir);
+  return sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
+}
 function renderRangeOfMinutes(ir) {
-  return "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  return minuteHourClause(ir) + "\uFF0C\u6BCF\u5206\u949F";
 }
 function renderStandaloneSeconds(ir) {
   const segs = fieldSegments(ir, "second");
@@ -286,7 +408,7 @@ function renderStandaloneSeconds(ir) {
   if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
     return cadence(first.interval, UNITS.second);
   }
-  return "\u6BCF\u5206\u949F\u7B2C" + valueText(segs) + "\u79D2";
+  return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u6BCF\u5206\u949F\u7B2C" + valueText(segs) + "\u79D2";
 }
 function renderSecondPastMinute(ir) {
   return "\u6BCF\u5206\u949F\u7B2C" + valueText(fieldSegments(ir, "second")) + "\u79D2";
@@ -309,7 +431,7 @@ function secondClause(ir) {
   if (segs.length === 1 && first.kind === "step" && first.startToken === "*") {
     return cadence(first.interval, UNITS.second);
   }
-  return "\u7B2C" + valueText(segs) + "\u79D2";
+  return strideFromSegments(segs, "\u79D2", "\u79D2", "\u6BCF\u5206\u949F") ?? "\u7B2C" + valueText(segs) + "\u79D2";
 }
 function minuteClause(ir) {
   if (ir.pattern.minute === "*") {
@@ -326,13 +448,15 @@ function isHourCadence(ir) {
 function composeSecondsOnHour(ir, plan, opts) {
   const sec = secondClause(ir);
   const { rest } = plan;
-  if ((rest.kind === "clockTimes" || rest.kind === "compactClockTimes") && ir.pattern.minute === "0") {
-    const clocks = hourFires(ir).map(function clock(hour) {
-      return hourWord(hour) + "0\u5206";
-    });
-    const tail = sec === "\u6BCF\u79D2" ? "\u7684\u6BCF\u4E00\u79D2" : "\u7684" + sec;
-    const core = joinAnd(clocks) + tail;
-    return isDaily(ir) ? "\u6BCF\u5929" + core : core;
+  const composedClock = rest.kind === "clockTimes" || rest.kind === "compactClockTimes";
+  if (composedClock) {
+    const hourCad = hourCadence(ir);
+    if (hourCad !== null) {
+      return hourCad;
+    }
+  }
+  if (composedClock && ir.pattern.minute === "0") {
+    return composeMinuteZeroClocks(ir, sec);
   }
   const restText = render(ir, rest, opts);
   if (rest.kind === "clockTimes" || rest.kind === "compactClockTimes") {
@@ -345,6 +469,15 @@ function composeSecondsOnHour(ir, plan, opts) {
   }
   return restText + sec;
 }
+function composeMinuteZeroClocks(ir, sec) {
+  const clocks = hourFires(ir).map(function clock(hour) {
+    return hour === 12 ? "\u6B63\u5348" : hourWord(hour) + "0\u5206";
+  });
+  const nested = strideFromSegments(fieldSegments(ir, "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;
+}
 function composeSecondsCadence(ir) {
   const sec = secondClause(ir);
   const tail = minuteClause(ir) + sec;
@@ -355,15 +488,23 @@ function composeSecondsCadence(ir) {
     return hourWord(hourFires(ir)[0]) + "\u7684" + tail;
   }
   if (ir.shapes.hour === "wildcard") {
+    if (ir.shapes.minute === "step" && sec === "\u6BCF\u79D2") {
+      const minuteStep = stepSegment(ir, "minute");
+      if (minuteStep.startToken === "*" && minuteStep.interval === 2) {
+        return "\u6BCF\u5076\u6570\u5206\u949F\u7684\u6BCF\u4E00\u79D2";
+      }
+    }
     return sec + "\uFF0C" + minuteClause(ir);
   }
   return hourFrame(ir) + tail;
 }
 function composeSecondsListed(ir) {
   const sec = secondClause(ir);
-  const minutes = "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206");
+  const minutes = minuteHourClause(ir);
   if (ir.shapes.hour === "single" && sec === "\u6BCF\u79D2") {
-    return hourWord(hourFires(ir)[0]) + valueList(fieldSegments(ir, "minute"), "\u5206") + "\u7684\u6BCF\u4E00\u79D2";
+    const minuteSegs = fieldSegments(ir, "minute");
+    const minuteCad = strideFromSegments(minuteSegs, "\u5206\u949F", "\u5206", "") ?? valueList(minuteSegs, "\u5206");
+    return hourWord(hourFires(ir)[0]) + minuteCad + "\u7684\u6BCF\u4E00\u79D2";
   }
   if (ir.shapes.hour === "wildcard") {
     return minutes + "\uFF0C" + sec;
@@ -580,11 +721,16 @@ function composeCadence(ir, core) {
 function composeWindow(ir, core) {
   return qualifier(ir) + core;
 }
+function hourCadenceApplies(ir) {
+  return ir.shapes.minute === "single" && hourCadence(ir) !== null;
+}
 function describe(ir, opts) {
   const { kind } = ir.plan;
   const core = render(ir, ir.plan, opts);
   let composed = core;
-  if (kind === "clockTimes" || kind === "compactClockTimes" && ir.pattern.minute === "0") {
+  if (hourCadenceApplies(ir)) {
+    composed = composeCadence(ir, core);
+  } else if (kind === "clockTimes" || kind === "compactClockTimes" && ir.pattern.minute === "0") {
     composed = composePoint(ir, core);
   } else if (kind === "hourStep" || kind === "minuteFrequency" || kind === "minuteSpanAcrossHourStep" || kind === "compactClockTimes") {
     composed = composeCadence(ir, core);