cronli5 0.1.1 → 0.1.4

package/src/lang/en/index.ts

@@ -21,12 +21,15 @@ type StepSegment = Extract<Segment, {kind: 'step'}>;
 
 // A clock-time entry assembled for rendering. Hour/minute/second arrive as
 // numbers or as raw field tokens (a range bound or single value is a
-// string); `plain` suppresses the noon/midnight words.
+// string); `plain` suppresses the noon/midnight words. `explicit` forces the
+// minute to show even when zero ("9:00 a.m.", not "9 a.m.") and suppresses
+// the noon/midnight words, so a pinned minute-0 stays visible.
 interface TimeEntry {
   hour: number | string;
   minute: number | string;
   second?: number | string | null;
   plain?: boolean;
+  explicit?: boolean;
 }
 
 // English number names for the integers zero through ten.
@@ -80,22 +83,6 @@ const weekdayNames: [string, string][] = [
   ['Saturday', 'Sat']
 ];
 
-// Month names by abbreviation.
-const monthAbbreviations: Record<string, [string, string] | null> = {
-  JAN: monthNames[1],
-  FEB: monthNames[2],
-  MAR: monthNames[3],
-  APR: monthNames[4],
-  MAY: monthNames[5],
-  JUN: monthNames[6],
-  JUL: monthNames[7],
-  AUG: monthNames[8],
-  SEP: monthNames[9],
-  OCT: monthNames[10],
-  NOV: monthNames[11],
-  DEC: monthNames[12]
-};
-
 // Weekday name by abbreviation.
 const weekdayAbbreviations: Record<string, [string, string]> = {
   SUN: weekdayNames[0],
@@ -192,9 +179,78 @@ function renderSecondsWithinMinute(ir: IR, plan: PlanOf<'secondsWithinMinute'>,
 // pattern follows.
 function renderComposeSeconds(ir: IR, plan: PlanOf<'composeSeconds'>,
   opts: NormalizedOptions): string {
+  // A wildcard or stepped second under a minute pinned to a single value
+  // across one or more specific hours. The clock-time rest collapses the
+  // pinned minute into the hour, and on the clock a pinned minute-0 reads as
+  // the whole hour ("9 a.m." spoken == "9:00 a.m."), losing the one-minute
+  // confinement. (A second list/range/single leads with a "past the minute"
+  // clause that an "of"/duration frame cannot follow, so it stays generic.)
+  if (plan.rest.kind === 'clockTimes' &&
+      (ir.shapes.second === 'wildcard' || ir.shapes.second === 'step')) {
+    const minute = plan.rest.times[0].minute;
+
+    // Minute 0 is the one-minute window at the top of each named hour: a
+    // duration frame ("for one minute at 9 a.m.") states the confinement
+    // outright, with the hour as its word so it cannot be heard as the hour
+    // itself. A non-zero pinned minute is an unambiguous clock time, so the
+    // compact "of 9:05 a.m." form reads it as the minute, never the hour.
+    if (+minute === 0) {
+      return secondsLeadClause(ir, opts) + ' for one minute at ' +
+        durationHours(ir, plan.rest, opts);
+    }
+
+    return secondsLeadClause(ir, opts) + ' of ' +
+      clockTimesOf(ir, plan.rest, opts);
+  }
+
+  // A wildcard second under a */2 minute step with a wildcard hour binds
+  // idiomatically as "every second of every other minute": "every other" is
+  // the natural English for an interval of 2, and "of" joins the two without
+  // the ambiguity of a comma, which reads as two independent cadences.
+  // Scoped to */2 only; other step sizes keep the comma form.
+  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);
+  }
+
   return secondsLeadClause(ir, opts) + ', ' + render(ir, plan.rest, opts);
 }
 
