cronli5 0.0.0-beta.6 → 0.1.0

package/dist/lang/en.cjs

@@ -0,0 +1,830 @@
+"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/en/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/lang/en/dialects.ts
+var dialects = {
+  gb: {
+    am: "am",
+    closeUp: true,
+    dayFirst: true,
+    midday: "midday",
+    midnight: "midnight",
+    ordinals: false,
+    pm: "pm",
+    sep: ".",
+    serialComma: false,
+    through: " to "
+  },
+  us: {
+    am: "a.m.",
+    closeUp: false,
+    dayFirst: false,
+    midday: "noon",
+    midnight: "midnight",
+    ordinals: false,
+    pm: "p.m.",
+    sep: ":",
+    serialComma: true,
+    through: " through "
+  },
+  house: {
+    am: "AM",
+    closeUp: false,
+    dayFirst: false,
+    midday: "noon",
+    midnight: "midnight",
+    ordinals: true,
+    pm: "PM",
+    sep: ":",
+    serialComma: true,
+    through: " - "
+  }
+};
+function resolveDialect(dialect) {
+  if (typeof dialect === "object" && dialect !== null) {
+    return { ...dialects.us, ...dialect };
+  }
+  const name = dialect === "uk" ? "gb" : dialect;
+  return dialects[name] || dialects.us;
+}
+
+// src/lang/en/index.ts
+var numbers = [
+  "zero",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten"
+];
+var suffixes = [
+  "th",
+  "st",
+  "nd",
+  "rd"
+];
+var monthNames = [
+  null,
+  ["January", "Jan"],
+  ["February", "Feb"],
+  ["March", "Mar"],
+  ["April", "Apr"],
+  ["May", "May"],
+  ["June", "Jun"],
+  ["July", "Jul"],
+  ["August", "Aug"],
+  ["September", "Sep"],
+  ["October", "Oct"],
+  ["November", "Nov"],
+  ["December", "Dec"]
+];
+var weekdayNames = [
+  ["Sunday", "Sun"],
+  ["Monday", "Mon"],
+  ["Tuesday", "Tue"],
+  ["Wednesday", "Wed"],
+  ["Thursday", "Thu"],
+  ["Friday", "Fri"],
+  ["Saturday", "Sat"]
+];
+var monthAbbreviations = {
+  JAN: monthNames[1],
+  FEB: monthNames[2],
+  MAR: monthNames[3],
+  APR: monthNames[4],
+  MAY: monthNames[5],
+  JUN: monthNames[6],
+  JUL: monthNames[7],
+  AUG: monthNames[8],
+  SEP: monthNames[9],
+  OCT: monthNames[10],
+  NOV: monthNames[11],
+  DEC: monthNames[12]
+};
+var weekdayAbbreviations = {
+  SUN: weekdayNames[0],
+  MON: weekdayNames[1],
+  TUE: weekdayNames[2],
+  WED: weekdayNames[3],
+  THU: weekdayNames[4],
+  FRI: weekdayNames[5],
+  SAT: weekdayNames[6]
+};
+var nthWeekdayNames = [null, "first", "second", "third", "fourth", "fifth"];
+function normalizeOptions(options) {
+  options = options || {};
+  return {
+    ampm: typeof options.ampm === "boolean" ? options.ampm : true,
+    lenient: !!options.lenient,
+    seconds: !!options.seconds,
+    short: !!options.short,
+    style: resolveDialect(options.dialect),
+    years: !!options.years
+  };
+}
+function describe(ir, opts) {
+  return applyYear(render(ir, ir.plan, opts), ir, opts);
+}
+function render(ir, plan, opts) {
+  const renderer = renderers[plan.kind];
+  return renderer(ir, plan, opts);
+}
+function renderEverySecond(ir, plan, opts) {
+  return "every second" + trailingQualifier(ir, opts);
+}
+function renderStandaloneSeconds(ir, plan, opts) {
+  return secondsLeadClause(ir, opts) + trailingQualifier(ir, opts);
+}
+function renderSecondPastMinute(ir, plan, opts) {
+  const secondField = ir.pattern.second;
+  return getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the minute, every minute" + trailingQualifier(ir, opts);
+}
+function renderSecondsWithinMinute(ir, plan, opts) {
+  const minuteField = ir.pattern.minute;
+  const minuteWord = getNumber(minuteField, opts);
+  const minuteUnit = pluralize(minuteField, "minute");
+  if (plan.singleSecond) {
+    const secondField = ir.pattern.second;
+    return minuteWord + " " + minuteUnit + " and " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the hour, every hour" + trailingQualifier(ir, opts);
+  }
+  return secondsLeadClause(ir, opts) + ", " + minuteWord + " " + minuteUnit + " past the hour, every hour" + trailingQualifier(ir, opts);
+}
+function renderComposeSeconds(ir, plan, opts) {
+  return secondsLeadClause(ir, opts) + ", " + render(ir, plan.rest, opts);
+}
+function secondsLeadClause(ir, opts) {
+  const secondField = ir.pattern.second;
+  const shape = ir.shapes.second;
+  if (secondField === "*") {
+    return "every second";
+  }
+  if (shape === "step") {
+    return stepCycle60(
+      ir.analyses.segments.second[0],
+      "second",
+      "minute",
+      opts
+    );
+  }
+  if (shape === "range") {
+    const bounds = secondField.split("-");
+    const num = seriesNumber(bounds, opts);
+    return "every second from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the minute";
+  }
+  if (shape === "single") {
+    return "at " + getNumber(secondField, opts) + " " + pluralize(secondField, "second") + " past the minute";
+  }
+  return listPastThe(
+    segmentWords(ir.analyses.segments.second, opts),
+    "second",
+    "minute",
+    opts
+  );
+}
+function renderEveryMinute(ir, plan, opts) {
+  return "every minute" + trailingQualifier(ir, opts);
+}
+function renderSingleMinute(ir, plan, opts) {
+  const minuteField = ir.pattern.minute;
+  return getNumber(minuteField, opts) + " " + pluralize(minuteField, "minute") + " past the hour, every hour" + trailingQualifier(ir, opts);
+}
+function renderRangeOfMinutes(ir, plan, opts) {
+  return minuteRangeLead(ir.pattern.minute, opts) + trailingQualifier(ir, opts);
+}
+function renderMultipleMinutes(ir, plan, opts) {
+  return listPastThe(
+    segmentWords(ir.analyses.segments.minute, opts),
+    "minute",
+    "hour",
+    opts
+  ) + trailingQualifier(ir, opts);
+}
+function renderMinuteFrequency(ir, plan, opts) {
+  let phrase = stepCycle60(
+    ir.analyses.segments.minute[0],
+    "minute",
+    "hour",
+    opts
+  );
+  if (plan.hours.kind === "during") {
+    phrase += " during the " + hourTimesFromPlan(ir, plan.hours.times, false, opts) + " hours";
+  } else if (plan.hours.kind === "window") {
+    phrase += " " + hourWindow(plan.hours, opts);
+  } else if (plan.hours.kind === "step") {
+    phrase += " " + everyNthHour(ir.analyses.segments.hour[0], opts);
+  }
+  return phrase + trailingQualifier(ir, opts);
+}
+function renderMinuteSpanInHour(ir, plan, opts) {
+  return "every minute from " + getTime({ hour: plan.hour, minute: plan.span[0] }, opts) + through(opts) + getTime({ hour: plan.hour, minute: plan.span[1] }, opts) + trailingQualifier(ir, opts);
+}
+function renderMinutesAcrossHours(ir, plan, opts) {
+  if (plan.form === "wildcard") {
+    return "every minute during the " + hourTimesFromPlan(ir, plan.times, false, opts) + " hours" + trailingQualifier(ir, opts);
+  }
+  const times = hourTimesFromPlan(ir, plan.times, true, opts);
+  const lead = plan.form === "range" ? minuteRangeLead(ir.pattern.minute, opts) : (
+    // The 'list' form is a minute list, which has segments.
+    listPastThe(
+      segmentWords(ir.analyses.segments.minute, opts),
+      "minute",
+      "hour",
+      opts
+    )
+  );
+  return lead + ", at " + times + trailingQualifier(ir, opts);
+}
+var stepOrdinals = {
+  2: "other",
+  3: "third",
+  4: "fourth",
+  6: "sixth",
+  8: "eighth",
+  12: "twelfth"
+};
+function everyNthHour(segment, opts) {
+  const base = "during every " + stepOrdinals[segment.interval] + " hour";
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  return start === 0 ? base : base + " starting at " + getTime({ hour: start, minute: 0 }, opts);
+}
+function renderMinuteSpanAcrossHourStep(ir, plan, opts) {
+  const segment = ir.analyses.segments.hour[0];
+  if (plan.form === "wildcard") {
+    return "every minute " + everyNthHour(segment, opts) + trailingQualifier(ir, opts);
+  }
+  return minuteRangeLead(ir.pattern.minute, opts) + ", " + stepHours(segment, opts) + trailingQualifier(ir, opts);
+}
+function minuteRangeLead(minuteField, opts) {
+  const bounds = minuteField.split("-");
+  const num = seriesNumber(bounds, opts);
+  return "every minute from " + num(bounds[0]) + through(opts) + num(bounds[1]) + " past the hour";
+}
+function renderEveryHour(ir, plan, opts) {
+  return "every hour" + trailingQualifier(ir, opts);
+}
+function renderHourRange(ir, plan, opts) {
+  const window = hourWindow(plan, opts);
+  if (plan.minuteForm === "wildcard") {
+    return "every minute " + window + trailingQualifier(ir, opts);
+  }
+  if (plan.minuteForm === "range") {
+    return minuteRangeLead(ir.pattern.minute, opts) + ", " + window + trailingQualifier(ir, opts);
+  }
+  return rangeMinuteLead(ir, opts) + " " + window + trailingQualifier(ir, opts);
+}
+function rangeMinuteLead(ir, opts) {
+  if (ir.pattern.minute === "0") {
+    return "every hour";
+  }
+  return listPastThe(
+    segmentWords(ir.analyses.segments.minute, opts),
+    "minute",
+    "hour",
+    opts
+  );
+}
+function renderHourStep(ir, plan, opts) {
+  return stepHours(ir.analyses.segments.hour[0], opts) + trailingQualifier(ir, opts);
+}
+function hourWindow(window, opts) {
+  return "from " + getTime({ hour: window.from, minute: 0 }, opts) + through(opts) + getTime({ hour: window.to, minute: window.last }, opts);
+}
+function renderClockTimes(ir, plan, opts) {
+  const plain = mixedTwelve(plan.times);
+  const times = plan.times.map(function clock(time) {
+    return getTime({
+      hour: time.hour,
+      minute: time.minute,
+      second: time.second,
+      plain
+    }, opts);
+  });
+  return interpretDayQualifier(ir, opts) + "at " + joinList(times, opts);
+}
+function renderCompactClockTimes(ir, plan, opts) {
+  if (plan.fold) {
+    const hasRange = ir.analyses.segments.hour.some(function range(segment) {
+      return segment.kind === "range";
+    });
+    if (hasRange && !ir.analyses.clockSecond) {
+      return foldedHourWindows(ir, plan, opts) + trailingQualifier(ir, opts);
+    }
+    const fold = { minute: plan.minute, second: ir.analyses.clockSecond };
+    return interpretDayQualifier(ir, opts) + "at " + hourSegmentTimes(ir, fold, true, opts);
+  }
+  const phrase = (
+    // The non-fold branch is a minute list, which has segments.
+    listPastThe(
+      segmentWords(ir.analyses.segments.minute, opts),
+      "minute",
+      "hour",
+      opts
+    ) + ", at " + hourSegmentTimes(ir, { minute: 0, second: null }, true, opts) + trailingQualifier(ir, opts)
+  );
+  return ir.analyses.clockSecond ? secondsLeadClause(ir, opts) + ", " + phrase : phrase;
+}
+function foldedHourWindows(ir, plan, opts) {
+  const minute = plan.minute;
+  const windows = [];
+  const singles = [];
+  ir.analyses.segments.hour.forEach(function classify(segment) {
+    if (segment.kind === "range") {
+      windows.push("from " + getTime(
+        { hour: segment.bounds[0], minute: 0 },
+        opts
+      ) + through(opts) + getTime({ hour: segment.bounds[1], minute }, opts));
+    } else if (segment.kind === "step") {
+      singles.push(...segment.fires);
+    } else {
+      singles.push(+segment.value);
+    }
+  });
+  let phrase = rangeMinuteLead(ir, opts) + " " + joinList(windows, opts);
+  if (singles.length) {
+    phrase += " and at " + joinList(singles.map(function time(hour) {
+      return getTime({ hour, minute }, opts);
+    }), opts);
+  }
+  return 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 stepCycle60(segment, unit, anchor, opts) {
+  if (segment.startToken.indexOf("-") !== -1) {
+    return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
+  }
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  const interval = segment.interval;
+  if (start !== 0) {
+    if (segment.fires.length <= 3) {
+      return listPastThe(
+        numberWords(segment.fires, opts),
+        unit,
+        anchor,
+        opts
+      );
+    }
+    return "every " + getNumber(interval, opts) + " " + unit + "s from " + getNumber(start, opts) + " " + pluralize(start, unit) + " past the " + anchor;
+  }
+  if (60 % interval === 0) {
+    return "every " + getNumber(interval, opts) + " " + unit + "s";
+  }
+  if (segment.fires.length <= 2) {
+    return listPastThe(numberWords(segment.fires, opts), unit, anchor, opts);
+  }
+  return "every " + getNumber(interval, opts) + " " + unit + "s past the " + anchor;
+}
+function stepHours(segment, opts) {
+  if (segment.startToken.indexOf("-") !== -1) {
+    return "at " + hourTimes(segment.fires, opts);
+  }
+  const start = segment.startToken === "*" ? 0 : +segment.startToken;
+  const interval = segment.interval;
+  if (start === 0 && 24 % interval === 0) {
+    return "every " + getNumber(interval, opts) + " hours";
+  }
+  if (segment.fires.length <= 3) {
+    return "at " + hourTimes(segment.fires, opts);
+  }
+  if (start === 0) {
+    return "every " + getNumber(interval, opts) + " hours from midnight";
+  }
+  return "every " + getNumber(interval, opts) + " hours from " + getTime({ hour: start, minute: 0 }, opts);
+}
+function seriesNumber(values, opts) {
+  const anyBig = values.some(function big(v) {
+    return +v > 10;
+  });
+  return function format(n) {
+    return anyBig ? "" + n : getNumber(n, opts);
+  };
+}
+function numberWords(fires, opts) {
+  return fires.map(seriesNumber(fires, opts));
+}
+function segmentWords(segments, opts) {
+  const values = segments.flatMap(function collect(segment) {
+    if (segment.kind === "range") {
+      return segment.bounds;
+    }
+    return segment.kind === "step" ? segment.fires : [segment.value];
+  });
+  const num = seriesNumber(values, opts);
+  return segments.flatMap(function word(segment) {
+    if (segment.kind === "range") {
+      return [num(segment.bounds[0]) + through(opts) + num(segment.bounds[1])];
+    }
+    if (segment.kind === "step") {
+      return segment.fires.map(num);
+    }
+    return [num(segment.value)];
+  });
+}
+function listPastThe(words, unit, anchor, opts) {
+  return "at " + joinList(words, opts) + " " + unit + "s past the " + anchor;
+}
+function wordTime(hour, minute, second) {
+  return (+hour === 0 || +hour === 12) && +minute === 0 && !(typeof second === "number" && second > 0);
+}
+function mixedTwelve(entries) {
+  const words = entries.filter(function word(e) {
+    return wordTime(e.hour, e.minute, e.second);
+  });
+  return words.length > 0 && words.length < entries.length;
+}
+function hourTimes(hours, opts) {
+  const plain = mixedTwelve(hours.map(function entry(hour) {
+    return { hour, minute: 0 };
+  }));
+  const times = hours.map(function clock(hour) {
+    return getTime({ hour, minute: 0, plain }, opts);
+  });
+  return joinList(times, opts);
+}
+function hourTimesFromPlan(ir, times, atContext, opts) {
+  if (times.kind === "fires") {
+    return hourTimes(times.fires, opts);
+  }
+  return hourSegmentTimes(ir, { minute: 0, second: null }, atContext, opts);
+}
+function segmentHours(segment) {
+  if (segment.kind === "range") {
+    return segment.bounds;
+  }
+  return segment.kind === "step" ? segment.fires : [segment.value];
+}
+function hourSegmentTimes(ir, fold, atContext, opts) {
+  const { minute, second } = fold;
+  const segments = ir.analyses.segments.hour;
+  const plain = mixedTwelve(segments.flatMap(function entries(segment) {
+    return segmentHours(segment).map(function entry(hour) {
+      return { hour: +hour, minute, second };
+    });
+  }));
+  const pieces = [];
+  segments.forEach(function clock(segment) {
+    if (segment.kind === "step") {
+      pieces.push(...segment.fires.map(function time(hour) {
+        return getTime({ hour, minute, second, plain }, opts);
+      }));
+    } else if (segment.kind === "range") {
+      pieces.push(
+        getTime({ hour: segment.bounds[0], minute, second, plain }, opts) + through(opts) + getTime({ hour: segment.bounds[1], minute, second, plain }, opts)
+      );
+    } else {
+      pieces.push(getTime({ hour: segment.value, minute, second, plain }, opts));
+    }
+  });
+  return joinList(disambiguateTimes(pieces, segments, atContext), opts);
+}
+function disambiguateTimes(pieces, segments, atContext) {
+  const hasRange = segments.some(function range(segment) {
+    return segment.kind === "range";
+  });
+  if (!atContext || !hasRange) {
+    return pieces;
+  }
+  return pieces.map(function at(piece, index) {
+    return index === 0 ? piece : "at " + piece;
+  });
+}
+function joinList(items, opts) {
+  if (items.length <= 1) {
+    return items.join("");
+  }
+  if (items.length === 2) {
+    return items[0] + " and " + items[1];
+  }
+  const and = opts.style.serialComma ? ", and " : " and ";
+  return items.slice(0, -1).join(", ") + and + items[items.length - 1];
+}
+var trailingWords = { all: "", month: "in ", stepDate: "on ", weekday: "on " };
+var leadingWords = {
+  all: "every day",
+  month: "every day in ",
+  stepDate: "",
+  weekday: "every "
+};
+function trailingQualifier(ir, opts) {
+  const phrase = dayQualifier(ir, trailingWords, opts);
+  return phrase && " " + phrase;
+}
+function interpretDayQualifier(ir, opts) {
+  return dayQualifier(ir, leadingWords, opts) + " ";
+}
+function dayQualifier(ir, words, opts) {
+  const pattern = ir.pattern;
+  if (pattern.date !== "*" && pattern.weekday !== "*") {
+    return dateOrWeekday(ir, opts);
+  }
+  if (pattern.date !== "*") {
+    return datePhrase(ir, words, opts);
+  }
+  if (pattern.weekday !== "*") {
+    const weekdays = quartzWeekdayPhrase(pattern.weekday, opts) || words.weekday + weekdayPhrase(ir, opts);
+    return weekdays + monthScope(ir, opts);
+  }
+  if (pattern.month !== "*") {
+    return words.month + monthName(ir, opts);
+  }
+  return words.all;
+}
+function datePhrase(ir, words, opts) {
+  const pattern = ir.pattern;
+  const quartzDate = quartzDatePhrase(pattern.date, opts);
+  if (quartzDate) {
+    return quartzDate + monthScope(ir, opts);
+  }
+  if (isOpenStep(pattern.date)) {
+    return words.stepDate + stepDates(pattern.date) + monthScope(ir, opts);
+  }
+  if (pattern.month !== "*" && !monthFoldsIntoDate(ir)) {
+    return "on the " + dateOrdinals(ir, opts) + monthScope(ir, opts);
+  }
+  if (pattern.month !== "*") {
+    return "on " + monthDatePhrase(ir, opts);
+  }
+  return "on the " + dateOrdinals(ir, opts);
+}
+function monthFoldsIntoDate(ir) {
+  return !oddEvenMonth(ir.pattern.month) && // Reached only with a restricted month, which has segments.
+  ir.analyses.segments.month.every(function flat(segment) {
+    return segment.kind !== "range";
+  });
+}
+function dateOrWeekday(ir, opts) {
+  const pattern = ir.pattern;
+  const weekdayPart = quartzWeekdayPhrase(pattern.weekday, opts) || "on " + weekdayPhrase(ir, opts);
+  const quartzDate = quartzDatePhrase(pattern.date, opts);
+  if (quartzDate) {
+    return quartzDate + monthScope(ir, opts) + " or " + weekdayPart;
+  }
+  if (isOpenStep(pattern.date)) {
+    return stepDates(pattern.date) + monthScope(ir, opts) + " or " + weekdayPart;
+  }
+  if (pattern.month !== "*" && monthFoldsIntoDate(ir)) {
+    return "on " + monthDatePhrase(ir, opts) + " or " + weekdayPart + " in " + monthName(ir, opts);
+  }
+  return "on the " + dateOrdinals(ir, opts) + " or " + weekdayPart + monthScope(ir, opts);
+}
+function quartzDatePhrase(dateField, opts) {
+  if (dateField === "L") {
+    return "on the last day of the month";
+  }
+  if (dateField === "LW" || dateField === "WL") {
+    return "on the last weekday of the month";
+  }
+  const offset = /^L-(\d{1,2})$/.exec(dateField);
+  if (offset) {
+    return getNumber(+offset[1], opts) + " " + pluralize(offset[1], "day") + " before the last day of the month";
+  }
+  const nearest = /^(\d{1,2})W$|^W(\d{1,2})$/.exec(dateField);
+  if (nearest) {
+    return "on the weekday nearest the " + getOrdinal(nearest[1] || nearest[2]);
+  }
+}
+function quartzWeekdayPhrase(weekdayField, opts) {
+  const parts = weekdayField.split("#");
+  if (parts.length === 2) {
+    return "on the " + nthWeekdayNames[+parts[1]] + " " + getWeekday(parts[0], opts) + " of the month";
+  }
+  if (/L$/.test(weekdayField)) {
+    return "on the last " + getWeekday(weekdayField.slice(0, -1), opts) + " of the month";
+  }
+}
+function monthDatePhrase(ir, opts) {
+  const month = monthName(ir, opts);
+  const days = renderSegments(
+    ir.analyses.segments.date,
+    opts.style.ordinals ? getOrdinal : cardinalDay,
+    opts
+  );
+  return opts.style.dayFirst ? days + " " + month : month + " " + days;
+}
+function cardinalDay(value) {
+  return "" + value;
+}
+function monthScope(ir, opts) {
+  if (ir.pattern.month === "*") {
+    return "";
+  }
+  return " in " + monthName(ir, opts);
+}
+function stepDates(dateField) {
+  const parts = dateField.split("/");
+  const interval = +parts[1];
+  const start = parts[0];
+  const cadence = interval === 2 ? "every other" : "every " + getOrdinal(interval);
+  let phrase = cadence + " day of the month";
+  if (start !== "*" && start !== "1") {
+    phrase += " from the " + getOrdinal(start);
+  }
+  return phrase;
+}
+function dateOrdinals(ir, opts) {
+  return renderSegments(ir.analyses.segments.date, getOrdinal, opts);
+}
+function monthName(ir, opts) {
+  const oddEven = oddEvenMonth(ir.pattern.month);
+  if (oddEven) {
+    return oddEven;
+  }
+  return renderSegments(ir.analyses.segments.month, function name(value) {
+    return getMonth(value, opts);
+  }, opts);
+}
+function oddEvenMonth(monthField) {
+  if (!isOpenStep(monthField)) {
+    return null;
+  }
+  const [start, step] = monthField.split("/");
+  if (+step !== 2) {
+    return null;
+  }
+  if (start === "*" || start === "1") {
+    return "every odd-numbered month";
+  }
+  return start === "2" ? "every even-numbered month" : null;
+}
+function weekdayPhrase(ir, opts) {
+  return renderSegments(ir.analyses.segments.weekday, function name(value) {
+    return getWeekday(value, opts);
+  }, opts);
+}
+function renderSegments(segments, word, opts) {
+  const pieces = [];
+  segments.forEach(function expand(segment) {
+    if (segment.kind === "step") {
+      pieces.push(...segment.fires.map(word));
+    } else if (segment.kind === "range") {
+      pieces.push(segment.bounds.map(word).join(through(opts)));
+    } else {
+      pieces.push(word(segment.value));
+    }
+  });
+  return joinList(pieces, opts);
+}
+function isOpenStep(field) {
+  return field.indexOf("/") !== -1 && field.indexOf("-") === -1 && field.indexOf(",") === -1;
+}
+function applyYear(description, ir, opts) {
+  const yearField = ir.pattern.year;
+  if (yearField === "*") {
+    return description;
+  }
+  if (yearField.indexOf("/") !== -1) {
+    return description + " " + stepYears(yearField, opts);
+  }
+  const label = yearLabel(yearField, opts);
+  if (yearField.indexOf("-") === -1 && yearField.indexOf(",") === -1 && ir.pattern.date !== "*" && description.indexOf(" at ") !== -1) {
+    const yearGlue = opts.style.dayFirst ? " " : ", ";
+    return description.replace(" at ", yearGlue + label + " at ");
+  }
+  return description + " in " + label;
+}
+function yearLabel(yearField, opts) {
+  if (yearField.indexOf(",") !== -1) {
+    return joinList(yearField.split(","), opts);
+  }
+  return yearField;
+}
+function stepYears(yearField, opts) {
+  const parts = yearField.split("/");
+  const interval = +parts[1];
+  const start = parts[0];
+  if (interval <= 1) {
+    return "every year";
+  }
+  let phrase = "every " + getNumber(interval, opts) + " years";
+  if (start !== "*" && start !== "0") {
+    phrase += " from " + start;
+  }
+  return phrase;
+}
+function getTime(time, opts) {
+  const { hour, minute, plain } = time;
+  const second = typeof time.second === "number" && time.second > 0 ? time.second : 0;
+  if (!opts.ampm) {
+    return clockDigits({
+      hour,
+      minute,
+      second
+    }, { pad: true, sep: opts.style.sep });
+  }
+  return twelveHourTime({ hour, minute, second, plain }, opts);
+}
+function twelveHourTime(time, opts) {
+  const { hour, minute, second, plain } = time;
+  const style = opts.style;
+  if (!plain && +minute === 0 && !second) {
+    if (+hour === 0) {
+      return style.midnight;
+    }
+    if (+hour === 12) {
+      return style.midday;
+    }
+  }
+  const digits = clockDigits(
+    { hour: hour % 12 || 12, minute, second },
+    { lean: true, sep: style.sep }
+  );
+  return digits + (style.closeUp ? "" : " ") + (hour < 12 ? style.am : style.pm);
+}
+function getNumber(n, opts) {
+  return numeral(n, numbers, opts);
+}
+function pluralize(value, unit) {
+  return +value === 1 ? unit : unit + "s";
+}
+function through(opts) {
+  return opts.short ? "-" : opts.style.through;
+}
+function getOrdinal(n) {
+  let m = Math.abs(n);
+  let suffix = suffixes[m];
+  if (!suffix) {
+    m = (m % 100 - 20) % 10;
+    suffix = suffixes[m] || suffixes[0];
+  }
+  return n + suffix;
+}
+function getMonth(m, opts) {
+  const month = monthNames[m] || monthAbbreviations[m];
+  return month && month[opts.short ? 1 : 0];
+}
+function getWeekday(d, opts) {
+  const day = d === 7 || d === "7" ? 0 : d;
+  const weekday = weekdayNames[day] || weekdayAbbreviations[day];
+  return weekday && weekday[opts.short ? 1 : 0];
+}
+var en = {
+  describe,
+  fallback: "an unrecognizable cron pattern",
+  options: normalizeOptions,
+  reboot: "at system startup",
+  sentence: (description) => "Runs " + description + "."
+};
+var index_default = en;
+module.exports = module.exports.default;