cronli5 0.1.1 → 0.1.4

package/dist/lang/zh.js

@@ -171,10 +171,12 @@ function hourFrame(ir) {
   return "\u5728" + hourList(ir) + "\uFF0C";
 }
 function renderMinuteFrequency(ir, plan) {
-  const base = cadence(stepSegment(ir, "minute").interval, UNITS.minute);
+  const minuteStep = stepSegment(ir, "minute");
+  const base = minuteStep.startToken === "*" ? cadence(minuteStep.interval, UNITS.minute) : renderMinutePast(ir);
   const { hours } = plan;
   if (hours.kind === "step") {
-    return cadence(stepSegment(ir, "hour").interval, UNITS.hour) + base;
+    const hourStep = stepSegment(ir, "hour");
+    return hourStep.startToken === "*" ? cadence(hourStep.interval, UNITS.hour) + base : "\u5728" + hourList(ir) + "\uFF0C" + base;
   }
   if (hours.kind === "single" || hours.kind === "window" && hours.from === hours.to) {
     return "\u5728" + hourWord(hours.from) + "\u81F3" + hours.from + "\u70B9" + hours.last + "\u5206\u4E4B\u95F4\uFF0C" + base;
@@ -189,6 +191,9 @@ function renderMinuteFrequency(ir, plan) {
 }
 function renderMinuteSpanInHour(ir, plan) {
   const span = plan;
+  if (ir.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) {
@@ -199,12 +204,17 @@ function renderMinutesAcrossHours(ir, plan) {
   return hourList(ir) + "\uFF0C\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
 }
 function renderMinuteSpanAcrossHourStep(ir, plan) {
-  const cad = cadence(stepSegment(ir, "hour").interval, UNITS.hour);
+  const hourStep = stepSegment(ir, "hour");
   const { form } = plan;
-  if (form === "wildcard") {
-    return cad + "\u5185\uFF0C\u6BCF\u5206\u949F";
+  const minuteTail = form === "wildcard" ? "\u6BCF\u5206\u949F" : "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  if (hourStep.startToken !== "*") {
+    return form === "wildcard" ? "\u5728" + hourList(ir) + "\uFF0C" + minuteTail : hourList(ir) + "\uFF0C" + minuteTail;
   }
-  return cad + "\uFF0C\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206") + "\uFF0C\u6BCF\u5206\u949F";
+  if (hourStep.interval === 2 && form === "wildcard") {
+    return "\u5728\u5076\u6570\u5C0F\u65F6\uFF0C" + minuteTail;
+  }
+  const cad = cadence(hourStep.interval, UNITS.hour);
+  return form === "wildcard" ? cad + "\u5185\uFF0C" + minuteTail : cad + "\uFF0C" + minuteTail;
 }
 function renderClockTimes(ir, plan, opts) {
   const { times } = plan;
@@ -239,9 +249,6 @@ function renderHourStep(ir) {
   if (segment.fires.length <= 2) {
     return joinAnd(segment.fires.map(hourWord));
   }
-  if (24 % segment.interval !== 0) {
-    return "\u4ECE" + hourWord(segment.fires[0]) + "\u8D77\uFF0C" + cadence(segment.interval, UNITS.hour);
-  }
   return cadence(segment.interval, UNITS.hour);
 }
 function renderRangeOfMinutes(ir) {
@@ -293,9 +300,19 @@ 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 restText = render(ir, rest, opts);
-  if ((rest.kind === "clockTimes" || rest.kind === "compactClockTimes") && isDaily(ir)) {
-    return "\u6BCF\u5929" + restText + sec;
+  if (rest.kind === "clockTimes" || rest.kind === "compactClockTimes") {
+    if (isDaily(ir)) {
+      return "\u6BCF\u5929" + restText + sec;
+    }
   }
   if (rest.kind === "singleMinute") {
     return restText + "\uFF0C" + sec;
@@ -319,6 +336,9 @@ function composeSecondsCadence(ir) {
 function composeSecondsListed(ir) {
   const sec = secondClause(ir);
   const minutes = "\u6BCF\u5C0F\u65F6" + valueList(fieldSegments(ir, "minute"), "\u5206");
+  if (ir.shapes.hour === "single" && sec === "\u6BCF\u79D2") {
+    return hourWord(hourFires(ir)[0]) + valueList(fieldSegments(ir, "minute"), "\u5206") + "\u7684\u6BCF\u4E00\u79D2";
+  }
   if (ir.shapes.hour === "wildcard") {
     return minutes + "\uFF0C" + sec;
   }
@@ -328,10 +348,13 @@ function composeSecondsListed(ir) {
   return hourFrame(ir) + minutes + "\uFF0C" + sec;
 }
 function renderComposeSeconds(ir, plan, opts) {
-  if (ir.pattern.minute === "0") {
+  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 (ir.pattern.minute === "*" || ir.shapes.minute === "step") {
+  const minuteCadence = ir.pattern.minute === "*" || ir.shapes.minute === "step" && stepSegment(ir, "minute").startToken === "*";
+  if (minuteCadence) {
     return composeSecondsCadence(ir);
   }
   return composeSecondsListed(ir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",
@@ -62,6 +62,7 @@
     "docs": "node --import tsx scripts/docs.mjs",
     "fuzz": "node --import tsx scripts/fuzz-lang.mjs",
     "lint": "eslint src test cli.js eslint.config.js scripts tooling/scripts",
+    "metamorphic": "node --import tsx tooling/scripts/metamorphic.mjs",
     "lint:fix": "eslint src test cli.js eslint.config.js scripts tooling/scripts --fix",
     "test": "mocha",
     "types": "tsc -p tsconfig.types.json",

package/src/core/normalize.ts

@@ -4,10 +4,20 @@
 
 import {fieldOrder, fieldSpecs} from './specs.js';
 import type {CronLike, FieldSpec} from './specs.js';
-import type {Pattern} from './ir.js';
+import type {Field, Pattern} from './ir.js';
 import {includes, toFieldNumber, unique} from './util.js';
 import {isQuartzDate, isQuartzWeekday} from './validate.js';
 
+// The fixed-cycle time fields: their step intervals are measured against a
+// closed cycle (60 seconds, 60 minutes, 24 hours), so a step is a true
+// "every N" cadence only when it tiles that cycle. The calendar fields
+// (date/month/weekday) have variable cycles and keep their step form.
+const timeFieldCycle: Partial<Record<Field, number>> = {
+  hour: 24,
+  minute: 60,
+  second: 60
+};
+
 // Quartz aliases: `?` reads "no specific value" (equivalent to `*`) in the
 // date and weekday fields, and a bare `L` weekday means Saturday.
 function applyQuartzAliases(cronPattern: CronLike): void {
@@ -40,7 +50,7 @@ function normalizeCronPattern(cronPattern: CronLike): Pattern {
       return;
     }
 
-    cronPattern[field] = normalizeField(value, fieldSpecs[field]);
+    cronPattern[field] = normalizeField(value, field, fieldSpecs[field]);
   });
 
   // Every field is now a canonical string.
@@ -48,17 +58,23 @@ function normalizeCronPattern(cronPattern: CronLike): Pattern {
 }
 
 // Canonicalize a single validated field value to a string.
-function normalizeField(value: string, spec: FieldSpec): string {
+function normalizeField(value: string, field: Field, spec: FieldSpec): string {
   const stringValue = '' + value;
 
   if (stringValue === '*') {
     return stringValue;
   }
 
+  const cycle = timeFieldCycle[field];
   const segments = stringValue.split(',').map(function canonical(segment) {
-    return collapseDegenerateRange(
-      collapseOnceStep(collapseUnitStep(segment, spec), spec), spec);
-  });
+    return canonicalizeTokens(collapseFullSpanRange(
+      enumerateNonUniformStep(
+        collapseFullSpanStep(
+          collapseDegenerateRange(
+            collapseOnceStep(collapseUnitStep(segment, spec), spec), spec),
+          spec),
+        spec, cycle), spec), spec);
+  }).join(',').split(',');
 
   // A full-cycle segment covers the whole field.
   if (segments.indexOf('*') !== -1) {
@@ -70,6 +86,40 @@ function normalizeField(value: string, spec: FieldSpec): string {
   }).join(',');
 }
 
+// Rewrite a segment's value tokens to their canonical numbers: a name
+// (`MON`, `JAN`) becomes its index, and a weekday `7` (Sunday again, above
+// `top`) folds to the field minimum (`0`). Applied to every token position —
+// a single, both range bounds, and a step's start — so a normalized field
+// never carries a surface name or the 7-for-Sunday alias. `*` and Quartz
+// tokens (resolved earlier) are left untouched. Output is unchanged: a
+// renderer maps the number back to its own name.
+function canonicalizeTokens(segment: string, spec: FieldSpec): string {
+  // Only the named fields (month, weekday) carry name tokens or the
+  // weekday `7`-for-Sunday alias; every other field is already numeric.
+  if (!spec.numbers) {
+    return segment;
+  }
+
+  const parts = segment.split('/');
+  const start = parts[0].split('-').map(function fold(token) {
+    return canonicalizeToken(token, spec);
+  }).join('-');
+
+  return parts.length === 2 ? start + '/' + parts[1] : start;
+}
+
+// A single token to its canonical number string (`*` passes through).
+function canonicalizeToken(token: string, spec: FieldSpec): string {
+  if (token === '*') {
+    return token;
+  }
+
+  const number = toFieldNumber(token, spec.numbers);
+
+  // A value above `top` (weekday 7) is the field minimum again.
+  return '' + (number > (spec.top as number) ? spec.min : number);
+}
+
 // An interval-one step enumerates every value from its start, so it reads
 // as the equivalent range: `1/1` is `1-59` and `5-30/1` is `5-30`. A start
 // at the bottom of the cycle covers the whole field (`0/1` is `*`).
@@ -115,6 +165,94 @@ function collapseOnceStep(segment: string, spec: FieldSpec): string {
   return start === '*' ? '' + spec.min : start;
 }
 
+// An unbounded step in a fixed-cycle time field is a true "every N" cadence
+// only when it tiles the cycle: the interval divides it evenly and the start
+// falls within the first interval (`*/15`, `5/6`). A step that fails either
+// test fires at irregular points within the cycle, so it reads as the literal
+// list of those fires (`*/7` is `0,7,14,…`), the same as if it were written
+// out. Calendar fields (no `cycle`), bounded steps (`9-17/2`, a per-window
+// stride), and non-step segments are left untouched.
+function enumerateNonUniformStep(
+  segment: string,
+  spec: FieldSpec,
+  cycle: number | undefined
+): string {
+  const parts = segment.split('/');
+
+  if (typeof cycle !== 'number' || parts.length !== 2 ||
+      includes(parts[0], '-')) {
+    return segment;
+  }
+
+  const interval = +parts[1];
+  const start = parts[0] === '*' ? spec.min : toFieldNumber(parts[0]);
+
+  if (cycle % interval === 0 && start < interval) {
+    return segment;
+  }
+
+  const fires = [];
+
+  for (let value = start; value <= (spec.top as number); value += interval) {
+    fires.push(value);
+  }
+
+  return fires.join(',');
+}
+
+// A step whose range part covers the whole field (`0-59/2`, `0-23/2`) strides
+// across the entire cycle, so the bound adds nothing — it reads as the
+// unbounded `*/N` step (which the cycle test then renders as "every N" or its
+// fires). Partial-range steps (`9-17/2`) keep their window.
+function collapseFullSpanStep(segment: string, spec: FieldSpec): string {
+  const parts = segment.split('/');
+
+  if (parts.length !== 2 || !includes(parts[0], '-')) {
+    return segment;
+  }
+
+  return collapseFullSpanRange(parts[0], spec) === '*' ?
+    '*/' + parts[1] :
+    segment;
+}
+
+// A plain range whose enumerated values cover the whole field imposes no
+// restriction, so it reads identically to `*` (`0-59` minute, `0-23` hour,
+// `1-31` date, `1-12` month, and every seven-day weekday range — `0-6`,
+// `1-7`, `0-7`, `SUN-SAT` — since cron's 7 is Sunday again, folding to the
+// field minimum). Only bare ranges qualify: a step (`0-59/2`) keeps its
+// cadence, so segments carrying a `/` are left untouched.
+function collapseFullSpanRange(segment: string, spec: FieldSpec): string {
+  if (typeof spec.top !== 'number' || includes(segment, '/') ||
+      !includes(segment, '-')) {
+    return segment;
+  }
+
+  const bounds = segment.split('-');
+  const low = toFieldNumber(bounds[0], spec.numbers);
+  const high = toFieldNumber(bounds[1], spec.numbers);
+
+  if (low > high) {
+    return segment;
+  }
+
+  // The full field is min..top; a value above top (weekday 7) folds to min.
+  const top = spec.top as number;
+  const fired: Record<number, boolean> = {};
+
+  for (let value = low; value <= high; value += 1) {
+    fired[value > top ? spec.min : value] = true;
+  }
+
+  for (let value = spec.min; value <= top; value += 1) {
+    if (!fired[value]) {
+      return segment;
+    }
+  }
+
+  return '*';
+}
+
 // A degenerate range (`9-9`) fires once, so it reads as its single value.
 // A stepped degenerate range (`9-9/5`) likewise fires only at its start.
 function collapseDegenerateRange(segment: string, spec: FieldSpec): string {

package/src/lang/de/index.ts

@@ -2,6 +2,8 @@
 // German. Anchored to Duden; see notes.md for the decisions.
 
 import {pad} 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, Segment
@@ -61,11 +63,6 @@ const weekdayNames = [
   'freitags', 'samstags'
 ];
 
-// Cron weekday tokens (part of cron syntax), mapped to indices.
-const weekdayTokens: {[token: string]: number} = {
-  SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6
-};
-
 function fieldSegments(ir: IR, field: Field): Segment[] {
   return ir.analyses.segments[field] as Segment[];
 }
@@ -94,14 +91,9 @@ function joinList(items: string[]): string {
   return items.slice(0, -1).join(', ') + ' und ' + items[items.length - 1];
 }
 
-// The adverbial name for a weekday token (cron name or number; 7 = Sunday).
+// The adverbial name for a canonical weekday number (0 = Sunday).
 function weekdayName(token: NameToken): string {
-  if (token === '7' || token === 7) {
-    return weekdayNames[0];
-  }
-
-  return weekdayNames[token as number] ||
-    weekdayNames[weekdayTokens[token as string]];
+  return weekdayNames[+token];
 }
 
 // "montags bis freitags".
@@ -150,12 +142,10 @@ function everyNthHour(segment: StepSegment): string {
   return start === 0 ? base : base + ' ab ' + start + ' Uhr';
 }
 
+// The Quartz weekday stem (`5L`, `MON#2`) is not number-canonicalized in the
+// core, so it may still be a name token; resolve it via the core's index.
 function weekdayNoun(token: string): string {
-  if (token === '7') {
-    return weekdayNouns[0];
-  }
-
-  return weekdayNouns[token in weekdayTokens ? weekdayTokens[token] : +token];
+  return weekdayNouns[toFieldNumber(token, weekdayNumbers)];
 }
 
 // The Quartz weekday phrase: "am letzten Freitag des Monats", "am zweiten
@@ -193,18 +183,12 @@ function quartzDate(field: string): string | null {
   return null;
 }
 
-// Cron month tokens (part of cron syntax), mapped to indices. The month names
-// themselves are dialect-scoped and resolved from `opts.style.months`.
-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
-};
-
 type Months = GermanStyle['months'];
 
+// The month names are dialect-scoped (resolved from `opts.style.months`);
+// the canonical month number indexes them.
 function monthName(token: NameToken, months: Months): string {
-  return (months[token as number] ||
-    months[monthTokens[token as string]]) as string;
+  return months[+token] as string;
 }
 
 // "von Juni bis August".
@@ -462,7 +446,9 @@ function duringHours(ir: IR, times: HourTimesPlan, sep: string): string {
     return joinList(windows);
   }
 
-  return 'in den Stunden von ' + joinList(times.fires.map(String)) + ' Uhr';
+  // A discrete set of hours is a list, not a range, so it takes no "von"
+  // (which would read as "von X bis Y"); it mirrors the minute list form.
+  return 'in den Stunden ' + joinList(times.fires.map(String)) + ' Uhr';
 }
 
 // --- Renderers. ---
@@ -509,12 +495,33 @@ function renderSecondsWithinMinute(
     ' jeder Stunde';
 }
 
-// A minute span inside one hour: "jede Minute von 9:00 bis 9:30 Uhr".
+// The whole-hour noun in the genitive: "der Mitternachtsstunde" (0), "der
+// Mittagsstunde" (12), or "der <H>-Uhr-Stunde" for any other hour.
+function wholeHour(hour: number): string {
+  if (hour === 0) {
+    return 'der Mitternachtsstunde';
+  }
+
+  if (hour === 12) {
+    return 'der Mittagsstunde';
+  }
+
+  return 'der ' + hour + '-Uhr-Stunde';
+}
+
+// A minute span inside one hour: "jede Minute von 9:00 bis 9:30 Uhr". A
+// wildcard minute is the whole hour, so it reads as that hour itself ("jede
+// Minute der 9-Uhr-Stunde") rather than a synthesized "von 9:00 bis 9:59"
+// range the source never stated; a plain range is a real window and keeps it.
 function renderMinuteSpanInHour(
   ir: IR,
   plan: Extract<PlanNode, {kind: 'minuteSpanInHour'}>,
   opts: Opts
 ): string {
+  if (ir.pattern.minute === '*') {
+    return 'jede Minute ' + wholeHour(plan.hour);
+  }
+
   const sep = opts.style.sep;
 
   return 'jede Minute von ' + spanTime(plan.hour, plan.span[0], sep) +
@@ -528,9 +535,47 @@ function renderComposeSeconds(
   plan: Extract<PlanNode, {kind: 'composeSeconds'}>,
   opts: Opts
 ): string {
+  // A sub-minute second with the minute pinned to 0 and a specific hour: the
+  // clock-time rest would read "um 9 Uhr", which hides the pinned :00 (and so
+  // the one-minute confinement — 60 fires in :00, not 3,600 across the hour).
+  // Bind the seconds into the explicit clock minute in the genitive ("der
+  // Minute 9:00"); the recurring "täglich"/day frame is added in `describe`.
+  if (composeMinuteZero(ir, plan)) {
+    return secondsLead(ir) + ' ' +
+      clockMinuteGenitive(plan.rest.times, opts.style.sep);
+  }
+
   return secondsLead(ir) + ', ' + render(ir, plan.rest, opts);
 }
 
+// True when a compose-seconds plan is a sub-minute second over a minute-0
+// clock-time rest — the case that reads as the bare hour and so must surface
+// the pinned clock minute.
+function composeMinuteZero(
+  ir: IR,
+  plan: Extract<PlanNode, {kind: 'composeSeconds'}>
+): plan is Extract<PlanNode, {kind: 'composeSeconds'}> &
+  {rest: Extract<PlanNode, {kind: 'clockTimes'}>} {
+  return plan.rest.kind === 'clockTimes' &&
+    plan.rest.times.every((time) => +time.minute === 0);
+}
+
+// The pinned clock minute in the genitive: "der Minute 9:00" for one hour,
+// "der Minuten 9:00, 10:00 und 17:00" for several — the explicit ":00" so the
+// minute-0 confinement stays visible.
+function clockMinuteGenitive(
+  times: {hour: number; minute: number}[],
+  sep: string
+): string {
+  const clocks = times.map(function clock(time): string {
+    return time.hour + sep + pad(time.minute);
+  });
+
+  return clocks.length === 1 ?
+    'der Minute ' + clocks[0] :
+    'der Minuten ' + joinList(clocks);
+}
+
 // A minute clause across discrete hours: "in den Minuten 0 bis 30, um 9 und
 // 17 Uhr".
 function renderMinutesAcrossHours(
@@ -739,15 +784,31 @@ function qualifier(ir: IR, months: Months): string {
 }
 
 // Plan kinds whose clause is a clock time: the qualifier leads them ("montags
-// um 9 Uhr"); a frequency clause trails it ("jede Minute montags").
+// um 9 Uhr"); a frequency clause trails it ("jede Minute montags"). The
+// minute-0 compose-seconds clause is anchored on a clock minute too, so the
+// qualifier leads it ("montags jede Sekunde der Minute 9:00").
 const LEADING_PLANS = new Set(['clockTimes']);
 
+// True when the leading qualifier should precede the clause: a clock-time
+// plan, or the minute-0 compose-seconds clause that surfaces a clock minute.
+function leadsQualifier(ir: IR): boolean {
+  return LEADING_PLANS.has(ir.plan.kind) || isComposeMinuteZero(ir);
+}
+
+// Whether the planned clause is the minute-0 compose-seconds confinement
+// (a sub-minute second over a minute-0 clock-time rest).
+function isComposeMinuteZero(ir: IR): boolean {
+  return ir.plan.kind === 'composeSeconds' &&
+    composeMinuteZero(ir, ir.plan);
+}
+
 // True when the clause is a bare daily clock-time list and so needs the
-// "täglich" frame to read as recurring, not a one-off: clockTimes always, and
-// an uneven hour step (rendered as its fire list "um 0, 5, … Uhr", not the
-// cadence "alle N Stunden"). A frequency clause already implies recurrence.
+// "täglich" frame to read as recurring, not a one-off: clockTimes always, the
+// minute-0 compose-seconds clause (a recurring clock minute), and an uneven
+// hour step (rendered as its fire list "um 0, 5, … Uhr", not the cadence "alle
+// N Stunden"). A frequency clause already implies recurrence.
 function needsDailyFrame(ir: IR): boolean {
-  if (ir.plan.kind === 'clockTimes') {
+  if (ir.plan.kind === 'clockTimes' || isComposeMinuteZero(ir)) {
     return true;
   }
 
@@ -802,7 +863,7 @@ function describe(ir: IR, opts: Opts): string {
   let base = core;
 
   if (qual) {
-    base = LEADING_PLANS.has(ir.plan.kind) ?
+    base = leadsQualifier(ir) ?
       qual + ' ' + core :
       core + ' ' + qual;
   }
@@ -818,7 +879,10 @@ const de: Language<GermanStyle> = {
   fallback: 'ein unlesbares Cron-Muster',
   options: normalizeOptions,
   reboot: 'beim Systemstart',
-  sentence: (description) => 'Läuft ' + description + '.'
+  // A description ending in a German ordinal already carries its period
+  // ("…am 8."), so closing the sentence must not double it.
+  sentence: (description) =>
+    'Läuft ' + description + (description.endsWith('.') ? '' : '.')
 };
 
 export default de;