cronli5 0.3.1 → 0.7.2

package/dist/lang/pt.cjs

@@ -0,0 +1,1591 @@
+"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/pt/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;
+}
+function clockDigits(time, { sep, pad: padHour, lean }) {
+  const head = padHour ? pad(time.hour) : "" + time.hour;
+  if (lean && !time.minute && !time.second) {
+    return head;
+  }
+  return head + sep + pad(time.minute) + (time.second ? sep + pad(time.second) : "");
+}
+
+// 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/pt/dialects.ts
+var pt = {
+  ampm: false,
+  hSuffix: false,
+  meridiem: "descriptors",
+  sep: ":"
+};
+var dialects = {
+  pt,
+  // Brazil is the default; named explicitly so it is a recognized choice and
+  // has a home if it ever diverges.
+  "pt-BR": pt
+};
+function resolveDialect(dialect) {
+  if (typeof dialect === "object" && dialect !== null) {
+    return { ...dialects.pt, ...dialect };
+  }
+  return dialects[dialect] || dialects.pt;
+}
+
+// src/lang/pt/index.ts
+var numeros = [
+  "zero",
+  "um",
+  "dois",
+  "tr\xEAs",
+  "quatro",
+  "cinco",
+  "seis",
+  "sete",
+  "oito",
+  "nove",
+  "dez"
+];
+var monthNames = [
+  null,
+  "janeiro",
+  "fevereiro",
+  "mar\xE7o",
+  "abril",
+  "maio",
+  "junho",
+  "julho",
+  "agosto",
+  "setembro",
+  "outubro",
+  "novembro",
+  "dezembro"
+];
+var weekdayNames = [
+  "domingo",
+  "segunda-feira",
+  "ter\xE7a-feira",
+  "quarta-feira",
+  "quinta-feira",
+  "sexta-feira",
+  "s\xE1bado"
+];
+var weekdayStems = [
+  "domingo",
+  "segunda",
+  "ter\xE7a",
+  "quarta",
+  "quinta",
+  "sexta",
+  "s\xE1bado"
+];
+function weekdayFeminine(number) {
+  return number !== 0 && number !== 6;
+}
+var nthWeekdayMasculine = [null, "primeiro", "segundo", "terceiro", "quarto", "quinto"];
+var nthWeekdayFeminine = [null, "primeira", "segunda", "terceira", "quarta", "quinta"];
+function noonMidnightArticle(phrase) {
+  if (phrase === "meio-dia") {
+    return "o";
+  }
+  if (phrase === "meia-noite") {
+    return "a";
+  }
+  return null;
+}
+function withA(phrase) {
+  const word = noonMidnightArticle(phrase);
+  if (word) {
+    return (word === "o" ? "ao " : "\xE0 ") + phrase;
+  }
+  if (phrase.startsWith("as ")) {
+    return "\xE0s " + phrase.slice(3);
+  }
+  if (phrase.startsWith("a ")) {
+    return "\xE0 " + phrase.slice(2);
+  }
+  if (phrase.startsWith("os ")) {
+    return "aos " + phrase.slice(3);
+  }
+  if (phrase.startsWith("o ")) {
+    return "ao " + phrase.slice(2);
+  }
+  return "a " + phrase;
+}
+function withDe(phrase) {
+  const word = noonMidnightArticle(phrase);
+  if (word) {
+    return (word === "o" ? "do " : "da ") + phrase;
+  }
+  if (phrase.startsWith("as ")) {
+    return "das " + phrase.slice(3);
+  }
+  if (phrase.startsWith("a ")) {
+    return "da " + phrase.slice(2);
+  }
+  if (phrase.startsWith("os ")) {
+    return "dos " + phrase.slice(3);
+  }
+  if (phrase.startsWith("o ")) {
+    return "do " + phrase.slice(2);
+  }
+  return "de " + phrase;
+}
+function hasLeadingArticle(phrase) {
+  return noonMidnightArticle(phrase) !== null || phrase.startsWith("a ") || phrase.startsWith("as ") || phrase.startsWith("o ") || phrase.startsWith("os ");
+}
+function withEm(phrase) {
+  if (phrase.startsWith("as ")) {
+    return "nas " + phrase.slice(3);
+  }
+  if (phrase.startsWith("a ")) {
+    return "na " + phrase.slice(2);
+  }
+  if (phrase.startsWith("os ")) {
+    return "nos " + phrase.slice(3);
+  }
+  if (phrase.startsWith("o ")) {
+    return "no " + phrase.slice(2);
+  }
+  return "em " + phrase;
+}
+function normalizeOptions(options) {
+  options = options || {};
+  const style = resolveDialect(options.dialect);
+  return {
+    // The clock default comes from the dialect (24-hour for pt-BR); an explicit
+    // `{ampm}` option overrides it.
+    ampm: typeof options.ampm === "boolean" ? options.ampm : style.ampm,
+    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 + unionSejaSuffix(schedule, opts);
+}
+function renderEverySecond(schedule, plan, opts) {
+  return "a cada segundo" + trailingQualifier(schedule, opts);
+}
+function renderStandaloneSeconds(schedule, plan, opts) {
+  return secondsLeadClause(schedule, opts) + trailingQualifier(schedule, opts);
+}
+function renderSecondPastMinute(schedule, plan, opts) {
+  return "no segundo " + schedule.pattern.second + " de cada minuto" + trailingQualifier(schedule, opts);
+}
+function renderSecondsWithinMinute(schedule, plan, opts) {
+  const minuteField = schedule.pattern.minute;
+  if (plan.singleSecond) {
+    return "no minuto " + minuteField + " e no segundo " + schedule.pattern.second + " de cada hora" + trailingQualifier(schedule, opts);
+  }
+  return secondsLeadClause(schedule, opts) + ", no minuto " + minuteField + " de cada hora" + trailingQualifier(schedule, opts);
+}
+function secondsListAtClock(schedule, rest, opts) {
+  const clockPhrases = rest.times.map(function clock(time) {
+    return atTime(timePhrase(time.hour, time.minute, null, opts));
+  });
+  const grouped = groupClockTimesByArticle(clockPhrases);
+  const clockList = degenitive(grouped);
+  const stride = strideFromSegments(segmentsOf(schedule, "second"), "segundo", "", opts);
+  const secondsPhrase = stride ?? "nos segundos " + joinList(segmentWords(segmentsOf(schedule, "second")));
+  const dayFrame = trailingQualifier(schedule, opts);
+  return (dayFrame ? dayFrame.trimStart() + ", " : "") + secondsPhrase + " " + 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 = "a cada " + numero(stepSegment(schedule, "second").interval, opts) + " segundos do minuto " + schedule.pattern.minute;
+    return dayFrame + ", " + window + ", " + cadence;
+  }
+  if (isEveryOtherMinuteSeconds(schedule, plan)) {
+    const rest = render(schedule, plan.rest, opts).replace(/^a /u, "");
+    return secondsLeadClause(schedule, opts) + " de " + rest;
+  }
+  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 = trailingDayClause(schedule, opts);
+  const trail = dayTrail ? ", " + dayTrail : "";
+  if (+rest.times[0].minute === 0 && schedule.shapes.minute === "single") {
+    return secondsLeadClause(schedule, opts) + " durante um minuto " + durationHourList(rest.times, opts) + trail;
+  }
+  return secondsLeadClause(schedule, opts) + " " + explicitClockList(rest.times, opts) + trail;
+}
+function secondsLeadClause(schedule, opts) {
+  return secondsClause(schedule, "minuto", opts);
+}
+function secondsClause(schedule, anchor, opts) {
+  const secondField = schedule.pattern.second;
+  const shape = schedule.shapes.second;
+  if (secondField === "*") {
+    return "a cada segundo";
+  }
+  if (shape === "step") {
+    return stepCycle60(
+      stepSegment(schedule, "second"),
+      "segundo",
+      anchor,
+      opts
+    );
+  }
+  if (shape === "range") {
+    const bounds = secondField.split("-");
+    return "a cada segundo do " + bounds[0] + " ao " + bounds[1] + " de cada " + anchor;
+  }
+  if (shape === "single") {
+    return "no segundo " + secondField + " de cada " + anchor;
+  }
+  return strideFromSegments(
+    segmentsOf(schedule, "second"),
+    "segundo",
+    anchor,
+    opts
+  ) ?? "nos segundos " + joinList(segmentWords(segmentsOf(schedule, "second"))) + " de cada " + anchor;
+}
+function renderEveryMinute(schedule, plan, opts) {
+  return "a cada minuto" + trailingQualifier(schedule, opts);
+}
+function renderSingleMinute(schedule, plan, opts) {
+  return "no minuto " + schedule.pattern.minute + " de cada hora" + trailingQualifier(schedule, opts);
+}
+function renderRangeOfMinutes(schedule, plan, opts) {
+  return minuteRangeLead(schedule.pattern.minute) + " de cada hora" + trailingQualifier(schedule, opts);
+}
+function renderMultipleMinutes(schedule, plan, opts) {
+  return minutesList(schedule, opts) + trailingQualifier(schedule, opts);
+}
+function minutesList(schedule, opts) {
+  return strideFromSegments(
+    segmentsOf(schedule, "minute"),
+    "minuto",
+    "hora",
+    opts
+  ) ?? "nos minutos " + joinList(segmentWords(segmentsOf(schedule, "minute"))) + " de cada hora";
+}
+function minuteRangeLead(minuteField) {
+  const bounds = minuteField.split("-");
+  return "a cada minuto do " + bounds[0] + " ao " + 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 ? "durante as horas pares" : "durante as horas \xEDmpares";
+  }
+  return "durante as horas " + hourSpanList(segment.fires, opts);
+}
+function hourSpanList(fires, opts) {
+  if (!opts.ampm) {
+    return "das " + joinList(fires.map(String));
+  }
+  return joinList(hourPeriodGroups(fires, opts));
+}
+function hourPeriod(hour, opts) {
+  return opts.style.meridiem === "english" ? meridiemMark(hour) : dayPeriod(hour, opts);
+}
+function hourPeriodGroups(fires, opts) {
+  const groups = [];
+  fires.forEach(function place(hour) {
+    const period = hour === 0 || hour === 12 ? "" : hourPeriod(hour, opts);
+    const last = groups[groups.length - 1];
+    if (period !== "" && last && last.period === period) {
+      last.hours.push(hour);
+    } else {
+      groups.push({ hours: [hour], period });
+    }
+  });
+  return groups.map(function phrase(group) {
+    if (group.period === "") {
+      return fromTime(timePhrase(group.hours[0], 0, null, opts));
+    }
+    return spanHours(group.hours) + " " + group.period;
+  });
+}
+function spanHours(hours) {
+  const display = hours.map(function twelve(hour) {
+    return hour % 12 || 12;
+  });
+  if (display.indexOf(1) === -1) {
+    return "das " + joinList(display.map(String));
+  }
+  return joinList(display.map(function article(hour) {
+    return withDe((hour === 1 ? "a " : "as ") + hour);
+  }));
+}
+function renderMinuteFrequency(schedule, plan, opts) {
+  let phrase = stepCycle60(
+    stepSegment(schedule, "minute"),
+    "minuto",
+    "hora",
+    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 "a cada minuto da hora " + fromTime(timePhrase(plan.hour, 0, null, opts)) + trailingQualifier(schedule, opts);
+  }
+  return "a cada minuto " + 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 "a cada minuto, " + cadence + trailingQualifier(schedule, opts);
+    }
+    if (singleHourStep(schedule.analyses.segments.hour)) {
+      return "a cada minuto, " + stepHourSpan(stepSegment(schedule, "hour"), opts) + trailingQualifier(schedule, opts);
+    }
+    return "a cada minuto " + 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 "a cada minuto, " + 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 "a cada hora" + trailingQualifier(schedule, opts);
+}
+function renderHourRange(schedule, plan, opts) {
+  const window = hourWindow(boundedWindow(plan), opts);
+  if (plan.minuteForm === "wildcard") {
+    return "a cada minuto " + window + trailingQualifier(schedule, opts);
+  }
+  if (plan.minuteForm === "range") {
+    return minuteRangeLead(schedule.pattern.minute) + ", " + window + trailingQualifier(schedule, opts);
+  }
+  if (schedule.pattern.minute === "0") {
+    return "a cada hora " + window + trailingQualifier(schedule, opts);
+  }
+  const lead = schedule.shapes.minute === "single" ? "no minuto " + schedule.pattern.minute + " de cada hora" : 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 " : "em ");
+  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 hasLeadingArticle(quartz) ? withEm(quartz) : quartz;
+  }
+  const parity = parityDayPredicate(date);
+  if (parity) {
+    return "em " + parity;
+  }
+  if (isOpenStep(date)) {
+    return stepDates(date, opts);
+  }
+  const segments = segmentsOf(schedule, "date");
+  if (segments.length === 1 && segments[0].kind === "range") {
+    return "do dia " + dayOrdinal(segments[0].bounds[0]) + " ao dia " + segments[0].bounds[1] + " do m\xEAs";
+  }
+  if (segments.length === 1 && segments[0].kind === "single") {
+    return schedule.pattern.month === "*" ? "no dia " + dayOrdinal(segments[0].value) + " de cada m\xEAs" : "no dia " + dayOrdinal(segments[0].value);
+  }
+  return "nos dias " + joinList(dateWords(segments)) + " do m\xEAs";
+}
+function dowArm(schedule) {
+  const quartz = quartzWeekdayPhrase(schedule.pattern.weekday);
+  if (quartz) {
+    return withEm(quartz);
+  }
+  const segments = orderWeekdaysForDisplay(segmentsOf(schedule, "weekday"));
+  const allSingles = segments.every(function single(segment) {
+    return segment.kind === "single";
+  });
+  if (allSingles && segments.length === 1) {
+    return recurringWeekday(segments[0].value);
+  }
+  if (allSingles) {
+    return recurringWeekdayList(segments);
+  }
+  if (segments.length === 1) {
+    return "em qualquer dia " + weekdayRange(segments[0]);
+  }
+  return mixedWeekdayList(segments);
+}
+function unionSejaSuffix(schedule, opts) {
+  return ", seja " + domArm(schedule, opts) + " ou " + 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));
+  });
+  return degenitive(groupClockTimes(phrases));
+}
+function durationHourList(times, opts) {
+  const phrases = times.map(function clock(time) {
+    return atTime(bareHourPhrase(time.hour, opts));
+  });
+  return groupClockTimes(phrases);
+}
+function bareHourPhrase(hour, opts) {
+  if (opts.ampm) {
+    return timePhrase(hour, 0, null, opts);
+  }
+  if (+hour === 0) {
+    return "meia-noite";
+  }
+  if (+hour === 12) {
+    return "meio-dia";
+  }
+  return (+hour === 1 ? "a " : "as ") + hour;
+}
+function explicitTimePhrase(hour, minute, opts) {
+  if (!opts.ampm) {
+    const article = +hour === 1 ? "a " : "as ";
+    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 ? "a " : "as ") + clockDigits({ hour: display, minute, second: 0 }, { sep: opts.style.sep });
+  const period = opts.style.meridiem === "english" ? meridiemMark(hour) : dayPeriod(hour, opts);
+  return time + " " + period;
+}
+function groupClockTimes(phrases) {
+  if (phrases.length < 2) {
+    return joinList(phrases);
+  }
+  return phrases.some(carriesDayPeriod) ? groupClockTimesByDayPeriod(phrases) : groupClockTimesByArticle(phrases);
+}
+function carriesDayPeriod(phrase) {
+  return phrase.includes(" da ");
+}
+var periodPhrasePattern = /^(às|à) (.+) (da .+)$/u;
+function groupClockTimesByDayPeriod(phrases) {
+  const runs = collectPeriodRuns(phrases);
+  const elided = elideSharedSingleValues(runs);
+  const rendered = elided.map(renderPeriodRun);
+  return joinPeriodClauses(rendered);
+}
+function collectPeriodRuns(phrases) {
+  const runs = [];
+  phrases.forEach(function place(phrase) {
+    const match = periodPhrasePattern.exec(phrase);
+    if (!match) {
+      runs.push({ kind: "special", text: phrase });
+      return;
+    }
+    const article = match[1] === "\xE0s" ? "as" : "a";
+    const value = match[2];
+    const period = match[3];
+    const last = runs[runs.length - 1];
+    if (last && last.kind === "period" && last.period === period) {
+      last.values.push({ article, value });
+    } else {
+      runs.push({ kind: "period", period, values: [{ article, value }] });
+    }
+  });
+  return runs;
+}
+function renderPeriodRun(clause) {
+  if (clause.kind === "special") {
+    return { text: clause.text, hasInternalE: false };
+  }
+  const { period, values } = clause;
+  if (values.length === 1) {
+    const tail = elidedTail(clause);
+    return {
+      hasInternalE: tail !== "",
+      text: withA(values[0].article + " " + values[0].value) + " " + period + tail
+    };
+  }
+  const sharedArticle = values.every(function same(entry) {
+    return entry.article === values[0].article;
+  });
+  const parts = sharedArticle ? values.map(function bare(entry) {
+    return entry.value;
+  }) : values.map(function articled(entry) {
+    return withA(entry.article + " " + entry.value);
+  });
+  const lead = sharedArticle ? withA(values[0].article + " ") : "";
+  return { hasInternalE: true, text: lead + joinList(parts) + " " + period };
+}
+function elideSharedSingleValues(runs) {
+  const merged = [];
+  let i = 0;
+  while (i < runs.length) {
+    const run = runs[i];
+    const value = loneValue(run);
+    let combined = run;
+    let j = i + 1;
+    if (value !== null) {
+      while (j < runs.length && loneValue(runs[j]) === value) {
+        combined = appendPeriod(
+          combined,
+          runs[j].period
+        );
+        j += 1;
+      }
+    }
+    merged.push(combined);
+    i = j;
+  }
+  return merged;
+}
+function loneValue(clause) {
+  return clause.kind === "period" && clause.values.length === 1 ? clause.values[0].value : null;
+}
+function appendPeriod(clause, period) {
+  const elided = clause;
+  const tailPeriods = (elided.tailPeriods || []).concat(period);
+  return { ...clause, tailPeriods };
+}
+function elidedTail(clause) {
+  const tail = clause.tailPeriods;
+  if (!tail || tail.length === 0) {
+    return "";
+  }
+  return tail.map(function chain(period) {
+    return " e " + period;
+  }).join("");
+}
+function joinPeriodClauses(clauses) {
+  if (clauses.length === 1) {
+    return clauses[0].text;
+  }
+  const last = clauses[clauses.length - 1];
+  const lead = clauses.slice(0, -1).map(function text(clause) {
+    return clause.text;
+  });
+  return lead.join(", ") + " e " + last.text;
+}
+function groupClockTimesByArticle(phrases) {
+  const singular = "\xE0 ";
+  const plural = "\xE0s ";
+  const aItems = [];
+  const asItems = [];
+  for (const phrase of phrases) {
+    if (phrase.startsWith(plural)) {
+      asItems.push(phrase.slice(plural.length));
+    } else if (phrase.startsWith(singular)) {
+      aItems.push(phrase.slice(singular.length));
+    } else {
+      return joinList(phrases);
+    }
+  }
+  if (aItems.length === 0) {
+    return plural + joinList(asItems);
+  }
+  if (asItems.length === 0) {
+    return singular + joinList(aItems);
+  }
+  const aPart = singular + joinList(aItems);
+  const asPart = plural + joinList(asItems);
+  const doubleE = aItems.length >= 2 || asItems.length === 2;
+  const connector = doubleE ? ", " : " e ";
+  return aPart + connector + asPart;
+}
+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 "a cada hora " + 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 = "a cada " + numero(interval, opts) + " " + unit + "s";
+  const tail = anchor ? " de cada " + anchor : "";
+  return renderStride({ start, interval, last, cycle }, {
+    bare: () => cadence,
+    offset: () => cadence + " a partir do " + unit + " " + start + tail,
+    bounded: () => cadence + " do " + unit + " " + start + " ao " + last + tail
+  });
+}
+function stepCycle60(segment, unit, anchor, opts) {
+  if (segment.startToken.indexOf("-") !== -1) {
+    return "nos " + unit + "s " + joinList(wordList(segment.fires)) + " de cada " + anchor;
+  }
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  if (start !== 0 && segment.fires.length <= 3) {
+    return "nos " + unit + "s " + joinList(wordList(segment.fires)) + " de cada " + 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 "a cada " + numeroF(interval, opts) + " horas";
+  }
+  if (segment.fires.length <= 3) {
+    return groupClockTimesByArticle(atTimes(segment.fires, opts));
+  }
+  return "a cada " + numeroF(interval, opts) + " horas a partir " + fromTime(timePhrase(start, 0, null, opts));
+}
+function hourStrideCadence(stride, opts) {
+  const { start, interval, last } = stride;
+  const cadence = "a cada " + numeroF(interval, opts) + " horas";
+  return renderStride({ start, interval, last, cycle: 24 }, {
+    bare: () => cadence,
+    offset: () => cadence + " a partir " + fromTime(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, "minuto", opts) + " durante um minuto";
+    }
+    return secondsClause(schedule, "hora", opts);
+  }
+  const minutePhrase = "no minuto " + minute;
+  if (schedule.pattern.second === "0") {
+    return minutePhrase;
+  }
+  return secondsClause(schedule, "minuto", 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, "minuto", opts) + " durante um minuto, " + 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, "minuto", opts) + " durante um minuto, durante as horas " + 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 !opts.ampm && (hour === 0 || hour === 12);
+  }
+  if (!hasRange && points.every(isWord)) {
+    return joinList(points.map(function each(hour) {
+      return atTime(bareHourPhrase(hour, opts));
+    }));
+  }
+  function wholeHour(hour) {
+    return "da hora " + fromTime(explicitTimePhrase(hour, 0, 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 "durante as horas " + 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)) + " e tamb\xE9m " + pieces[lastIdx];
+  }
+  return groupClockTimesByArticle(pieces);
+}
+function timeRange(from, to, opts) {
+  const fromPhrase = timePhrase(from.hour, from.minute, from.second, opts);
+  const toPhrase = timePhrase(to.hour, to.minute, to.second, opts);
+  const fromPeriod = dayPeriod(from.hour, opts);
+  const toPeriod = dayPeriod(to.hour, opts);
+  if (fromPeriod && fromPeriod === toPeriod && fromPhrase.endsWith(fromPeriod)) {
+    return fromTime(stripPeriod(fromPhrase, fromPeriod)) + " " + toTime(toPhrase);
+  }
+  return fromTime(fromPhrase) + " " + toTime(toPhrase);
+}
+function hourAsWindow(hour, opts) {
+  return timeRange({ hour, minute: 0 }, { hour, minute: 59 }, opts);
+}
+function stripPeriod(phrase, period) {
+  return phrase.slice(0, -(period.length + 1));
+}
+function atTime(phrase) {
+  return withA(phrase);
+}
+function fromTime(phrase) {
+  return withDe(phrase);
+}
+function toTime(phrase) {
+  return atTime(phrase);
+}
+function degenitive(grouped) {
+  if (grouped.startsWith("\xE0s ")) {
+    return "das " + grouped.slice(3);
+  }
+  if (grouped.startsWith("\xE0 ")) {
+    return "da " + grouped.slice(2);
+  }
+  return grouped;
+}
+function timePhrase(hour, minute, second, opts) {
+  const showSeconds = typeof second === "number" && second > 0 ? second : 0;
+  if (!opts.ampm) {
+    const article = +hour === 1 ? "a " : "as ";
+    const suffix = opts.style.hSuffix ? " h" : "";
+    return article + clockDigits(
+      { hour, minute, second: showSeconds },
+      { pad: true, sep: opts.style.sep }
+    ) + suffix;
+  }
+  return twelveHourPhrase(hour, minute, showSeconds, opts);
+}
+function twelveHourPhrase(hour, minute, second, opts) {
+  if (+minute === 0 && !second) {
+    if (+hour === 0) {
+      return "meia-noite";
+    }
+    if (+hour === 12) {
+      return "meio-dia";
+    }
+  }
+  const display = hour % 12 || 12;
+  const time = (display === 1 ? "a " : "as ") + clockDigits(
+    { hour: display, minute, second },
+    { lean: true, sep: opts.style.sep }
+  );
+  const period = opts.style.meridiem === "english" ? meridiemMark(hour) : dayPeriod(hour, opts);
+  return time + " " + period;
+}
+function meridiemMark(hour) {
+  return +hour < 12 ? "AM" : "PM";
+}
+function dayPeriod(hour, opts) {
+  if (!opts.ampm) {
+    return "";
+  }
+  if (+hour === 0 || +hour >= 19) {
+    return "da noite";
+  }
+  if (+hour <= 5) {
+    return "da madrugada";
+  }
+  if (+hour <= 11) {
+    return "da manh\xE3";
+  }
+  return "da tarde";
+}
+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 weekdayLead(schedule) + " ";
+  }
+  if (pattern.month !== "*") {
+    return "todos os dias " + monthPhrase(schedule, "de ") + " ";
+  }
+  return "todos os dias ";
+}
+function trailingDayClause(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 "todos os dias " + monthPhrase(schedule, "de ");
+  }
+  return "todos os dias";
+}
+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, "em ");
+  }
+  return "";
+}
+function weekdayLead(schedule) {
+  const single = singleFeminineWeekday(schedule);
+  if (single !== null && !monthRanged(schedule)) {
+    return everyWeekday(single) + monthScope(schedule);
+  }
+  return weekdayQualifier(schedule) + monthScope(schedule);
+}
+function singleFeminineWeekday(schedule) {
+  if (quartzWeekdayPhrase(schedule.pattern.weekday)) {
+    return null;
+  }
+  const segments = segmentsOf(schedule, "weekday");
+  if (segments.length === 1 && segments[0].kind === "single") {
+    const number = canonicalWeekday(segments[0].value);
+    return weekdayFeminine(number) ? number : null;
+  }
+  return null;
+}
+function everyWeekday(number) {
+  return "toda " + weekdayNames[number];
+}
+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 hasLeadingArticle(quartz) ? withEm(quartz) : quartz;
+  }
+  if (isOpenStep(pattern.date)) {
+    return stepDates(pattern.date, opts);
+  }
+  const segments = segmentsOf(schedule, "date");
+  if (segments.length === 1 && segments[0].kind === "range") {
+    return "do dia " + dayOrdinal(segments[0].bounds[0]) + " ao dia " + segments[0].bounds[1] + monthPart + foldedYear(schedule);
+  }
+  if (segments.length === 1 && segments[0].kind === "single") {
+    return "no dia " + dayOrdinal(segments[0].value) + monthPart + foldedYear(schedule);
+  }
+  return "nos dias " + 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 cada m\xEAs";
+  }
+  if (monthRanged(schedule)) {
+    return " de cada m\xEAs, " + monthPhrase(schedule, "de ");
+  }
+  return " " + monthPhrase(schedule, "de ");
+}
+function foldedYear(schedule) {
+  const yearField = schedule.pattern.year;
+  if (yearField === "*" || yearField.indexOf("/") !== -1 || yearField.indexOf("-") !== -1 || yearField.indexOf(",") !== -1) {
+    return "";
+  }
+  return " de " + yearField;
+}
+function quartzDatePhrase(dateField) {
+  if (dateField === "L") {
+    return "o \xFAltimo dia do m\xEAs";
+  }
+  if (dateField === "LW" || dateField === "WL") {
+    return "o \xFAltimo dia \xFAtil do m\xEAs";
+  }
+  const offset = /^L-(\d{1,2})$/.exec(dateField);
+  if (offset) {
+    return +offset[1] === 1 ? "um dia antes do \xFAltimo dia do m\xEAs" : offset[1] + " dias antes do \xFAltimo dia do m\xEAs";
+  }
+  const nearest = /^(\d{1,2})W$|^W(\d{1,2})$/.exec(dateField);
+  if (nearest) {
+    return "o dia \xFAtil mais pr\xF3ximo ao dia " + (nearest[1] || nearest[2]);
+  }
+}
+function quartzWeekdayPhrase(weekdayField) {
+  const parts = weekdayField.split("#");
+  if (parts.length === 2) {
+    const number = canonicalWeekday(parts[0]);
+    const feminine = weekdayFeminine(number);
+    const ordinalWord = (feminine ? nthWeekdayFeminine : nthWeekdayMasculine)[+parts[1]];
+    const article = feminine ? "a " : "o ";
+    if (ordinalCollides(ordinalWord, number)) {
+      return article + parts[1] + (feminine ? "\xAA " : "\xBA ") + weekdayNames[number] + " do m\xEAs";
+    }
+    return article + ordinalWord + " " + weekdayNames[number] + " do m\xEAs";
+  }
+  if (/L$/.test(weekdayField)) {
+    const number = canonicalWeekday(weekdayField.slice(0, -1));
+    const article = weekdayFeminine(number) ? "a \xFAltima " : "o \xFAltimo ";
+    return article + weekdayNames[number] + " do m\xEAs";
+  }
+}
+function ordinalCollides(ordinalWord, number) {
+  return ordinalWord === weekdayStems[number];
+}
+function weekdayQualifier(schedule) {
+  const quartz = quartzWeekdayPhrase(schedule.pattern.weekday);
+  if (quartz) {
+    return withEm(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 recurringWeekday(token) {
+  const number = canonicalWeekday(token);
+  const article = weekdayFeminine(number) ? "as " : "os ";
+  return withA(article + pluralWeekday(token));
+}
+function recurringWeekdayList(segments) {
+  const numbers = segments.map(function num(segment) {
+    return canonicalWeekday(segment.value);
+  });
+  const feminineCount = numbers.filter(weekdayFeminine).length;
+  if (feminineCount === 0) {
+    return withA("os " + joinList(numbers.map(pluralFeira)));
+  }
+  const trailingMasculine = numbers.length - feminineCount === 1 && !weekdayFeminine(numbers[numbers.length - 1]);
+  const head = trailingMasculine ? numbers.slice(0, -1) : numbers;
+  const tail = trailingMasculine ? numbers[numbers.length - 1] : null;
+  if (tail === null) {
+    return withA("as " + joinList(feiraEllipsis(head)));
+  }
+  const feminineList = withA("as " + feiraEllipsis(head).join(", "));
+  return feminineList + " e " + withA("os " + pluralFeira(tail));
+}
+function feiraEllipsis(numbers) {
+  let lastFeira = -1;
+  numbers.forEach(function find(number, index) {
+    if (weekdayFeminine(number)) {
+      lastFeira = index;
+    }
+  });
+  return numbers.map(function word(number, index) {
+    if (weekdayFeminine(number)) {
+      return index === lastFeira ? pluralFeira(number) : pluralStem(number);
+    }
+    return pluralFeira(number);
+  });
+}
+function mixedWeekdayList(segments) {
+  return joinList(segments.map(function name(segment) {
+    return segment.kind === "range" ? weekdayRange(segment) : recurringWeekday(segment.value);
+  }));
+}
+function weekdayRange(segment) {
+  return "de " + weekdayStem(segment.bounds[0]) + " a " + 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]) + " a " + 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 "um dia \xEDmpar do m\xEAs";
+  }
+  if (start === "2") {
+    return "um dia par do m\xEAs";
+  }
+}
+function stepDates(dateField, opts) {
+  const parts = dateField.split("/");
+  let phrase = "a cada " + numero(+parts[1], opts) + " dias do m\xEAs";
+  if (parts[0] !== "*" && parts[0] !== "1") {
+    phrase += " a partir do dia " + dayOrdinal(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 + " em " + joinList(yearField.split(","));
+  }
+  return description + " em " + yearField;
+}
+function stepYears(yearField, opts) {
+  const parts = yearField.split("/");
+  const interval = +parts[1];
+  if (interval <= 1) {
+    return "todos os anos";
+  }
+  let phrase = "a cada " + numero(interval, opts) + " anos";
+  if (parts[0] !== "*" && parts[0] !== "0") {
+    phrase += " a partir de " + parts[0];
+  }
+  return phrase;
+}
+function segmentWords(segments) {
+  return segments.flatMap(function word(segment) {
+    if (segment.kind === "range") {
+      return [segment.bounds[0] + " a " + 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 [dayOrdinal(segment.bounds[0]) + " a " + segment.bounds[1]];
+    }
+    if (segment.kind === "step") {
+      return segment.fires.map(function fire(value, index) {
+        return index === 0 ? dayOrdinal(value) : "" + value;
+      });
+    }
+    return [dayOrdinal(segment.value)];
+  });
+}
+function dayOrdinal(value) {
+  return +value === 1 ? "1\xBA" : "" + 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] + " e " + items[1];
+  }
+  return items.slice(0, -1).join(", ") + " e " + items[items.length - 1];
+}
+function numero(n, opts) {
+  return numeral(n, numeros, opts);
+}
+function numeroF(n, opts) {
+  const word = numero(n, opts);
+  return word === "dois" ? "duas" : word;
+}
+function canonicalWeekday(token) {
+  const number = toFieldNumber("" + token, weekdayNumbers);
+  return number === 7 ? 0 : number;
+}
+function weekdayName(token) {
+  return weekdayNames[canonicalWeekday(token)];
+}
+function weekdayStem(token) {
+  return weekdayStems[canonicalWeekday(token)];
+}
+function pluralWeekday(token) {
+  return pluralFeira(canonicalWeekday(token));
+}
+function pluralFeira(number) {
+  if (weekdayFeminine(number)) {
+    return pluralStem(number) + "-feiras";
+  }
+  return weekdayNames[number] + "s";
+}
+function pluralStem(number) {
+  return weekdayStems[number] + "s";
+}
+function monthName(token) {
+  return monthNames[+token];
+}
+var pt2 = {
+  describe,
+  fallback: "um padr\xE3o cron irreconhec\xEDvel",
+  options: normalizeOptions,
+  reboot: "ao iniciar o sistema",
+  // A description ending in a period already carries it, so closing the
+  // sentence must not double it.
+  sentence: (description) => "Se executa " + description + (description.endsWith(".") ? "" : ".")
+};
+var index_default = pt2;
+module.exports = module.exports.default;