cronli5 0.3.1 → 0.7.2

package/dist/lang/fr.cjs

@@ -0,0 +1,1210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lang/fr/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/format.ts
+function pad(n) {
+  n = "" + n;
+  return n.length < 2 ? "0" + n : n;
+}
+function numeral(n, words, opts) {
+  return opts.short ? n : words[n] || n;
+}
+
+// src/core/specs.ts
+var weekdayNumbers = {
+  SUN: 0,
+  MON: 1,
+  TUE: 2,
+  WED: 3,
+  THU: 4,
+  FRI: 5,
+  SAT: 6
+};
+var maxClockTimes = 6;
+
+// 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/cadence.ts
+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 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 lastTileOf(start, interval, cycle) {
+  return cycle - 1 - (cycle - 1 - start) % interval;
+}
+function renderStride(spec, parts) {
+  const { start, interval, last, cycle } = spec;
+  const open = cycle % interval === 0 && last === lastTileOf(
+    start,
+    interval,
+    cycle
+  );
+  if (start === 0 && open) {
+    return parts.bare();
+  }
+  if (start < interval && open) {
+    return parts.offset();
+  }
+  return parts.bounded();
+}
+function hourListStride(values) {
+  if (values.length < 2) {
+    return null;
+  }
+  const interval = values[1] - values[0];
+  if (interval < 2) {
+    return null;
+  }
+  for (let i = 2; i < values.length; i += 1) {
+    if (values[i] - values[i - 1] !== interval) {
+      return null;
+    }
+  }
+  if (values[0] !== 0 && values.length < 5) {
+    return null;
+  }
+  return { interval, last: values[values.length - 1], start: values[0] };
+}
+
+// src/core/weekday.ts
+function weekdayDisplayKey(value) {
+  return value === 0 ? 7 : value;
+}
+function orderWeekdaysForDisplay(segments) {
+  const flattened = segments.flatMap(function flat(segment) {
+    return segment.kind === "step" ? segment.fires.map(function single(value) {
+      return { kind: "single", value: "" + value };
+    }) : [segment];
+  });
+  function key(segment) {
+    return segment.kind === "range" ? weekdayDisplayKey(+segment.bounds[0]) : weekdayDisplayKey(+segment.value);
+  }
+  return flattened.map(function index(segment, position) {
+    return [segment, position];
+  }).sort(function byDisplayKey(a, b) {
+    return key(a[0]) - key(b[0]) || a[1] - b[1];
+  }).map(function unwrap(pair) {
+    return pair[0];
+  });
+}
+
+// src/lang/fr/dialects.ts
+var fr = {
+  sep: "h",
+  unspaced: false
+};
+var dialects = {
+  fr,
+  // France is the default; named explicitly so it is a recognized choice and
+  // has a home if it ever diverges.
+  "fr-FR": fr
+};
+function resolveDialect(dialect) {
+  if (typeof dialect === "object" && dialect !== null) {
+    return { ...dialects.fr, ...dialect };
+  }
+  return dialects[dialect] || dialects.fr;
+}
+
+// src/lang/fr/index.ts
+var numeros = [
+  "z\xE9ro",
+  "un",
+  "deux",
+  "trois",
+  "quatre",
+  "cinq",
+  "six",
+  "sept",
+  "huit",
+  "neuf",
+  "dix"
+];
+var monthNames = [
+  null,
+  "janvier",
+  "f\xE9vrier",
+  "mars",
+  "avril",
+  "mai",
+  "juin",
+  "juillet",
+  "ao\xFBt",
+  "septembre",
+  "octobre",
+  "novembre",
+  "d\xE9cembre"
+];
+var weekdayNames = [
+  "dimanche",
+  "lundi",
+  "mardi",
+  "mercredi",
+  "jeudi",
+  "vendredi",
+  "samedi"
+];
+var nthWeekdayMasculine = [null, "premier", "deuxi\xE8me", "troisi\xE8me", "quatri\xE8me", "cinqui\xE8me"];
+function normalizeOptions(options) {
+  options = options || {};
+  const style = resolveDialect(options.dialect);
+  return {
+    // fr is 24-hour only; `ampm` is accepted and ignored (a documented no-op,
+    // notes.md). It is normalized to false so the shared option shape is
+    // satisfied without the 12-hour machinery the es donor carried.
+    ampm: false,
+    lenient: !!options.lenient,
+    seconds: !!options.seconds,
+    short: !!options.short,
+    style,
+    years: !!options.years
+  };
+}
+function describe(schedule, opts) {
+  return applyYear(render(schedule, schedule.plan, opts), schedule, opts);
+}
+function render(schedule, plan, opts) {
+  const phrase = renderers[plan.kind](schedule, plan, opts);
+  if (!isDateWeekdayUnion(schedule)) {
+    return phrase;
+  }
+  const lead = unionMonthLeadFull(schedule);
+  return (lead ? lead + " " : "") + phrase + unionSoitSuffix(schedule, opts);
+}
+function renderEverySecond(schedule, plan, opts) {
+  return "chaque seconde" + trailingQualifier(schedule, opts);
+}
+function renderStandaloneSeconds(schedule, plan, opts) {
+  return secondsLeadClause(schedule, opts) + trailingQualifier(schedule, opts);
+}
+function renderSecondPastMinute(schedule, plan, opts) {
+  return "\xE0 la seconde " + schedule.pattern.second + " de chaque minute" + trailingQualifier(schedule, opts);
+}
+function renderSecondsWithinMinute(schedule, plan, opts) {
+  const minuteField = schedule.pattern.minute;
+  if (plan.singleSecond) {
+    return "\xE0 la minute " + minuteField + " et \xE0 la seconde " + schedule.pattern.second + " de chaque heure" + trailingQualifier(schedule, opts);
+  }
+  return secondsLeadClause(schedule, opts) + ", \xE0 la minute " + minuteField + " de chaque heure" + trailingQualifier(schedule, opts);
+}
+function secondsListAtClock(schedule, rest, opts) {
+  const clockPhrases = rest.times.map(function clock(time) {
+    return timePhrase(time.hour, time.minute, null, opts);
+  });
+  const clockList = joinList(clockPhrases);
+  const stride = strideFromSegments(segmentsOf(schedule, "second"), "seconde", "", opts);
+  const secondsPhrase = stride ?? "aux secondes " + joinList(segmentWords(segmentsOf(schedule, "second")));
+  const dayFrame = trailingQualifier(schedule, opts);
+  return (dayFrame ? dayFrame.trimStart() + ", " : "") + secondsPhrase + " de " + clockList;
+}
+function composeHourCadence(schedule, plan, opts) {
+  const clockRest = plan.rest.kind === "clockTimes" || plan.rest.kind === "compactClockTimes";
+  if (!clockRest || schedule.shapes.minute !== "single") {
+    return null;
+  }
+  const minute = +schedule.pattern.minute;
+  return hourCadence(schedule, minute, opts) ?? hourRangeCadence(schedule, minute, opts);
+}
+function isPinnedMinuteSeconds(schedule, plan) {
+  return plan.rest.kind === "clockTimes" && (schedule.shapes.second === "wildcard" || schedule.shapes.second === "step");
+}
+function renderComposeSeconds(schedule, plan, opts) {
+  const hourCad = composeHourCadence(schedule, plan, opts);
+  if (hourCad !== null) {
+    return hourCad;
+  }
+  if (isPinnedMinuteSeconds(schedule, plan)) {
+    return pinnedMinuteSeconds(schedule, plan.rest, opts);
+  }
+  if (plan.rest.kind === "clockTimes" && schedule.shapes.second === "list") {
+    return secondsListAtClock(schedule, plan.rest, opts);
+  }
+  if (plan.rest.kind === "hourRange" && schedule.shapes.second === "step" && schedule.pattern.weekday !== "*") {
+    const restNode = plan.rest;
+    const window = hourWindow(boundedWindow(restNode), opts);
+    const dayFrame = weekdayQualifier(schedule) + monthScope(schedule);
+    const cadence = "toutes les " + numero(stepSegment(schedule, "second").interval, opts) + " secondes de la minute " + schedule.pattern.minute;
+    return dayFrame + ", " + window + ", " + cadence;
+  }
+  if (isEveryOtherMinuteSeconds(schedule, plan)) {
+    return secondsLeadClause(schedule, opts) + " de " + render(schedule, plan.rest, opts).replace(/^toutes les /u, "chaque ");
+  }
+  const restOwnsLead = plan.rest.kind === "compactClockTimes" && schedule.analyses.clockSecond;
+  const lead = restOwnsLead ? "" : secondsLeadClause(schedule, opts) + ", ";
+  return lead + render(schedule, plan.rest, opts);
+}
+function isEveryOtherMinuteSeconds(schedule, plan) {
+  if (plan.rest.kind !== "minuteFrequency" || schedule.shapes.second !== "wildcard" || schedule.shapes.hour !== "wildcard") {
+    return false;
+  }
+  const minuteStep = stepSegment(schedule, "minute");
+  return minuteStep.startToken === "*" && minuteStep.interval === 2;
+}
+function pinnedMinuteSeconds(schedule, rest, opts) {
+  const dayTrail = leadingQualifier(schedule, opts).trimEnd();
+  const trail = dayTrail ? ", " + dayTrail : "";
+  if (+rest.times[0].minute === 0 && schedule.shapes.minute === "single") {
+    return secondsLeadClause(schedule, opts) + " pendant une minute " + durationHourList(rest.times, opts) + trail;
+  }
+  return secondsLeadClause(schedule, opts) + " de " + explicitClockList(rest.times, opts) + trail;
+}
+function secondsLeadClause(schedule, opts) {
+  return secondsClause(schedule, "minute", opts);
+}
+function secondsClause(schedule, anchor, opts) {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
+  if (secondField === "*") {
+    return "chaque seconde";
+  }
+  if (shape === "step") {
+    return stepCycle60(
+      stepSegment(schedule, "second"),
+      "seconde",
+      anchor,
+      opts
+    );
+  }
+  if (shape === "range") {
+    const bounds = secondField.split("-");
+    return "chaque seconde de " + bounds[0] + " \xE0 " + bounds[1] + " de chaque " + anchor;
+  }
+  if (shape === "single") {
+    return "\xE0 la seconde " + secondField + " de chaque " + anchor;
+  }
+  return strideFromSegments(
+    segmentsOf(schedule, "second"),
+    "seconde",
+    anchor,
+    opts
+  ) ?? "aux secondes " + joinList(segmentWords(segmentsOf(schedule, "second"))) + " de chaque " + anchor;
+}
+function renderEveryMinute(schedule, plan, opts) {
+  return "chaque minute" + trailingQualifier(schedule, opts);
+}
+function renderSingleMinute(schedule, plan, opts) {
+  return "\xE0 la minute " + schedule.pattern.minute + " de chaque heure" + trailingQualifier(schedule, opts);
+}
+function renderRangeOfMinutes(schedule, plan, opts) {
+  return minuteRangeLead(schedule.pattern.minute) + " de chaque heure" + trailingQualifier(schedule, opts);
+}
+function renderMultipleMinutes(schedule, plan, opts) {
+  return minutesList(schedule, opts) + trailingQualifier(schedule, opts);
+}
+function minutesList(schedule, opts) {
+  return strideFromSegments(
+    segmentsOf(schedule, "minute"),
+    "minute",
+    "heure",
+    opts
+  ) ?? "aux minutes " + joinList(segmentWords(segmentsOf(schedule, "minute"))) + " de chaque heure";
+}
+function minuteRangeLead(minuteField) {
+  const bounds = minuteField.split("-");
+  return "chaque minute de " + bounds[0] + " \xE0 " + bounds[1];
+}
+function singleHourStep(segments) {
+  return segments !== null && segments.length === 1 && segments[0].kind === "step";
+}
+function stepHourSpan(segment, opts) {
+  const bounded = segment.startToken.indexOf("-") !== -1;
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  if (segment.interval === 2 && !bounded && start <= 1) {
+    return start === 0 ? "pendant les heures paires" : "pendant les heures impaires";
+  }
+  return "pendant les heures " + hourSpanList(segment.fires, opts);
+}
+function hourSpanList(fires, opts) {
+  return "de " + joinList(fires.map(function each(hour) {
+    return clockNumeric(hour, 0, null, opts);
+  }));
+}
+function renderMinuteFrequency(schedule, plan, opts) {
+  let phrase = stepCycle60(
+    stepSegment(schedule, "minute"),
+    "minute",
+    "heure",
+    opts
+  );
+  if (plan.hours.kind === "during") {
+    const cadence = unevenHourCadence(schedule, opts);
+    if (cadence) {
+      phrase += ", " + cadence;
+    } else {
+      phrase += singleHourStep(schedule.analyses.segments.hour) ? ", " + stepHourSpan(stepSegment(schedule, "hour"), opts) : " " + hourSpanFromTimes(schedule, plan.hours.times, opts);
+    }
+  } else if (plan.hours.kind === "window") {
+    phrase += " " + hourWindow(plan.hours, opts);
+  } else if (plan.hours.kind === "step") {
+    phrase += ", " + stepHourSpan(stepSegment(schedule, "hour"), opts);
+  }
+  return phrase + trailingQualifier(schedule, opts);
+}
+function renderMinuteSpanInHour(schedule, plan, opts) {
+  if (schedule.pattern.minute === "*") {
+    return "chaque minute de l'heure " + fromTime(timePhrase(plan.hour, 0, null, opts)) + trailingQualifier(schedule, opts);
+  }
+  return "chaque minute " + timeRange(
+    { hour: plan.hour, minute: plan.span[0] },
+    { hour: plan.hour, minute: plan.span[1] },
+    opts
+  ) + trailingQualifier(schedule, opts);
+}
+function renderMinutesAcrossHours(schedule, plan, opts) {
+  const cadence = unevenHourCadence(schedule, opts);
+  if (plan.form === "wildcard") {
+    if (cadence !== null) {
+      return "chaque minute, " + cadence + trailingQualifier(schedule, opts);
+    }
+    if (singleHourStep(schedule.analyses.segments.hour)) {
+      return "chaque minute, " + stepHourSpan(stepSegment(schedule, "hour"), opts) + trailingQualifier(schedule, opts);
+    }
+    return "chaque minute " + hourSpanFromTimes(schedule, plan.times, opts) + trailingQualifier(schedule, opts);
+  }
+  const lead = plan.form === "range" ? minuteRangeLead(schedule.pattern.minute) : minutesList(schedule, opts);
+  if (cadence !== null) {
+    return lead + ", " + cadence + trailingQualifier(schedule, opts);
+  }
+  return lead + ", " + atHourTimes(schedule, plan.times, opts) + trailingQualifier(schedule, opts);
+}
+function renderMinuteSpanAcrossHourStep(schedule, plan, opts) {
+  const segment = stepSegment(schedule, "hour");
+  const cadence = unevenHourCadence(schedule, opts);
+  if (plan.form === "wildcard") {
+    return "chaque minute, " + stepHourSpan(segment, opts) + trailingQualifier(schedule, opts);
+  }
+  const lead = plan.form === "list" ? minutesList(schedule, opts) : minuteRangeLead(schedule.pattern.minute);
+  return lead + ", " + (cadence ?? stepHours(segment, opts)) + trailingQualifier(schedule, opts);
+}
+function renderEveryHour(schedule, plan, opts) {
+  return "chaque heure" + trailingQualifier(schedule, opts);
+}
+function renderHourRange(schedule, plan, opts) {
+  const window = hourWindow(boundedWindow(plan), opts);
+  if (plan.minuteForm === "wildcard") {
+    return "chaque minute " + window + trailingQualifier(schedule, opts);
+  }
+  if (plan.minuteForm === "range") {
+    return minuteRangeLead(schedule.pattern.minute) + ", " + window + trailingQualifier(schedule, opts);
+  }
+  if (schedule.pattern.minute === "0") {
+    return "chaque heure " + window + trailingQualifier(schedule, opts);
+  }
+  const lead = schedule.shapes.minute === "single" ? "\xE0 la minute " + schedule.pattern.minute + " de chaque heure" : minutesList(schedule, opts);
+  return lead + ", " + window + trailingQualifier(schedule, opts);
+}
+function renderHourStep(schedule, plan, opts) {
+  const cadence = unevenHourCadence(schedule, opts);
+  if (cadence !== null) {
+    return cadence + trailingQualifier(schedule, opts);
+  }
+  return stepHours(stepSegment(schedule, "hour"), opts) + trailingQualifier(schedule, opts);
+}
+function boundedWindow(plan) {
+  const last = plan.minuteForm === "wildcard" ? plan.boundMinute ?? 0 : 0;
+  return { from: plan.from, last, to: plan.to };
+}
+function hourWindow(window, opts) {
+  return timeRange(
+    { hour: window.from, minute: 0 },
+    { hour: window.to, minute: window.last },
+    opts
+  );
+}
+function isDateWeekdayUnion(schedule) {
+  return schedule.pattern.date !== "*" && schedule.pattern.weekday !== "*";
+}
+function unionMonthLeadFull(schedule) {
+  if (schedule.pattern.month === "*") {
+    return "";
+  }
+  const lead = monthPhrase(schedule, monthRanged(schedule) ? "de " : "en ");
+  const segments = flattenSteps(segmentsOf(schedule, "month"));
+  const isEnumeration = !monthRanged(schedule) && segments.length >= 2;
+  return isEnumeration ? lead + "," : lead;
+}
+function domArm(schedule, opts) {
+  const date = schedule.pattern.date;
+  const quartz = quartzDatePhrase(date);
+  if (quartz) {
+    return quartz;
+  }
+  const parity = parityDayPredicate(date);
+  if (parity) {
+    return parity;
+  }
+  if (isOpenStep(date)) {
+    return stepDates(date, opts);
+  }
+  const segments = segmentsOf(schedule, "date");
+  if (segments.length === 1 && segments[0].kind === "range") {
+    return "du " + dayOrdinal(segments[0].bounds[0]) + " au " + segments[0].bounds[1] + " du mois";
+  }
+  if (segments.length === 1 && segments[0].kind === "single") {
+    return schedule.pattern.month === "*" ? "le " + dayOrdinal(segments[0].value) + " de chaque mois" : "le " + dayOrdinal(segments[0].value);
+  }
+  return joinList(dateWords(segments)) + " du mois";
+}
+function dowArm(schedule) {
+  const quartz = quartzWeekdayPhrase(schedule.pattern.weekday);
+  if (quartz) {
+    return quartz;
+  }
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, "weekday"));
+  const allSingles = segments.every(function single(segment) {
+    return segment.kind === "single";
+  });
+  if (allSingles && segments.length === 1) {
+    return "n'importe quel " + weekdayName(segments[0].value);
+  }
+  if (allSingles) {
+    return recurringWeekdayList(segments);
+  }
+  if (segments.length === 1) {
+    return "n'importe quel jour " + weekdayRange(segments[0]);
+  }
+  return mixedWeekdayList(segments);
+}
+function unionSoitSuffix(schedule, opts) {
+  return ", soit " + domArm(schedule, opts) + ", soit " + dowArm(schedule);
+}
+function renderClockTimes(schedule, plan, opts) {
+  if (schedule.shapes.minute === "single") {
+    const minute = +schedule.pattern.minute;
+    const cadence = hourCadence(schedule, minute, opts) ?? hourRangeCadence(schedule, minute, opts);
+    if (cadence !== null) {
+      return cadence;
+    }
+  }
+  const phrases = plan.times.map(function clock(time) {
+    return atTime(timePhrase(time.hour, time.minute, time.second, opts));
+  });
+  return leadingQualifier(schedule, opts) + groupClockTimes(phrases);
+}
+function explicitClockList(times, opts) {
+  const phrases = times.map(function clock(time) {
+    return atTime(explicitTimePhrase(time.hour, time.minute, opts));
+  });
+  const grouped = groupClockTimes(phrases);
+  return grouped.startsWith("\xE0 ") ? grouped.slice(2) : grouped;
+}
+function durationHourList(times, opts) {
+  const phrases = times.map(function clock(time) {
+    return atTime(barePoint(time.hour, opts));
+  });
+  return groupClockTimes(phrases);
+}
+function explicitTimePhrase(hour, minute, opts) {
+  return clockNumeric(hour, minute, null, opts);
+}
+function groupClockTimes(phrases) {
+  if (phrases.length < 2) {
+    return joinList(phrases);
+  }
+  return groupClockTimesByArticle(phrases);
+}
+function groupClockTimesByArticle(phrases) {
+  const prefix = "\xE0 ";
+  const oneOclock = [];
+  const rest = [];
+  for (const phrase of phrases) {
+    if (!phrase.startsWith(prefix)) {
+      return joinList(phrases);
+    }
+    const raw = phrase.slice(prefix.length);
+    const value = phrases.length > 1 && raw === "midi" ? "12 h" : raw;
+    if (/^1( |h)/u.test(value)) {
+      oneOclock.push(value);
+    } else {
+      rest.push(value);
+    }
+  }
+  return prefix + joinList([...oneOclock, ...rest]);
+}
+function renderCompactClockTimes(schedule, plan, opts) {
+  if (plan.fold) {
+    const cadence2 = hourCadence(schedule, plan.minute, opts) ?? hourRangeCadence(schedule, plan.minute, opts);
+    if (cadence2 !== null) {
+      return cadence2;
+    }
+    const ranged = segmentsOf(schedule, "hour").some(function range(segment) {
+      return segment.kind === "range";
+    });
+    if (ranged && !schedule.analyses.clockSecond) {
+      return "chaque heure " + hourSegmentTimes(
+        schedule,
+        plan.minute,
+        schedule.analyses.clockSecond,
+        opts
+      ) + trailingQualifier(schedule, opts);
+    }
+    return leadingQualifier(schedule, opts) + hourSegmentTimes(
+      schedule,
+      plan.minute,
+      schedule.analyses.clockSecond,
+      opts
+    );
+  }
+  const cadence = unevenHourCadence(schedule, opts);
+  const phrase = cadence ? minutesList(schedule, opts) + ", " + cadence + trailingQualifier(schedule, opts) : minutesList(schedule, opts) + ", " + hourContextTimes(schedule, opts) + trailingQualifier(schedule, opts);
+  return schedule.analyses.clockSecond ? secondsLeadClause(schedule, opts) + ", " + phrase : phrase;
+}
+var renderers = {
+  clockTimes: renderClockTimes,
+  compactClockTimes: renderCompactClockTimes,
+  composeSeconds: renderComposeSeconds,
+  everyHour: renderEveryHour,
+  everyMinute: renderEveryMinute,
+  everySecond: renderEverySecond,
+  hourRange: renderHourRange,
+  hourStep: renderHourStep,
+  minuteFrequency: renderMinuteFrequency,
+  minuteSpanAcrossHourStep: renderMinuteSpanAcrossHourStep,
+  minuteSpanInHour: renderMinuteSpanInHour,
+  minutesAcrossHours: renderMinutesAcrossHours,
+  multipleMinutes: renderMultipleMinutes,
+  rangeOfMinutes: renderRangeOfMinutes,
+  secondPastMinute: renderSecondPastMinute,
+  secondsWithinMinute: renderSecondsWithinMinute,
+  singleMinute: renderSingleMinute,
+  standaloneSeconds: renderStandaloneSeconds
+};
+function renderStride2(stride, opts) {
+  const { interval, start, last, cycle, unit, anchor } = stride;
+  const cadence = "toutes les " + numero(interval, opts) + " " + unit + "s";
+  const tail = anchor ? " de chaque " + anchor : "";
+  return renderStride({ start, interval, last, cycle }, {
+    bare: () => cadence,
+    offset: () => cadence + " \xE0 partir de la " + unit + " " + start + tail,
+    bounded: () => cadence + " de la " + unit + " " + start + " \xE0 " + last + tail
+  });
+}
+function stepCycle60(segment, unit, anchor, opts) {
+  if (segment.startToken.indexOf("-") !== -1) {
+    return "aux " + unit + "s " + joinList(wordList(segment.fires)) + " de chaque " + anchor;
+  }
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  if (start !== 0 && segment.fires.length <= 3) {
+    return "aux " + unit + "s " + joinList(wordList(segment.fires)) + " de chaque " + anchor;
+  }
+  return renderStride2({
+    interval: segment.interval,
+    start,
+    last: segment.fires[segment.fires.length - 1],
+    cycle: 60,
+    unit,
+    anchor
+  }, opts);
+}
+function strideFromSegments(segments, unit, anchor, opts) {
+  const values = singleValues(segments);
+  const step = values && arithmeticStep(values);
+  return step ? renderStride2({ ...step, cycle: 60, unit, anchor }, opts) : null;
+}
+function stepHours(segment, opts) {
+  if (segment.startToken.indexOf("-") !== -1) {
+    return groupClockTimesByArticle(atTimes(segment.fires, opts));
+  }
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  const interval = segment.interval;
+  if (start === 0) {
+    return "toutes les " + numero(interval, opts) + " heures";
+  }
+  if (segment.fires.length <= 3) {
+    return groupClockTimesByArticle(atTimes(segment.fires, opts));
+  }
+  return "toutes les " + numero(interval, opts) + " heures \xE0 partir de " + timePhrase(start, 0, null, opts);
+}
+function hourStrideCadence(stride, opts) {
+  const { start, interval, last } = stride;
+  const cadence = "toutes les " + numero(interval, opts) + " heures";
+  return renderStride({ start, interval, last, cycle: 24 }, {
+    bare: () => cadence,
+    offset: () => cadence + " \xE0 partir de " + timePhrase(start, 0, null, opts),
+    bounded: () => cadence + " " + fromTime(timePhrase(start, 0, null, opts)) + " " + toTime(timePhrase(last, 0, null, opts))
+  });
+}
+function unevenHourCadence(schedule, opts) {
+  const stride = hourStride(schedule);
+  if (!stride || offsetCleanStride(stride)) {
+    return null;
+  }
+  return hourStrideCadence(stride, opts);
+}
+function hourStride(schedule) {
+  const segments = segmentsOf(schedule, "hour");
+  if (segments.length === 1 && segments[0].kind === "step") {
+    const segment = segments[0];
+    if (segment.fires.length < 2) {
+      return null;
+    }
+    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);
+  return values && hourListStride(values);
+}
+function subMinuteSecond(schedule) {
+  return schedule.pattern.second === "*" || schedule.shapes.second === "step";
+}
+function hourCadenceLead(schedule, minute, opts) {
+  if (minute === 0) {
+    if (subMinuteSecond(schedule)) {
+      return secondsClause(schedule, "minute", opts) + " pendant une minute";
+    }
+    return secondsClause(schedule, "heure", opts);
+  }
+  const minutePhrase = "\xE0 la minute " + minute;
+  if (schedule.pattern.second === "0") {
+    return minutePhrase;
+  }
+  return secondsClause(schedule, "minute", opts) + ", " + minutePhrase;
+}
+function hourCadence(schedule, minute, opts) {
+  const stride = hourStride(schedule);
+  if (!stride) {
+    return null;
+  }
+  const fires = (stride.last - stride.start) / stride.interval + 1;
+  if (schedule.pattern.second === "0" && fires <= maxClockTimes && offsetCleanStride(stride)) {
+    return null;
+  }
+  const confinement = minute === 0 && subMinuteSecond(schedule) && cleanStrideSegment(schedule);
+  if (confinement) {
+    return secondsClause(schedule, "minute", opts) + " pendant une minute, " + stepHourSpan(confinement, opts) + trailingQualifier(schedule, opts);
+  }
+  if (minute === 0 && schedule.pattern.second === "0") {
+    return hourStrideCadence(stride, opts) + trailingQualifier(schedule, opts);
+  }
+  return hourCadenceLead(schedule, minute, opts) + ", " + hourStrideCadence(stride, opts) + trailingQualifier(schedule, opts);
+}
+function cleanStrideSegment(schedule) {
+  const segments = segmentsOf(schedule, "hour");
+  const segment = segments.length === 1 && segments[0];
+  if (!segment || segment.kind !== "step" || segment.startToken.indexOf("-") !== -1) {
+    return null;
+  }
+  return segment;
+}
+function hasHourWindow(schedule) {
+  return segmentsOf(schedule, "hour").some(function range(segment) {
+    return segment.kind === "range";
+  });
+}
+function hourRangeCadence(schedule, minute, opts) {
+  if (minute !== 0 || !hasHourWindow(schedule) || schedule.pattern.second === "0") {
+    return null;
+  }
+  if (subMinuteSecond(schedule)) {
+    return secondsClause(schedule, "minute", opts) + " pendant une minute, pendant les heures " + hourSegmentTimes(schedule, 0, null, opts) + trailingQualifier(schedule, opts);
+  }
+  return hourCadenceLead(schedule, minute, opts) + ", " + hourSegmentTimes(schedule, 0, null, opts) + trailingQualifier(schedule, opts);
+}
+function hourContextTimes(schedule, opts) {
+  const segments = segmentsOf(schedule, "hour");
+  const points = [];
+  const hasRange = segments.some(function range(segment) {
+    return segment.kind === "range";
+  });
+  segments.forEach(function collect(segment) {
+    if (segment.kind === "step") {
+      points.push(...segment.fires);
+    } else if (segment.kind === "single") {
+      points.push(+segment.value);
+    }
+  });
+  function isWord(hour) {
+    return hour === 0 || hour === 12;
+  }
+  if (!hasRange && points.every(isWord)) {
+    return joinList(points.map(function each(hour) {
+      return atTime(barePoint(hour, opts));
+    }));
+  }
+  function wholeHour(hour) {
+    return "de l'heure " + fromTime(barePoint(hour, opts));
+  }
+  const pieces = [];
+  segments.forEach(function place(segment) {
+    if (segment.kind === "range") {
+      pieces.push(timeRange(
+        { hour: +segment.bounds[0], minute: 0 },
+        { hour: +segment.bounds[1], minute: 0 },
+        opts
+      ));
+    } else if (segment.kind === "step") {
+      segment.fires.forEach(function each(hour) {
+        pieces.push(wholeHour(hour));
+      });
+    } else {
+      pieces.push(wholeHour(+segment.value));
+    }
+  });
+  return joinList(pieces);
+}
+function atTimes(hours, opts) {
+  return hours.map(function each(hour) {
+    return atTime(timePhrase(hour, 0, null, opts));
+  });
+}
+function atHourTimes(schedule, times, opts) {
+  if (times.kind === "fires") {
+    return groupClockTimesByArticle(atTimes(times.fires, opts));
+  }
+  return hourSegmentTimes(schedule, 0, null, opts);
+}
+function hourSpanFromTimes(schedule, times, opts) {
+  if (times.kind === "fires" && times.fires.length > 3) {
+    return "pendant les heures " + hourSpanList(times.fires, opts);
+  }
+  return hourWindowsFromTimes(schedule, times, opts);
+}
+function hourWindowsFromTimes(schedule, times, opts) {
+  if (times.kind === "fires") {
+    return joinList(times.fires.map(function window(hour) {
+      return hourAsWindow(hour, opts);
+    }));
+  }
+  return joinList(segmentsOf(schedule, "hour").map(function window(segment) {
+    if (segment.kind === "range") {
+      return timeRange(
+        { hour: +segment.bounds[0], minute: 0 },
+        { hour: +segment.bounds[1], minute: 59 },
+        opts
+      );
+    }
+    if (segment.kind === "step") {
+      return joinList(segment.fires.map(function each(hour) {
+        return hourAsWindow(hour, opts);
+      }));
+    }
+    return hourAsWindow(+segment.value, opts);
+  }));
+}
+function hourSegmentTimes(schedule, minute, second, opts) {
+  const pieces = [];
+  const fromRange = [];
+  segmentsOf(schedule, "hour").forEach(function clock(segment) {
+    if (segment.kind === "step") {
+      segment.fires.forEach(function each(hour) {
+        pieces.push(atTime(timePhrase(hour, minute, second, opts)));
+        fromRange.push(false);
+      });
+    } else if (segment.kind === "range") {
+      pieces.push(timeRange(
+        { hour: +segment.bounds[0], minute, second },
+        { hour: +segment.bounds[1], minute, second },
+        opts
+      ));
+      fromRange.push(true);
+    } else {
+      pieces.push(atTime(timePhrase(+segment.value, minute, second, opts)));
+      fromRange.push(false);
+    }
+  });
+  const lastIdx = pieces.length - 1;
+  const hasRange = fromRange.some(function ranged(r) {
+    return r;
+  });
+  const lastIsPoint = lastIdx >= 1 && !fromRange[lastIdx] && fromRange[lastIdx - 1];
+  if (hasRange && lastIsPoint) {
+    return joinList(pieces.slice(0, lastIdx)) + " et aussi " + pieces[lastIdx];
+  }
+  return groupClockTimesByArticle(pieces);
+}
+function timeRange(from, to, opts) {
+  if (from.hour === to.hour) {
+    return fromTime(clockNumeric(from.hour, from.minute, from.second, opts)) + " " + toTime(clockNumeric(to.hour, to.minute, to.second, opts));
+  }
+  const fromPhrase = timePhrase(from.hour, from.minute, from.second, opts);
+  const toPhrase = timePhrase(to.hour, to.minute, to.second, opts);
+  return fromTime(fromPhrase) + " " + toTime(toPhrase);
+}
+function hourAsWindow(hour, opts) {
+  return timeRange({ hour, minute: 0 }, { hour, minute: 59 }, opts);
+}
+function atTime(phrase) {
+  return "\xE0 " + phrase;
+}
+function fromTime(phrase) {
+  return "de " + phrase;
+}
+function toTime(phrase) {
+  return atTime(phrase);
+}
+function timePhrase(hour, minute, second, opts) {
+  const showSeconds = typeof second === "number" && second > 0 ? second : 0;
+  if (!showSeconds && +minute === 0) {
+    if (+hour === 0) {
+      return "minuit";
+    }
+    if (+hour === 12) {
+      return "midi";
+    }
+  }
+  return clockNumeric(hour, minute, showSeconds, opts);
+}
+function barePoint(hour, opts) {
+  if (+hour === 0) {
+    return "minuit";
+  }
+  if (+hour === 12) {
+    return "midi";
+  }
+  return clockNumeric(hour, 0, null, opts);
+}
+function clockNumeric(hour, minute, second, opts) {
+  const showSeconds = typeof second === "number" && second > 0 ? second : 0;
+  if (opts.style.sep !== "h") {
+    const base = hour + opts.style.sep + pad(minute);
+    return showSeconds ? base + opts.style.sep + pad(showSeconds) : base;
+  }
+  const space = opts.style.unspaced ? "" : " ";
+  const hourPart = hour + space + "h";
+  if (showSeconds) {
+    const minutePart = minute ? space + minute + space + "min" : "";
+    return hourPart + minutePart + space + showSeconds + space + "s";
+  }
+  return minute ? hourPart + space + minute : hourPart;
+}
+function leadingQualifier(schedule, opts) {
+  const pattern = schedule.pattern;
+  if (pattern.date !== "*" && pattern.weekday !== "*") {
+    return "";
+  }
+  if (pattern.date !== "*") {
+    return datePhrase(schedule, opts) + " ";
+  }
+  if (pattern.weekday !== "*") {
+    return weekdayQualifier(schedule) + monthScope(schedule) + " ";
+  }
+  if (pattern.month !== "*") {
+    return "tous les jours " + monthPhrase(schedule, "de ") + " ";
+  }
+  return "tous les jours ";
+}
+function trailingQualifier(schedule, opts) {
+  const pattern = schedule.pattern;
+  if (pattern.date !== "*" && pattern.weekday !== "*") {
+    return "";
+  }
+  if (pattern.date !== "*") {
+    return " " + datePhrase(schedule, opts);
+  }
+  if (pattern.weekday !== "*") {
+    return " " + weekdayQualifier(schedule) + monthScope(schedule);
+  }
+  if (pattern.month !== "*") {
+    return " " + monthPhrase(schedule, "en ");
+  }
+  return "";
+}
+function datePhrase(schedule, opts) {
+  const pattern = schedule.pattern;
+  if (quartzDatePhrase(pattern.date) || isOpenStep(pattern.date)) {
+    return dateClause(schedule, "", opts) + monthScope(schedule);
+  }
+  return dateClause(schedule, dateMonthPart(schedule), opts);
+}
+function dateClause(schedule, monthPart, opts) {
+  const pattern = schedule.pattern;
+  const quartz = quartzDatePhrase(pattern.date);
+  if (quartz) {
+    return quartz;
+  }
+  if (isOpenStep(pattern.date)) {
+    return stepDates(pattern.date, opts);
+  }
+  const segments = segmentsOf(schedule, "date");
+  if (segments.length === 1 && segments[0].kind === "range") {
+    return "du " + dayOrdinal(segments[0].bounds[0]) + " au " + segments[0].bounds[1] + monthPart + foldedYear(schedule);
+  }
+  if (segments.length === 1 && segments[0].kind === "single") {
+    return "le " + dayOrdinal(segments[0].value) + monthPart + foldedYear(schedule);
+  }
+  return joinList(dateWords(segments)) + monthPart + foldedYear(schedule);
+}
+function monthRanged(schedule) {
+  return schedule.pattern.month !== "*" && segmentsOf(schedule, "month").some(function range(segment) {
+    return segment.kind === "range";
+  });
+}
+function dateMonthPart(schedule) {
+  if (schedule.pattern.month === "*") {
+    return " de chaque mois";
+  }
+  if (monthRanged(schedule)) {
+    return " de chaque mois, " + monthPhrase(schedule, "de ");
+  }
+  return " " + monthPhrase(schedule, "");
+}
+function foldedYear(schedule) {
+  const yearField = schedule.pattern.year;
+  if (yearField === "*" || yearField.indexOf("/") !== -1 || yearField.indexOf("-") !== -1 || yearField.indexOf(",") !== -1) {
+    return "";
+  }
+  return " " + yearField;
+}
+function quartzDatePhrase(dateField) {
+  if (dateField === "L") {
+    return "le dernier jour du mois";
+  }
+  if (dateField === "LW" || dateField === "WL") {
+    return "le dernier jour ouvrable du mois";
+  }
+  const offset = /^L-(\d{1,2})$/.exec(dateField);
+  if (offset) {
+    return +offset[1] === 1 ? "un jour avant le dernier jour du mois" : offset[1] + " jours avant le dernier jour du mois";
+  }
+  const nearest = /^(\d{1,2})W$|^W(\d{1,2})$/.exec(dateField);
+  if (nearest) {
+    return "le jour ouvrable le plus proche du " + (nearest[1] || nearest[2]);
+  }
+}
+function quartzWeekdayPhrase(weekdayField) {
+  const parts = weekdayField.split("#");
+  if (parts.length === 2) {
+    return "le " + nthWeekdayMasculine[+parts[1]] + " " + weekdayName(parts[0]) + " du mois";
+  }
+  if (/L$/.test(weekdayField)) {
+    return "le dernier " + weekdayName(weekdayField.slice(0, -1)) + " du mois";
+  }
+}
+function weekdayQualifier(schedule) {
+  const quartz = quartzWeekdayPhrase(schedule.pattern.weekday);
+  if (quartz) {
+    return quartz;
+  }
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, "weekday"));
+  const allSingles = segments.every(function single(segment) {
+    return segment.kind === "single";
+  });
+  if (allSingles) {
+    return recurringWeekdayList(segments);
+  }
+  if (segments.length === 1) {
+    return weekdayRange(segments[0]);
+  }
+  return mixedWeekdayList(segments);
+}
+function recurringWeekdayList(segments) {
+  return joinList(segments.map(function name(segment) {
+    return "le " + weekdayName(segment.value);
+  }));
+}
+function mixedWeekdayList(segments) {
+  return joinList(segments.map(function name(segment) {
+    return segment.kind === "range" ? weekdayRange(segment) : "le " + weekdayName(segment.value);
+  }));
+}
+function weekdayRange(segment) {
+  return "du " + weekdayName(segment.bounds[0]) + " au " + weekdayName(segment.bounds[1]);
+}
+function flattenSteps(segments) {
+  return segments.flatMap(function flat(segment) {
+    return segment.kind === "step" ? segment.fires.map(function single(value) {
+      return { kind: "single", value };
+    }) : [segment];
+  });
+}
+function monthPhrase(schedule, lead) {
+  const segments = flattenSteps(segmentsOf(schedule, "month"));
+  const ranged = segments.some(function range(segment) {
+    return segment.kind === "range";
+  });
+  if (!ranged) {
+    return lead + joinList(segments.map(function name(segment) {
+      return monthName(segment.value);
+    }));
+  }
+  return joinList(segments.map(function name(segment) {
+    if (segment.kind === "range") {
+      return "de " + monthName(segment.bounds[0]) + " \xE0 " + monthName(segment.bounds[1]);
+    }
+    return lead + monthName(segment.value);
+  }));
+}
+function monthScope(schedule) {
+  if (schedule.pattern.month === "*") {
+    return "";
+  }
+  return (monthRanged(schedule) ? ", " : " ") + monthPhrase(schedule, "de ");
+}
+function parityDayPredicate(dateField) {
+  if (!isOpenStep(dateField)) {
+    return;
+  }
+  const [start, step] = dateField.split("/");
+  if (+step !== 2) {
+    return;
+  }
+  if (start === "*" || start === "1") {
+    return "un jour impair du mois";
+  }
+  if (start === "2") {
+    return "un jour pair du mois";
+  }
+}
+function stepDates(dateField, opts) {
+  const parts = dateField.split("/");
+  let phrase = "tous les " + numero(+parts[1], opts) + " jours du mois";
+  if (parts[0] !== "*" && parts[0] !== "1") {
+    phrase += " \xE0 partir du " + parts[0];
+  }
+  return phrase;
+}
+function applyYear(description, schedule, opts) {
+  const yearField = schedule.pattern.year;
+  if (yearField === "*") {
+    return description;
+  }
+  if (yearField.indexOf("/") !== -1) {
+    return description + " " + stepYears(yearField, opts);
+  }
+  if (foldedYear(schedule) && schedule.pattern.date !== "*") {
+    return description;
+  }
+  if (yearField.indexOf(",") !== -1) {
+    return description + " en " + joinList(yearField.split(","));
+  }
+  return description + " en " + yearField;
+}
+function stepYears(yearField, opts) {
+  const parts = yearField.split("/");
+  const interval = +parts[1];
+  if (interval <= 1) {
+    return "chaque ann\xE9e";
+  }
+  let phrase = "tous les " + numero(interval, opts) + " ans";
+  if (parts[0] !== "*" && parts[0] !== "0") {
+    phrase += " \xE0 partir de " + parts[0];
+  }
+  return phrase;
+}
+function segmentWords(segments) {
+  return segments.flatMap(function word(segment) {
+    if (segment.kind === "range") {
+      return [segment.bounds[0] + " \xE0 " + segment.bounds[1]];
+    }
+    if (segment.kind === "step") {
+      return wordList(segment.fires);
+    }
+    return [segment.value];
+  });
+}
+function dateWords(segments) {
+  return segments.flatMap(function word(segment) {
+    if (segment.kind === "range") {
+      return ["du " + dayOrdinal(segment.bounds[0]) + " au " + segment.bounds[1]];
+    }
+    if (segment.kind === "step") {
+      return segment.fires.map(function fire(value) {
+        return "le " + dayOrdinal(value);
+      });
+    }
+    return ["le " + dayOrdinal(segment.value)];
+  });
+}
+function dayOrdinal(value) {
+  return +value === 1 ? "1er" : "" + value;
+}
+function wordList(fires) {
+  return fires.map(function digit(value) {
+    return "" + value;
+  });
+}
+function joinList(items) {
+  if (items.length <= 1) {
+    return items.join("");
+  }
+  if (items.length === 2) {
+    return items[0] + " et " + items[1];
+  }
+  return items.slice(0, -1).join(", ") + " et " + items[items.length - 1];
+}
+function numero(n, opts) {
+  return numeral(n, numeros, opts);
+}
+function weekdayName(token) {
+  const number = toFieldNumber("" + token, weekdayNumbers);
+  return weekdayNames[number === 7 ? 0 : number];
+}
+function monthName(token) {
+  return monthNames[+token];
+}
+var fr2 = {
+  describe,
+  fallback: "un motif cron non reconnu",
+  options: normalizeOptions,
+  reboot: "au d\xE9marrage du syst\xE8me",
+  // A description ending in a period already carries it, so closing the
+  // sentence must not double it.
+  sentence: (description) => "S'ex\xE9cute " + description + (description.endsWith(".") ? "" : ".")
+};
+var index_default = fr2;
+module.exports = module.exports.default;