+// The bare-hour words for a minute-0 duration confinement, joined and followed
+// by the trailing day qualifier: "9 a.m. and 11 a.m., every day", "midnight,
+// 2 a.m., …, every day". The hour reads as its word (noon/midnight included),
+// never "H:00", since the "for one minute" frame already carries the minute.
+function durationHours(ir: IR, plan: PlanOf<'clockTimes'>,
+  opts: NormalizedOptions): string {
+  const hours = plan.times.map(function clock(time) {
+    return getTime({hour: time.hour, minute: 0}, opts);
+  });
+  const trail = dayQualifier(ir, leadingWords, opts);
+
+  return joinList(hours, opts) + (trail && ', ' + trail);
+}
+
+// The clock times for a non-zero pinned-minute compose-seconds rest, joined
+// and followed by the trailing day qualifier: "9:05 a.m. and 11:05 a.m.,
+// every day". The non-zero minute reads as a clock time, never the hour.
+function clockTimesOf(ir: IR, plan: PlanOf<'clockTimes'>,
+  opts: NormalizedOptions): string {
+  const times = plan.times.map(function clock(time) {
+    return getTime({
+      hour: time.hour,
+      minute: time.minute,
+      second: time.second,
+      explicit: true
+    }, opts);
+  });
+  const trail = dayQualifier(ir, leadingWords, opts);
+
+  return joinList(times, opts) + (trail && ', ' + trail);
+}
+
 // The leading clause describing a second field relative to the minute,
 // e.g. "at 5 and 10 seconds past the minute" or "every second from zero
 // through 30 past the minute".
@@ -289,9 +345,18 @@ function renderMinuteFrequency(ir: IR, plan: PlanOf<'minuteFrequency'>,
 }
 
 // A minute wildcard or plain range under a single specific hour fires
