cronli5 0.0.0-beta.6 → 0.1.0

package/dist/cronli5.cjs

@@ -0,0 +1,1556 @@
+"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/cronli5.ts
+var cronli5_exports = {};
+__export(cronli5_exports, {
+  default: () => cronli5_default
+});
+module.exports = __toCommonJS(cronli5_exports);
+
+// src/core/specs.ts
+var weekdayNumbers = {
+  SUN: 0,
+  MON: 1,
+  TUE: 2,
+  WED: 3,
+  THU: 4,
+  FRI: 5,
+  SAT: 6
+};
+var monthNumbers = {
+  JAN: 1,
+  FEB: 2,
+  MAR: 3,
+  APR: 4,
+  MAY: 5,
+  JUN: 6,
+  JUL: 7,
+  AUG: 8,
+  SEP: 9,
+  OCT: 10,
+  NOV: 11,
+  DEC: 12
+};
+var fieldSpecs = {
+  second: { cyclic: true, max: 59, min: 0, top: 59 },
+  minute: { cyclic: true, max: 59, min: 0, top: 59 },
+  hour: { cyclic: true, max: 23, min: 0, top: 23 },
+  date: { aliases: { "?": "*" }, cyclic: true, max: 31, min: 1, top: 31 },
+  month: { cyclic: true, max: 12, min: 1, numbers: monthNumbers, top: 12 },
+  weekday: {
+    aliases: { "?": "*", L: "6" },
+    cyclic: true,
+    max: 7,
+    min: 0,
+    numbers: weekdayNumbers,
+    top: 6
+  },
+  year: { max: 9999, min: 1970 }
+};
+var fieldOrder = [
+  "second",
+  "minute",
+  "hour",
+  "date",
+  "month",
+  "weekday",
+  "year"
+];
+var macros = {
+  "@annually": "0 0 1 1 *",
+  "@yearly": "0 0 1 1 *",
+  "@monthly": "0 0 1 * *",
+  "@weekly": "0 0 * * 0",
+  "@daily": "0 0 * * *",
+  "@midnight": "0 0 * * *",
+  "@hourly": "0 * * * *"
+};
+var maxClockTimes = 6;
+
+// src/core/util.ts
+function includes(str, sub) {
+  return ("" + str).indexOf(sub) !== -1;
+}
+function unique(items) {
+  return Array.from(new Set(items));
+}
+function isNonNegativeInteger(value) {
+  const digits = /^\d+$/;
+  return digits.test(value);
+}
+function toFieldNumber(token, numberMap) {
+  return isNonNegativeInteger(token) ? +token : numberMap[token.toUpperCase()];
+}
+
+// src/core/validate.ts
+function validateCronPattern(cronPattern) {
+  fieldOrder.forEach(function validate(field) {
+    validateField(cronPattern[field], fieldSpecs[field], field);
+  });
+  return cronPattern;
+}
+function validateField(value, spec, field) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    throwInvalidField(value, field);
+  }
+  const stringValue = "" + value;
+  if (stringValue === "*") {
+    return;
+  }
+  if (field === "date" && isQuartzDate(stringValue) || field === "weekday" && isQuartzWeekday(stringValue, spec)) {
+    return;
+  }
+  stringValue.split(",").forEach(function check(segment) {
+    if (!isValidSegment(segment, spec)) {
+      throwInvalidField(segment, field);
+    }
+  });
+}
+function isQuartzDate(value) {
+  if (value === "L" || value === "LW" || value === "WL") {
+    return true;
+  }
+  const offset = /^L-(\d{1,2})$/.exec(value);
+  if (offset) {
+    return +offset[1] >= 1 && +offset[1] <= 30;
+  }
+  const nearest = /^(\d{1,2})W$|^W(\d{1,2})$/.exec(value);
+  if (nearest) {
+    const day = +(nearest[1] || nearest[2]);
+    return day >= 1 && day <= 31;
+  }
+  return false;
+}
+function isQuartzWeekday(value, spec) {
+  if (/L$/.test(value)) {
+    return isValidSingle(value.slice(0, -1), spec);
+  }
+  const parts = value.split("#");
+  if (parts.length === 2) {
+    return isValidSingle(parts[0], spec) && /^[1-5]$/.test(parts[1]);
+  }
+  return false;
+}
+function isValidSegment(segment, spec) {
+  if (includes(segment, "/")) {
+    return isValidStep(segment, spec);
+  }
+  if (includes(segment, "-")) {
+    return isValidRange(segment, spec);
+  }
+  return isValidSingle(segment, spec);
+}
+function isValidStep(segment, spec) {
+  const parts = segment.split("/");
+  if (parts.length !== 2 || !isNonNegativeInteger(parts[1]) || +parts[1] < 1) {
+    return false;
+  }
+  return parts[0] === "*" || isValidSingle(parts[0], spec) || isValidRange(parts[0], spec, true);
+}
+function isValidRange(segment, spec, requireOrdered) {
+  const parts = segment.split("-");
+  if (parts.length !== 2) {
+    return false;
+  }
+  if (!isValidSingle(parts[0], spec) || !isValidSingle(parts[1], spec)) {
+    return false;
+  }
+  if (spec.cyclic && !requireOrdered) {
+    return true;
+  }
+  return toFieldNumber(parts[0], spec.numbers) <= toFieldNumber(parts[1], spec.numbers);
+}
+function isValidSingle(value, spec) {
+  if (value === "*") {
+    return false;
+  }
+  if (isNonNegativeInteger(value)) {
+    return +value >= spec.min && +value <= spec.max;
+  }
+  if (spec.numbers) {
+    return value.toUpperCase() in spec.numbers;
+  }
+  return false;
+}
+function throwInvalidField(value, field) {
+  throw new Error('`cronli5` was passed an invalid field value "' + value + '" for the ' + field + " field.");
+}
+
+// src/core/normalize.ts
+function applyQuartzAliases(cronPattern) {
+  fieldOrder.forEach(function apply(field) {
+    const aliases = fieldSpecs[field].aliases;
+    const alias = aliases && aliases["" + cronPattern[field]];
+    if (alias) {
+      cronPattern[field] = alias;
+    }
+  });
+}
+function normalizeCronPattern(cronPattern) {
+  fieldOrder.forEach(function normalize(field) {
+    const value = "" + cronPattern[field];
+    if (field === "date" && isQuartzDate(value) || field === "weekday" && isQuartzWeekday(value, fieldSpecs[field])) {
+      cronPattern[field] = value;
+      return;
+    }
+    cronPattern[field] = normalizeField(value, fieldSpecs[field]);
+  });
+  return cronPattern;
+}
+function normalizeField(value, spec) {
+  const stringValue = "" + value;
+  if (stringValue === "*") {
+    return stringValue;
+  }
+  const segments = stringValue.split(",").map(function canonical(segment) {
+    return collapseDegenerateRange(
+      collapseOnceStep(collapseUnitStep(segment, spec), spec),
+      spec
+    );
+  });
+  if (segments.indexOf("*") !== -1) {
+    return "*";
+  }
+  return unique(segments).sort(function ascending(a, b) {
+    return firstFire(a, spec) - firstFire(b, spec);
+  }).join(",");
+}
+function collapseUnitStep(segment, spec) {
+  const parts = segment.split("/");
+  if (!spec.cyclic || parts.length !== 2 || +parts[1] !== 1) {
+    return segment;
+  }
+  const start = parts[0];
+  if (includes(start, "-")) {
+    return start;
+  }
+  if (start === "*" || toFieldNumber(start, spec.numbers) === spec.min) {
+    return "*";
+  }
+  return start + "-" + spec.top;
+}
+function collapseOnceStep(segment, spec) {
+  const parts = segment.split("/");
+  if (!spec.cyclic || typeof spec.top !== "number" || parts.length !== 2 || includes(parts[0], "-")) {
+    return segment;
+  }
+  const start = parts[0];
+  const first = start === "*" ? spec.min : toFieldNumber(start, spec.numbers);
+  if (first + +parts[1] <= spec.top) {
+    return segment;
+  }
+  return start === "*" ? "" + spec.min : start;
+}
+function collapseDegenerateRange(segment, spec) {
+  const start = segment.split("/")[0];
+  if (!includes(start, "-")) {
+    return segment;
+  }
+  const bounds = start.split("-");
+  if (toFieldNumber(bounds[0], spec.numbers) !== toFieldNumber(bounds[1], spec.numbers)) {
+    return segment;
+  }
+  return bounds[0];
+}
+function firstFire(segment, spec) {
+  const start = segment.split("/")[0].split("-")[0];
+  return start === "*" ? spec.min : toFieldNumber(start, spec.numbers);
+}
+
+// src/core/parse.ts
+function parseCronPattern(cronPattern, opts) {
+  const isArray = cronPattern instanceof Array;
+  const isEmpty = cronPattern === null || typeof cronPattern === "undefined" || cronPattern === "" || isArray && cronPattern.length === 0;
+  if (isEmpty) {
+    throw new Error(
+      "`cronli5` expects a non-empty cron pattern as the first argument."
+    );
+  }
+  if (isArray) {
+    return cronifyArray(cronPattern, opts);
+  }
+  if (typeof cronPattern === "object") {
+    return cronifyObject(cronPattern);
+  }
+  if (typeof cronPattern === "string") {
+    return cronifyString(cronPattern, opts);
+  }
+  throw new Error("`cronli5` was passed an unexpected type.");
+}
+function cronifyArray(cronlikeArray, opts) {
+  if (cronlikeArray.length > 7) {
+    throw new Error(
+      "`cronli5` was passed a cron pattern with more than seven fields."
+    );
+  }
+  if (!opts.seconds && cronlikeArray.length < (opts.years ? 7 : 6)) {
+    cronlikeArray.unshift("0");
+  }
+  return {
+    second: cronlikeArray[0] || "0",
+    minute: cronlikeArray[1] || "*",
+    hour: cronlikeArray[2] || "*",
+    date: cronlikeArray[3] || "*",
+    month: cronlikeArray[4] || "*",
+    weekday: cronlikeArray[5] || "*",
+    year: cronlikeArray[6] || "*"
+  };
+}
+function cronifyObject(cronable) {
+  if (!cronable.second && !cronable.minute && !cronable.hour) {
+    throw new Error(
+      "`cronli5` expects that any object being interpreted as a cron pattern have at least one of the following properties: `second`, `minute`, or `hour`"
+    );
+  }
+  const hasSecond = typeof cronable.second !== "undefined";
+  const hasMinute = typeof cronable.minute !== "undefined";
+  const defaultMinute = hasSecond ? "*" : "0";
+  const defaultHour = hasSecond || hasMinute ? "*" : "0";
+  return {
+    second: pick(cronable.second, "0"),
+    minute: pick(cronable.minute, defaultMinute),
+    hour: pick(cronable.hour, defaultHour),
+    date: pick(cronable.date, "*"),
+    month: pick(cronable.month, "*"),
+    weekday: pick(cronable.weekday, "*"),
+    year: pick(cronable.year, "*")
+  };
+}
+function pick(value, fallback) {
+  return typeof value === "undefined" ? fallback : value;
+}
+function cronifyString(cronString, opts) {
+  const cronlikeArray = expandMacro(cronString).split(/\s+/);
+  return cronifyArray(cronlikeArray, opts);
+}
+function expandMacro(cronString) {
+  const trimmed = cronString.trim();
+  if (trimmed.charAt(0) !== "@") {
+    return cronString;
+  }
+  const macro = trimmed.toLowerCase();
+  if (Object.hasOwn(macros, macro)) {
+    return macros[macro];
+  }
+  throw new Error("`cronli5` does not recognize the macro `" + trimmed + "`.");
+}
+
+// src/core/shapes.ts
+function isSingleValue(field) {
+  return field !== "*" && !includes(field, ",") && !includes(field, "-") && !includes(field, "/");
+}
+function isPlainRange(field) {
+  return includes(field, "-") && !includes(field, ",") && !includes(field, "/");
+}
+function isPlainStep(field) {
+  return includes(field, "/") && !includes(field, ",");
+}
+function isDiscreteList(field) {
+  return field !== "*" && !includes(field, "-") && !includes(field, "/");
+}
+function isDiscreteHours(hourField) {
+  return hourField !== "*" && !isPlainRange(hourField) && !isPlainStep(hourField);
+}
+
+// src/core/analyze.ts
+function getOccurrences(start, interval, max) {
+  const occurrences = [];
+  let value = start;
+  while (value <= max) {
+    occurrences.push(value);
+    value += interval;
+  }
+  return occurrences;
+}
+function enumerateStep(field, min, max, numberMap) {
+  const parts = field.split("/");
+  const interval = +parts[1];
+  if (includes(parts[0], "-")) {
+    const bounds = parts[0].split("-");
+    return getOccurrences(
+      toFieldNumber(bounds[0], numberMap),
+      interval,
+      toFieldNumber(bounds[1], numberMap)
+    );
+  }
+  const start = parts[0] === "*" ? min : toFieldNumber(parts[0], numberMap);
+  return getOccurrences(start, interval, max);
+}
+function enumerateFires(field, min, max) {
+  const fires = [];
+  field.split(",").forEach(function expand(segment) {
+    if (includes(segment, "/")) {
+      fires.push(...enumerateStep(segment, min, max));
+    } else if (includes(segment, "-")) {
+      const bounds = segment.split("-");
+      if (+bounds[0] <= +bounds[1]) {
+        fires.push(...getOccurrences(+bounds[0], 1, +bounds[1]));
+      } else {
+        fires.push(...getOccurrences(+bounds[0], 1, max));
+        fires.push(...getOccurrences(min, 1, +bounds[1]));
+      }
+    } else {
+      fires.push(+segment);
+    }
+  });
+  return unique(fires);
+}
+function enumerateValues(field) {
+  if (!isDiscreteList(field)) {
+    return [0];
+  }
+  return field.split(",").map(Number);
+}
+function minuteSpan(minuteField) {
+  if (minuteField === "*") {
+    return [0, 59];
+  }
+  if (isPlainRange(minuteField)) {
+    const bounds = minuteField.split("-");
+    if (+bounds[0] <= +bounds[1]) {
+      return [+bounds[0], +bounds[1]];
+    }
+  }
+  return null;
+}
+function lastMinuteFire(minuteField) {
+  if (minuteField === "*") {
+    return 59;
+  }
+  return Math.max(...enumerateFires(minuteField, 0, 59));
+}
+function clockSecond(secondField) {
+  if (isSingleValue(secondField) && secondField !== "0") {
+    return +secondField;
+  }
+}
+function fieldShape(value, field) {
+  if (value === "*") {
+    return "wildcard";
+  }
+  if (field === "date" && isQuartzDate(value) || field === "weekday" && isQuartzWeekday(value, fieldSpecs.weekday)) {
+    return "quartz";
+  }
+  if (includes(value, ",")) {
+    return "list";
+  }
+  if (includes(value, "/")) {
+    return "step";
+  }
+  if (includes(value, "-")) {
+    return "range";
+  }
+  return "single";
+}
+function fieldSegments(value, shape, spec) {
+  if (shape === "wildcard" || shape === "quartz") {
+    return null;
+  }
+  return value.split(",").map(function classify(segment) {
+    if (includes(segment, "/")) {
+      const parts = segment.split("/");
+      return {
+        // Only the named/cyclic fields are segmented this way; `top` is
+        // always present for them (year has no segmentable step form).
+        fires: enumerateStep(
+          segment,
+          spec.min,
+          spec.top,
+          spec.numbers
+        ),
+        interval: +parts[1],
+        kind: "step",
+        startToken: parts[0]
+      };
+    }
+    if (includes(segment, "-")) {
+      return { bounds: segment.split("-"), kind: "range" };
+    }
+    return { kind: "single", value: segment };
+  });
+}
+function analyze(pattern) {
+  const shapes = {};
+  const segments = {};
+  fieldOrder.forEach(function classify(field) {
+    shapes[field] = fieldShape(pattern[field], field);
+    segments[field] = fieldSegments(
+      pattern[field],
+      shapes[field],
+      fieldSpecs[field]
+    );
+  });
+  const analyses = {
+    clockSecond: clockSecond(pattern.second),
+    lastMinuteFire: lastMinuteFire(pattern.minute),
+    minuteSpan: minuteSpan(pattern.minute),
+    segments
+  };
+  const content = { analyses, pattern, shapes };
+  return { ...content, plan: selectStrategy(content) };
+}
+function selectStrategy(content) {
+  const { analyses, pattern, shapes } = content;
+  if (pattern.second !== "0") {
+    const seconds = planSeconds(pattern, shapes, analyses);
+    if (seconds) {
+      return seconds;
+    }
+  }
+  return planMinutes(pattern, shapes, analyses) || planHours(pattern, shapes, analyses);
+}
+function planSeconds(pattern, shapes, analyses) {
+  const standalone = planStandaloneSeconds(pattern, shapes);
+  if (standalone) {
+    return standalone;
+  }
+  if (pattern.hour === "*" && shapes.minute === "single" && pattern.second !== "*") {
+    return {
+      kind: "secondsWithinMinute",
+      singleSecond: shapes.second === "single"
+    };
+  }
+  if (shapes.second === "single" && isDiscreteList(pattern.minute) && isDiscreteHours(pattern.hour)) {
+    return null;
+  }
+  return {
+    kind: "composeSeconds",
+    rest: planMinutes(pattern, shapes, analyses) || planHours(pattern, shapes, analyses)
+  };
+}
+function planStandaloneSeconds(pattern, shapes) {
+  if (pattern.minute !== "*" || pattern.hour !== "*") {
+    return null;
+  }
+  if (pattern.second === "*") {
+    return { kind: "everySecond" };
+  }
+  if (shapes.second === "single") {
+    return { kind: "secondPastMinute" };
+  }
+  return { kind: "standaloneSeconds" };
+}
+function planMinutes(pattern, shapes, analyses) {
+  if (shapes.minute === "step") {
+    return {
+      hours: planFrequencyHours(pattern, shapes, analyses),
+      kind: "minuteFrequency"
+    };
+  }
+  if (shapes.hour === "single" && analyses.minuteSpan) {
+    return {
+      hour: +pattern.hour,
+      kind: "minuteSpanInHour",
+      span: analyses.minuteSpan
+    };
+  }
+  const acrossHours = planMinutesAcrossHours(pattern, shapes);
+  if (acrossHours) {
+    return acrossHours;
+  }
+  const underStep = planMinuteUnderHourStep(pattern, shapes);
+  if (underStep) {
+    return underStep;
+  }
+  if (pattern.hour === "*") {
+    return planMinutesUnderOpenHour(pattern, shapes);
+  }
+}
+function cleanHourStride(hourField) {
+  const [start, step] = hourField.split("/");
+  const startHour = start === "*" ? 0 : +start;
+  return start.indexOf("-") === -1 && 24 % +step === 0 && startHour < +step;
+}
+function planMinuteUnderHourStep(pattern, shapes) {
+  if (shapes.hour !== "step") {
+    return null;
+  }
+  if (pattern.minute === "*") {
+    return cleanHourStride(pattern.hour) ? { form: "wildcard", kind: "minuteSpanAcrossHourStep" } : {
+      form: "wildcard",
+      kind: "minutesAcrossHours",
+      times: hourTimesPlan(pattern.hour)
+    };
+  }
+  if (shapes.minute === "range") {
+    return { form: "range", kind: "minuteSpanAcrossHourStep" };
+  }
+  return null;
+}
+function planFrequencyHours(pattern, shapes, analyses) {
+  if (shapes.hour === "list") {
+    return { kind: "during", times: hourTimesPlan(pattern.hour) };
+  }
+  if (shapes.hour === "range") {
+    const bounds = pattern.hour.split("-");
+    return {
+      from: +bounds[0],
+      kind: "window",
+      last: analyses.lastMinuteFire,
+      to: +bounds[1]
+    };
+  }
+  if (shapes.hour === "single") {
+    return {
+      from: +pattern.hour,
+      kind: "window",
+      last: analyses.lastMinuteFire,
+      to: +pattern.hour
+    };
+  }
+  if (shapes.hour === "step") {
+    return cleanHourStride(pattern.hour) ? { kind: "step" } : { kind: "during", times: hourTimesPlan(pattern.hour) };
+  }
+  return { kind: "none" };
+}
+function planMinutesAcrossHours(pattern, shapes) {
+  if (!isDiscreteHours(pattern.hour)) {
+    return null;
+  }
+  if (pattern.minute === "*") {
+    return {
+      form: "wildcard",
+      kind: "minutesAcrossHours",
+      times: hourTimesPlan(pattern.hour)
+    };
+  }
+  if (shapes.minute === "range" || shapes.minute === "list" && includes(pattern.minute, "-") && !includes(pattern.minute, "/")) {
+    return {
+      form: shapes.minute === "range" ? "range" : "list",
+      kind: "minutesAcrossHours",
+      times: hourTimesPlan(pattern.hour)
+    };
+  }
+  return null;
+}
+function planMinutesUnderOpenHour(pattern, shapes) {
+  if (shapes.minute === "range") {
+    return { kind: "rangeOfMinutes" };
+  }
+  if (shapes.minute === "list") {
+    return { kind: "multipleMinutes" };
+  }
+  if (pattern.minute === "*") {
+    return { kind: "everyMinute" };
+  }
+  if (pattern.minute !== "0") {
+    return { kind: "singleMinute" };
+  }
+}
+function planHours(pattern, shapes, analyses) {
+  if (shapes.hour === "range") {
+    const bounds = pattern.hour.split("-");
+    let minuteForm = "lead";
+    if (pattern.minute === "*") {
+      minuteForm = "wildcard";
+    } else if (shapes.minute === "range") {
+      minuteForm = "range";
+    }
+    return {
+      from: +bounds[0],
+      kind: "hourRange",
+      last: analyses.lastMinuteFire,
+      minuteForm,
+      to: +bounds[1]
+    };
+  }
+  if (shapes.hour === "step" && pattern.minute === "0") {
+    return { kind: "hourStep" };
+  }
+  if (pattern.hour === "*") {
+    return { kind: "everyHour" };
+  }
+  return planClockTimes(pattern, analyses);
+}
+function planClockTimes(pattern, analyses) {
+  const hours = enumerateFires(pattern.hour, 0, 23);
+  const minutes = enumerateValues(pattern.minute);
+  if (hours.length * minutes.length > maxClockTimes) {
+    return {
+      fold: minutes.length === 1,
+      kind: "compactClockTimes",
+      minute: minutes[0]
+    };
+  }
+  const times = [];
+  hours.forEach(function eachHour(hour) {
+    minutes.forEach(function eachMinute(minute) {
+      times.push({ hour, minute, second: analyses.clockSecond });
+    });
+  });
+  return { kind: "clockTimes", times };
+}
+function hourTimesPlan(hourField) {
+  const fires = enumerateFires(hourField, 0, 23);
+  if (fires.length <= maxClockTimes) {
+    return { fires, kind: "fires" };
+  }
+  return { kind: "segments" };
+}
+
+// src/core/index.ts
+function prepare(cronPattern, opts) {
+  const pattern = parseCronPattern(cronPattern, opts);
+  applyQuartzAliases(pattern);
+  validateCronPattern(pattern);
+  return normalizeCronPattern(pattern);
+}
+
+// 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 en_default = en;
+
+// src/cronli5.ts
+function cronli5(cronPattern, options) {
+  const lang = options && options.lang || en_default;
+  const opts = lang.options(options);
+  if (!opts.lenient) {
+    return present(
+      interpretCronPattern(cronPattern, lang, opts),
+      lang,
+      options
+    );
+  }
+  try {
+    return present(
+      interpretCronPattern(cronPattern, lang, opts),
+      lang,
+      options
+    );
+  } catch {
+    return lang.fallback;
+  }
+}
+function present(description, lang, options) {
+  return options && options.sentence ? lang.sentence(description) : description;
+}
+function interpretCronPattern(cronPattern, lang, opts) {
+  if (typeof cronPattern === "string" && cronPattern.trim().toLowerCase() === "@reboot") {
+    return lang.reboot;
+  }
+  const ir = analyze(prepare(cronPattern, opts));
+  const plan = lang.strategy ? lang.strategy(ir, ir.plan) : ir.plan;
+  return lang.describe({ ...ir, plan }, opts);
+}
+var cronli5_default = cronli5;
+/**
+ * @license MIT, Copyright (c) 2026 Andrew Brož
+ */
+module.exports = module.exports.default;