-// every minute within a window inside that hour.
+// every minute within a window inside that hour. A wildcard minute is the
+// whole hour, so it reads as that hour itself ("every minute of the 9 a.m.
+// hour") rather than a synthesized "from H:00 through H:59" range the source
+// never stated; a plain range is a real window and keeps "from … through …".
 function renderMinuteSpanInHour(ir: IR, plan: PlanOf<'minuteSpanInHour'>,
   opts: NormalizedOptions): string {
+  if (ir.pattern.minute === '*') {
+    return 'every minute of the ' +
+      getTime({hour: plan.hour, minute: 0}, opts) + ' hour' +
+      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) +
@@ -547,7 +612,10 @@ const renderers = {
 // Phrase a `start/interval` step segment for a field that cycles every 60
 // units (seconds and minutes). `unit` is the singular noun and `anchor` is
 // the larger unit the values are counted against. Interval-one steps never
-// arrive here: normalization collapses them to ranges or `*`.
+// arrive here: normalization collapses them to ranges or `*`. Nor do uneven
+// steps that fail to tile the cycle: normalization rewrites those to the
+// literal list of their fires, so only a clean cadence (interval dividing
+// 60, start within the first interval) reaches a step renderer.
 function stepCycle60(segment: StepSegment, unit: string,
   anchor: string, opts: NormalizedOptions): string {
   // A bounded start (`a-b/n`) applies the interval within the range.
@@ -559,6 +627,8 @@ function stepCycle60(segment: StepSegment, unit: string,
   const interval = segment.interval;
 
   if (start !== 0) {
+    // A short offset cadence lists its fires; a longer one names the
+    // interval and its starting offset ("every six minutes from five …").
     if (segment.fires.length <= 3) {
       return listPastThe(numberWords(segment.fires, opts), unit, anchor,
         opts);
@@ -569,18 +639,8 @@ function stepCycle60(segment: StepSegment, unit: string,
       ' past the ' + anchor;
   }
 
-  // A step reads as a natural cadence ("every N minutes") only when it
-  // divides the cycle evenly, mirroring the hour field's `24 % n` rule.
-  if (60 % interval === 0) {
-    return 'every ' + getNumber(interval, opts) + ' ' + unit + 's';
-  }
-
-  if (segment.fires.length <= 2) {
-    return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
-  }
-
-  return 'every ' + getNumber(interval, opts) + ' ' + unit +
-    's past the ' + anchor;
+  // A clean stride from the top of the cycle is the bare cadence.
+  return 'every ' + getNumber(interval, opts) + ' ' + unit + 's';
 }
 
 // Phrase a `start/interval` step segment for the hour field (cycles every
@@ -594,18 +654,18 @@ function stepHours(segment: StepSegment, opts: NormalizedOptions): string {
   const start = segment.startToken === '*' ? 0 : +segment.startToken;
   const interval = segment.interval;
 
-  if (start === 0 && 24 % interval === 0) {
+  // A clean stride from midnight is the bare cadence. (An uneven stride is
+  // rewritten to its fires upstream and never reaches here.)
+  if (start === 0) {
     return 'every ' + getNumber(interval, opts) + ' hours';
   }
 
+  // A short offset cadence lists its fires; a longer one names the interval
+  // and its start ("every three hours from 2 a.m.").
   if (segment.fires.length <= 3) {
     return 'at ' + hourTimes(segment.fires, opts);
   }
 
-  if (start === 0) {
-    return 'every ' + getNumber(interval, opts) + ' hours from midnight';
-  }
-
   return 'every ' + getNumber(interval, opts) + ' hours from ' +
     getTime({hour: start, minute: 0}, opts);
 }
@@ -1174,7 +1234,7 @@ function stepYears(yearField: string, opts: NormalizedOptions): string {
 // "3.45pm" / "9am" / "midday" for UK (Guardian), or "15:45" / "15.45" in
 // 24-hour mode.
 function getTime(time: TimeEntry, opts: NormalizedOptions): string {
-  const {hour, minute, plain} = time;
+  const {hour, minute, plain, explicit} = time;
   // Seconds are only shown when a specific non-zero value is supplied.
   const second = typeof time.second === 'number' && time.second > 0 ?
     time.second :
@@ -1184,12 +1244,13 @@ function getTime(time: TimeEntry, opts: NormalizedOptions): string {
     // Hour/minute arrive as numbers or raw field tokens (a range bound or
     // single value is a string); `clockDigits` types them as numbers but
     // `pad` stringifies either form to the same digits. Cast to keep the
-    // value byte-identical rather than coercing it.
+    // value byte-identical rather than coercing it. The 24-hour form always
+    // shows the minute, so it is already explicit.
     return clockDigits({hour: hour as number, minute: minute as number,
       second}, {pad: true, sep: opts.style.sep});
   }
 
-  return twelveHourTime({hour, minute, second, plain}, opts);
+  return twelveHourTime({hour, minute, second, plain, explicit}, opts);
 }
 
 // The 12-hour form of a clock time: "9:30 a.m.", "9 a.m." on the hour, or
@@ -1198,13 +1259,13 @@ function getTime(time: TimeEntry, opts: NormalizedOptions): string {
 // stays in one number style.
 function twelveHourTime(
   time: {hour: number | string; minute: number | string; second: number;
-    plain?: boolean},
+    plain?: boolean; explicit?: boolean},
   opts: NormalizedOptions
 ): string {
-  const {hour, minute, second, plain} = time;
+  const {hour, minute, second, plain, explicit} = time;
   const style = opts.style;
 
-  if (!plain && +minute === 0 && !second) {
+  if (!plain && !explicit && +minute === 0 && !second) {
     if (+hour === 0) {
       return style.midnight;
     }
@@ -1216,9 +1277,11 @@ function twelveHourTime(
 
   // `hour`/`minute` may be raw field tokens; the arithmetic below coerces
   // them numerically, matching `clockDigits`. Cast for the modulo/compare.
+  // `explicit` keeps the minute (":00") rather than leaning down to the bare
+  // hour, so a pinned minute-0 stays visible.
   const digits = clockDigits(
     {hour: (hour as number) % 12 || 12, minute: minute as number, second},
-    {lean: true, sep: style.sep});
+    {lean: !explicit, sep: style.sep});
 
   return digits + (style.closeUp ? '' : ' ') +
     ((hour as number) < 12 ? style.am : style.pm);
@@ -1260,11 +1323,10 @@ function getOrdinal(n: number | string): string {
   return n + suffix;
 }
 
-// Get English month names from a number or from an abbreviation.
+// Get English month names from a canonical month number (months are never
+// Quartz, so the field is always number-canonicalized by the core).
 function getMonth(m: number | string, opts: NormalizedOptions): string {
-  // `m` is a month number (indexing `monthNames`) or an abbreviation token
-  // (indexing `monthAbbreviations`); the unmatched table yields undefined.
-  const month = monthNames[m as number] || monthAbbreviations[m];
+  const month = monthNames[+m];
 
   // A valid month always resolves to a name pair, so the guarded lookup is
   // a string; the cast keeps the original null-guard expression intact.
@@ -1292,7 +1354,10 @@ const en: Language = {
   fallback: 'an unrecognizable cron pattern',
   options: normalizeOptions,
   reboot: 'at system startup',
-  sentence: (description) => 'Runs ' + description + '.'
+  // A description ending in an abbreviation already carries its period
+  // ("…9 a.m."), so closing the sentence must not double it.
+  sentence: (description) =>
+    'Runs ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default en;

package/src/lang/es/index.ts

@@ -9,6 +9,8 @@
 // lists render as per-hour windows).
 
 import {clockDigits, numeral} from '../../core/format.js';
+import {weekdayNumbers} from '../../core/specs.js';
+import {toFieldNumber} from '../../core/util.js';
 import type {Cronli5Options} from '../../types.js';
 import type {
   Field, HourTimesPlan, IR, Language, NormalizedOptions, PlanNode,
@@ -109,16 +111,6 @@ const weekdayNames = [
   'sábado'
 ];
 
-// Cron token vocabulary (JAN..DEC, SUN..SAT) is part of cron syntax; map
-// it to Spanish names.
-const monthTokens: {[token: string]: number} = {
-  JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6,
-  JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12
-};
-const weekdayTokens: {[token: string]: number} = {
-  SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6
-};
-
 // Ordinals for Quartz `#` weekday occurrences (1-5).
 const nthWeekdayNames =
   [null, 'primer', 'segundo', 'tercer', 'cuarto', 'quinto'];
@@ -219,6 +211,13 @@ function renderComposeSeconds(
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
   opts: Opts
 ): string {
+  // A wildcard or stepped second with the minute pinned to a single value
+  // across one or more specific hours: the seconds confine to the clock time.
+  if (plan.rest.kind === 'clockTimes' &&
+      (ir.shapes.second === 'wildcard' || ir.shapes.second === 'step')) {
+    return pinnedMinuteSeconds(ir, plan.rest, opts);
+  }
+
   // Seconds list + fixed clock time: nest the seconds into the clock time(s)
   // with genitive "de las HH:MM" instead of "de cada minuto"; the minute is
   // fixed so "de cada minuto" is misleading. Single seconds already fold into
@@ -256,6 +255,33 @@ function renderComposeSeconds(
   return secondsLeadClause(ir, opts) + ', ' + render(ir, plan.rest, opts);
 }
 
+// A wildcard or stepped second under a single pinned minute and specific
+// hour(s). The clock-time rest folds the minute into the hour, and on the
+// 12-hour clock a pinned minute-0 drops the :00 entirely ("a las 9 de la
+// mañana") — and even "a las 9" reads aloud as the whole hour, hiding the
+// one-minute confinement (60 fires in :00, not 3,600 across the hour). Minute
+// 0 is the one-minute window at the top of each named hour: a duration frame
+// ("durante un minuto a las 9") states the confinement outright, with the hour
+// as a bare hour so it cannot be heard as the whole hour. A non-zero pinned
+// minute is an unambiguous clock time, so the genitive "de las 09:05" form
+// reads it as the minute, never the hour.
+function pinnedMinuteSeconds(
+  ir: IR,
+  rest: Extract<PlanNode, {kind: 'clockTimes'}>,
+  opts: Opts
+): string {
+  const dayTrail = leadingQualifier(ir, opts).trimEnd();
+  const trail = dayTrail ? ', ' + dayTrail : '';
+
+  if (+rest.times[0].minute === 0) {
+    return secondsLeadClause(ir, opts) + ' durante un minuto ' +
+      durationHourList(rest.times, opts) + trail;
+  }
+
+  return secondsLeadClause(ir, opts) + ' de ' +
+    explicitClockList(rest.times, opts) + trail;
+}
+
 // The leading clause describing a second field relative to the minute.
 function secondsLeadClause(ir: IR, opts: Opts): string {
   const secondField = ir.pattern.second;
@@ -453,12 +479,21 @@ function renderMinuteFrequency(
   return phrase + trailingQualifier(ir, opts);
 }
 
-// "cada minuto de las 9:00 a las 9:29 de la mañana".
+// "cada minuto de las 9:00 a las 9:29 de la mañana". A wildcard minute is the
+// whole hour, so it reads as that hour itself ("cada minuto de la hora de las
+// 09:00") rather than a synthesized "de las HH:00 a las HH:59" range the
+// source never stated; a plain range is a real window and keeps "de … a …".
 function renderMinuteSpanInHour(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'minuteSpanInHour'}>,
   opts: Opts
 ): string {
+  if (ir.pattern.minute === '*') {
+    return 'cada minuto de la hora ' +
+      fromTime(timePhrase(plan.hour, 0, null, opts)) +
+      trailingQualifier(ir, opts);
+  }
+
   return 'cada minuto ' +
     timeRange({hour: plan.hour, minute: plan.span[0]},
       {hour: plan.hour, minute: plan.span[1]}, opts) +
@@ -689,6 +724,82 @@ function renderClockTimes(
   return leadingQualifier(ir, opts) + groupClockTimes(phrases);
 }
 
+// The genitive clock-time list for a minute-0 compose-seconds confinement:
+// each time with its minute forced visible ("las 09:00"), grouped as usual,
+// then reframed from "a …" to the genitive "de …" the caller prepends. So a
+// pinned minute-0 reads "de las 09:00", never the bare hour.
+function explicitClockList(
+  times: {hour: number; minute: number; second?: number | null}[],
+  opts: Opts
+): string {
+  const phrases = times.map(function clock(time) {
+    return atTime(explicitTimePhrase(time.hour, time.minute, opts));
+  });
+  const grouped = groupClockTimes(phrases);
+
+  // Strip the leading "a " so the caller's "de " produces the genitive form.
+  return grouped.startsWith('a ') ? grouped.slice(2) : grouped;
+}
+
+// The bare-hour list for a minute-0 duration confinement, keeping the "a …"
+// frame the caller embeds after "durante un minuto": "a las 9",
+// "a medianoche", "a las 9, 10, 11 y 12". The hour reads as a bare hour
+// (no minutes), since the "durante un minuto" frame already carries the
+// one-minute window — never "las 09:00", which would read as the whole hour.
+function durationHourList(
+  times: {hour: number; minute: number; second?: number | null}[],
+  opts: Opts
+): string {
+  const phrases = times.map(function clock(time) {
+    return atTime(bareHourPhrase(time.hour, opts));
+  });
+
+  return groupClockTimes(phrases);
+}
+
+// A bare hour with its article, no minutes: "las 9" / "la 1" / "mediodía" /
+// "medianoche" on the 24-hour clock, or the 12-hour day-period form
+// ("las 9 de la mañana"). Used by the minute-0 duration frame, where the
+// minute is already stated and the clock minute would only mislead.
+function bareHourPhrase(hour: number, opts: Opts): string {
+  if (opts.ampm) {
+    return timePhrase(hour, 0, null, opts);
+  }
+
+  if (+hour === 0) {
+    return 'medianoche';
+  }
+
+  if (+hour === 12) {
+    return 'mediodía';
+  }
+
+  return (+hour === 1 ? 'la ' : 'las ') + hour;
+}
+
+// A clock time with its minute forced visible and the noon/midnight words
+// suppressed: "las 09:00", "las 9:00 de la mañana", "las 12:00 de la tarde".
+// So a pinned minute-0 confinement always shows its ":00".
+function explicitTimePhrase(hour: number, minute: number, opts: Opts): string {
+  if (!opts.ampm) {
+    const article = +hour === 1 ? 'la ' : 'las ';
+    const suffix = opts.style.hSuffix ? ' h' : '';
+
+    return article +
+      clockDigits({hour, minute, second: 0},
+        {pad: true, sep: opts.style.sep}) + suffix;
+  }
+
+  const display = hour % 12 || 12;
+  const time = (display === 1 ? 'la ' : 'las ') +
+    clockDigits({hour: display, minute, second: 0}, {sep: opts.style.sep});
+  const period = opts.style.meridiem === 'english' ?
+    meridiemMark(hour) :
+    dayPeriod(hour, opts);
+
+  return time + ' ' + period;
+}
+
 // Group a chronological run of "a la(s) …" clock phrases. The 12-hour clock
 // carries day periods ("de la <period>"), which group chronologically by
 // period; the 24-hour clock has none, so it falls through to article-grouping.
@@ -1015,17 +1126,9 @@ function stepCycle60(
       unit + ' ' + start + ' de cada ' + anchor;
   }
 
-  if (60 % interval === 0) {
-    return 'cada ' + numero(interval, opts) + ' ' + unit + 's';
-  }
-
-  if (segment.fires.length <= 2) {
-    return 'en los ' + unit + 's ' + joinList(wordList(segment.fires)) +
-      ' de cada ' + anchor;
-  }
-
-  return 'cada ' + numero(interval, opts) + ' ' + unit + 's de cada ' +
-    anchor;
+  // A clean stride from the top of the cycle is the bare cadence. (An uneven
+  // stride is rewritten to its fires upstream and never reaches here.)
+  return 'cada ' + numero(interval, opts) + ' ' + unit + 's';
 }
 
 // "cada seis horas", "a las 9:00, a las 11:00 y a la 1:00", or "cada
@@ -1038,7 +1141,9 @@ function stepHours(segment: StepSegment, opts: Opts): string {
   const start = segment.startToken === '*' ? 0 : +segment.startToken;
   const interval = segment.interval;
 
-  if (start === 0 && 24 % interval === 0) {
+  // A clean stride from midnight is the bare cadence. (An uneven stride is
+  // rewritten to its fires upstream and never reaches here.)
+  if (start === 0) {
     return 'cada ' + numero(interval, opts) + ' horas';
   }
 
@@ -1046,10 +1151,6 @@ function stepHours(segment: StepSegment, opts: Opts): string {
     return groupClockTimesByArticle(atTimes(segment.fires, opts));
   }
 
-  if (start === 0) {
-    return 'cada ' + numero(interval, opts) + ' horas desde medianoche';
-  }
-
   return 'cada ' + numero(interval, opts) + ' horas a partir de ' +
     timePhrase(start, 0, null, opts);
 }
@@ -1699,16 +1800,13 @@ function numero(n: number, opts: Opts): string | number {
   return numeral(n, numeros, opts);
 }
 
-// A weekday name from a number or a cron token.
+// A weekday name from a canonical number, or from a Quartz stem (`5L`,
+// `MON#2`), which the core does not number-canonicalize: resolve any name
+// via the core's index and fold the Sunday alias 7 to 0.
 function weekdayName(token: NameToken): string {
-  if (token === '7' || token === 7) {
-    return weekdayNames[0];
-  }
+  const number = toFieldNumber('' + token, weekdayNumbers);
 
-  // `token` may be a numeric (string or number) field index or a cron name;
-  // the numeric path indexes the name array, the name path the token map.
-  return weekdayNames[token as number] ||
-    weekdayNames[weekdayTokens[token as string]];
+  return weekdayNames[number === 7 ? 0 : number];
 }
 
 // The plural weekday form: días ending in -s are invariant ("los lunes");
@@ -1719,12 +1817,10 @@ function pluralWeekday(token: NameToken): string {
   return name.endsWith('s') ? name : name + 's';
 }
 
-// A month name from a number or a cron token.
+// A month name from a canonical month number. The name array has a leading
+// null hole for the 1-based index.
 function monthName(token: NameToken): string {
-  // As with weekdays: a numeric index hits the name array, a cron name the
-  // token map. The name array has a leading null hole for the 1-based index.
-  return (monthNames[token as number] ||
-    monthNames[monthTokens[token as string]]) as string;
+  return monthNames[+token] as string;
 }
 
 // Whether a canonical field value is an open step (`*/n` or `a/n`).
@@ -1740,7 +1836,10 @@ const es: Language<SpanishStyle> = {
   fallback: 'un patrón cron irreconocible',
   options: normalizeOptions,
   reboot: 'al arrancar el sistema',
-  sentence: (description) => 'Se ejecuta ' + description + '.'
+  // A description ending in a period already carries it, so closing the
+  // sentence must not double it.
+  sentence: (description) =>
+    'Se ejecuta ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default es;