cronli5 0.3.4 → 0.8.0

package/dist/lang/zh.cjs

@@ -59,13 +59,20 @@ function singleValues(segments) {
 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, cycle } = spec;
-  const tiles = cycle % interval === 0;
-  if (start === 0 && tiles) {
+  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 && tiles) {
+  if (start < interval && open) {
     return parts.offset();
   }
   return parts.bounded();
@@ -165,6 +172,35 @@ function resolveDialect(dialect) {
 // src/lang/zh/index.ts
 var UNITS = { hour: "\u5C0F\u65F6", minute: "\u5206\u949F", second: "\u79D2" };
 var WEEKDAYS = ["\u5468\u65E5", "\u5468\u4E00", "\u5468\u4E8C", "\u5468\u4E09", "\u5468\u56DB", "\u5468\u4E94", "\u5468\u516D"];
+var HANT = {
+  \u4E2A: "\u500B",
+  \u4ECE: "\u5F9E",
+  \u5185: "\u5167",
+  \u522B: "\u5225",
+  \u52A8: "\u52D5",
+  \u5355: "\u55AE",
+  \u53CC: "\u96D9",
+  \u540E: "\u5F8C",
+  \u542F: "\u555F",
+  \u5468: "\u9031",
+  \u6570: "\u6578",
+  \u65E0: "\u7121",
+  \u65F6: "\u6642",
+  \u70B9: "\u9EDE",
+  \u7EDF: "\u7D71",
+  \u8BC6: "\u8B58",
+  \u8FBE: "\u9054",
+  \u8FD0: "\u904B",
+  \u949F: "\u9418",
+  \u95F4: "\u9593"
+};
+function toVariant(text, variant) {
+  if (variant !== "Hant") {
+    return text;
+  }
+  return Array.from(text, (glyph) => HANT[glyph] ?? glyph).join("");
+}
+var activeVariant = "Hans";
 function joinAnd(items) {
   if (items.length < 2) {
     return items.join("");
@@ -177,7 +213,7 @@ function cadence(interval, unit) {
 function renderStride2(stride) {
   const { interval, start, last, cycle, unit, mark, anchor } = stride;
   const lead = anchor + "\u4ECE" + start + mark + "\u8D77" + cadence(interval, unit);
-  return renderStride({ start, interval, cycle }, {
+  return renderStride({ start, interval, last, cycle }, {
     bare: () => cadence(interval, unit),
     offset: () => lead,
     bounded: () => lead + "\uFF0C\u81F3" + last + mark
@@ -873,6 +909,9 @@ function hourCadenceApplies(schedule) {
   return hourCadenceText(schedule) !== null;
 }
 function describe(schedule, opts) {
+  return toVariant(describeHans(schedule, opts), opts.style.variant);
+}
+function describeHans(schedule, opts) {
   const { kind } = schedule.plan;
   const core = render(schedule, schedule.plan, opts);
   let composed = core;
@@ -901,21 +940,31 @@ function describe(schedule, opts) {
 }
 function normalizeOptions(options) {
   options = options || {};
+  const style = resolveDialect(options.dialect);
+  activeVariant = style.variant;
   return {
     ampm: typeof options.ampm === "boolean" ? options.ampm : false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
-    style: resolveDialect(options.dialect),
+    style,
     years: !!options.years
   };
 }
 var zh2 = {
   describe,
-  fallback: "\u65E0\u6CD5\u8BC6\u522B\u7684 cron \u8868\u8FBE\u5F0F",
+  // `reboot`/`fallback` are contract-fixed strings the core reads without
+  // `opts`; getters honor the variant `options()` latched, keeping the shared
+  // Language contract unchanged while the Traditional dialect still applies.
+  get fallback() {
+    return toVariant("\u65E0\u6CD5\u8BC6\u522B\u7684 cron \u8868\u8FBE\u5F0F", activeVariant);
+  },
   options: normalizeOptions,
-  reboot: "\u7CFB\u7EDF\u542F\u52A8\u65F6",
-  sentence: (description) => "\u8FD0\u884C\u65F6\u95F4\uFF1A" + description + "\u3002"
+  get reboot() {
+    return toVariant("\u7CFB\u7EDF\u542F\u52A8\u65F6", activeVariant);
+  },
+  sentence: (description) => toVariant("\u8FD0\u884C\u65F6\u95F4\uFF1A", activeVariant) + description + "\u3002"
 };
 var index_default = zh2;
 module.exports = module.exports.default;

package/dist/lang/zh.js

@@ -33,13 +33,20 @@ function singleValues(segments) {
 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, cycle } = spec;
-  const tiles = cycle % interval === 0;
-  if (start === 0 && tiles) {
+  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 && tiles) {
+  if (start < interval && open) {
     return parts.offset();
   }
   return parts.bounded();
@@ -139,6 +146,35 @@ function resolveDialect(dialect) {
 // src/lang/zh/index.ts
 var UNITS = { hour: "\u5C0F\u65F6", minute: "\u5206\u949F", second: "\u79D2" };
 var WEEKDAYS = ["\u5468\u65E5", "\u5468\u4E00", "\u5468\u4E8C", "\u5468\u4E09", "\u5468\u56DB", "\u5468\u4E94", "\u5468\u516D"];
+var HANT = {
+  \u4E2A: "\u500B",
+  \u4ECE: "\u5F9E",
+  \u5185: "\u5167",
+  \u522B: "\u5225",
+  \u52A8: "\u52D5",
+  \u5355: "\u55AE",
+  \u53CC: "\u96D9",
+  \u540E: "\u5F8C",
+  \u542F: "\u555F",
+  \u5468: "\u9031",
+  \u6570: "\u6578",
+  \u65E0: "\u7121",
+  \u65F6: "\u6642",
+  \u70B9: "\u9EDE",
+  \u7EDF: "\u7D71",
+  \u8BC6: "\u8B58",
+  \u8FBE: "\u9054",
+  \u8FD0: "\u904B",
+  \u949F: "\u9418",
+  \u95F4: "\u9593"
+};
+function toVariant(text, variant) {
+  if (variant !== "Hant") {
+    return text;
+  }
+  return Array.from(text, (glyph) => HANT[glyph] ?? glyph).join("");
+}
+var activeVariant = "Hans";
 function joinAnd(items) {
   if (items.length < 2) {
     return items.join("");
@@ -151,7 +187,7 @@ function cadence(interval, unit) {
 function renderStride2(stride) {
   const { interval, start, last, cycle, unit, mark, anchor } = stride;
   const lead = anchor + "\u4ECE" + start + mark + "\u8D77" + cadence(interval, unit);
-  return renderStride({ start, interval, cycle }, {
+  return renderStride({ start, interval, last, cycle }, {
     bare: () => cadence(interval, unit),
     offset: () => lead,
     bounded: () => lead + "\uFF0C\u81F3" + last + mark
@@ -847,6 +883,9 @@ function hourCadenceApplies(schedule) {
   return hourCadenceText(schedule) !== null;
 }
 function describe(schedule, opts) {
+  return toVariant(describeHans(schedule, opts), opts.style.variant);
+}
+function describeHans(schedule, opts) {
   const { kind } = schedule.plan;
   const core = render(schedule, schedule.plan, opts);
   let composed = core;
@@ -875,21 +914,31 @@ function describe(schedule, opts) {
 }
 function normalizeOptions(options) {
   options = options || {};
+  const style = resolveDialect(options.dialect);
+  activeVariant = style.variant;
   return {
     ampm: typeof options.ampm === "boolean" ? options.ampm : false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
-    style: resolveDialect(options.dialect),
+    style,
     years: !!options.years
   };
 }
 var zh2 = {
   describe,
-  fallback: "\u65E0\u6CD5\u8BC6\u522B\u7684 cron \u8868\u8FBE\u5F0F",
+  // `reboot`/`fallback` are contract-fixed strings the core reads without
+  // `opts`; getters honor the variant `options()` latched, keeping the shared
+  // Language contract unchanged while the Traditional dialect still applies.
+  get fallback() {
+    return toVariant("\u65E0\u6CD5\u8BC6\u522B\u7684 cron \u8868\u8FBE\u5F0F", activeVariant);
+  },
   options: normalizeOptions,
-  reboot: "\u7CFB\u7EDF\u542F\u52A8\u65F6",
-  sentence: (description) => "\u8FD0\u884C\u65F6\u95F4\uFF1A" + description + "\u3002"
+  get reboot() {
+    return toVariant("\u7CFB\u7EDF\u542F\u52A8\u65F6", activeVariant);
+  },
+  sentence: (description) => toVariant("\u8FD0\u884C\u65F6\u95F4\uFF1A", activeVariant) + description + "\u3002"
 };
 var index_default = zh2;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronli5",
-  "version": "0.3.4",
+  "version": "0.8.0",
   "description": "Cron Like I'm Five: A Cron to English Utility",
   "repository": {
     "type": "git",
@@ -37,6 +37,16 @@
       "import": "./dist/lang/fi.js",
       "require": "./dist/lang/fi.cjs"
     },
+    "./lang/fr": {
+      "types": "./types/lang/fr/index.d.ts",
+      "import": "./dist/lang/fr.js",
+      "require": "./dist/lang/fr.cjs"
+    },
+    "./lang/pt": {
+      "types": "./types/lang/pt/index.d.ts",
+      "import": "./dist/lang/pt.js",
+      "require": "./dist/lang/pt.cjs"
+    },
     "./lang/zh": {
       "types": "./types/lang/zh/index.d.ts",
       "import": "./dist/lang/zh.js",
@@ -61,6 +71,7 @@
     "build": "node scripts/build.mjs && npm run types",
     "docs": "node --import tsx scripts/docs.mjs",
     "conciseness": "node --import tsx tooling/scripts/conciseness.mjs",
+    "divergence": "node --import tsx tooling/scripts/cronstrue-divergence.mjs",
     "fuzz": "node --import tsx scripts/fuzz-lang.mjs",
     "lint": "eslint src test cli.js eslint.config.js scripts tooling/scripts",
     "metamorphic": "node --import tsx tooling/scripts/metamorphic.mjs",
@@ -75,7 +86,7 @@
     "prepublishOnly": "npm run lint && npm run typecheck && npm run test:types && npm run build && npm test"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "keywords": [
     "cron",

package/src/core/cadence.ts

@@ -94,28 +94,41 @@ interface StrideParts {
   bounded(): string;
 }
 
+// The last value a stride reaches within `[0, cycle)`: the largest value below
+// the cycle that is congruent to `start` modulo `interval`. A clean, full-field
+// stride runs to this tile; a bounded one (`a-b/n`) stops short of it, and that
+// shortfall is what distinguishes the open cadence from a bounded set.
+function lastTileOf(start: number, interval: number, cycle: number): number {
+  return cycle - 1 - (cycle - 1 - start) % interval;
+}
+
 // Choose the stride/cadence branch for a step over a `cycle`-long field and
-// emit the renderer's words for it. A clean stride from the top of the cycle
-// is the bare cadence; a uniform offset (start within the first interval, the
+// emit the renderer's words for it. A clean stride from the top of the cycle is
+// the bare cadence; a uniform offset (start within the first interval, the
 // interval still tiling the cycle) names only its start, since it wraps cleanly
-// with no distinct endpoint; a non-uniform stride (start >= interval, or an
-// interval that does not tile the cycle) pins both endpoints so the bounded,
-// non-wrapping set reads unambiguously. This is the one decision tree every
-// renderer's `renderStride`/`hourStrideCadence` shared (cycle 60 for
+// with no distinct endpoint; a non-uniform stride (start >= interval, an
+// interval that does not tile the cycle, or one whose last fire stops short of
+// the cycle's final tile — a bounded `a-b/n`) pins both endpoints so the
+// bounded, non-wrapping set reads unambiguously. This is the one decision tree
+// every renderer's `renderStride`/`hourStrideCadence` shared (cycle 60 for
 // minute/second, 24 for the hour); the branch lives here once, the prose in
 // each language's `parts`.
 function renderStride(
-  spec: {start: number; interval: number; cycle: number},
+  spec: {start: number; interval: number; last: number; cycle: number},
   parts: StrideParts
 ): string {
-  const {start, interval, cycle} = spec;
-  const tiles = cycle % interval === 0;
-
-  if (start === 0 && tiles) {
+  const {start, interval, last, cycle} = spec;
+  // A stride wraps the full field only when it both tiles the cycle and runs to
+  // the cycle's last tile; one that stops short (`0-20/2`, last 20 of 22) is a
+  // bounded set, not the open `*/n`, so it keeps its endpoint-pinning cadence.
+  const open = cycle % interval === 0 && last === lastTileOf(start, interval,
+    cycle);
+
+  if (start === 0 && open) {
     return parts.bare();
   }
 
-  if (start < interval && tiles) {
+  if (start < interval && open) {
     return parts.offset();
   }
 

package/src/core/index.ts

@@ -5,16 +5,20 @@
 
 import {applyQuartzAliases, normalizeCronPattern} from './normalize.js';
 import type {NormalizedOptions, Pattern} from './schedule.js';
+import {applyQuartz} from './quartz.js';
 import {parseCronPattern} from './parse.js';
 import type {CronPattern} from '../types.js';
 import {validateCronPattern} from './validate.js';
 
-// Parse, alias, validate, and normalize cron input into a canonical
-// cron-like object of string fields, ready for semantic analysis and
-// rendering.
+// Parse, apply Quartz semantics, alias, validate, and normalize cron input
+// into a canonical cron-like object of string fields, ready for semantic
+// analysis and rendering. Quartz handling runs first: it gates the `?` token
+// (rejected unless `quartz`) and re-indexes the Quartz day-of-week to the
+// canonical cron numbering the rest of the core expects.
 function prepare(cronPattern: CronPattern, opts: NormalizedOptions): Pattern {
   const pattern = parseCronPattern(cronPattern, opts);
 
+  applyQuartz(pattern, opts.quartz);
   applyQuartzAliases(pattern);
   validateCronPattern(pattern);
 

package/src/core/quartz.ts

@@ -0,0 +1,97 @@
+// Quartz input semantics. cronli5 accepts Quartz tokens (`?`, `L`, `W`, `#`),
+// but Quartz numbers the day-of-week differently from standard cron: Quartz is
+// 1 = Sunday … 7 = Saturday, while cron is 0/7 = Sunday, 1 = Monday. Reading a
+// Quartz pattern with cron indexing silently shifts every weekday by one, so a
+// Quartz `2` (Monday) would read as Tuesday. This module gates and re-indexes
+// the input so the rest of the core keeps facing canonical cron values.
+//
+// The `?` token (Quartz's "no specific value", mandatory in Quartz, absent in
+// standard cron) is the unambiguous mark of a Quartz pattern. Outside Quartz
+// mode it is rejected outright rather than aliased to `*`, so a real Quartz
+// cron errors loudly instead of being mis-read; inside Quartz mode it is the
+// equivalent of `*`.
+
+import type {CronLike} from './specs.js';
+import {isNonNegativeInteger} from './util.js';
+
+// The error a `?` raises outside Quartz mode: a clear pointer at the option
+// that makes Quartz semantics (and `?`) available.
+const quartzTokenMessage =
+  '`?` is a Quartz token — pass { quartz: true } to enable Quartz semantics.';
+
+// In standard (non-Quartz) mode, `?` is not a valid value: reject it with a
+// pointer at the `quartz` option. In Quartz mode, accept `?` as `*` and
+// re-index the day-of-week from Quartz numbering (1 = Sunday) to the canonical
+// cron numbering (0 = Sunday) the rest of the core expects. Operates in place
+// on the raw cron-like object, before aliasing and validation.
+function applyQuartz(cronPattern: CronLike, quartz: boolean): void {
+  if (!quartz) {
+    rejectQuartzToken(cronPattern.date);
+    rejectQuartzToken(cronPattern.weekday);
+
+    return;
+  }
+
+  if ('' + cronPattern.date === '?') {
+    cronPattern.date = '*';
+  }
+
+  if ('' + cronPattern.weekday === '?') {
+    cronPattern.weekday = '*';
+
+    return;
+  }
+
+  cronPattern.weekday = reindexWeekday('' + cronPattern.weekday);
+}
+
+// Throw the Quartz-token error if a field is exactly `?`.
+function rejectQuartzToken(value: string | number): void {
+  if ('' + value === '?') {
+    throw new Error(quartzTokenMessage);
+  }
+}
+
+// Re-index a Quartz day-of-week field to canonical cron numbering. Every
+// numeric weekday position maps n -> n-1 (Quartz 1 = Sunday becomes cron 0),
+// across singles, ranges, and step bounds, and inside the DOW operators `nL`
+// (last weekday) and `n#k` (kth weekday). Day NAMES (`MON`) are unambiguous and
+// left untouched, as is the bare `L` alias (Saturday in both numberings) and
+// `*`. Quartz has no weekday 0; it is rejected here.
+function reindexWeekday(value: string): string {
+  if (value === '*') {
+    return value;
+  }
+
+  return value.split(',').map(reindexSegment).join(',');
+}
+
+// Re-index one comma-separated weekday segment: a single, a range, or either
+// of those followed by a `#k` or `L` operator (or a `/step`).
+function reindexSegment(segment: string): string {
+  const operator = (/(#\d+|L)$/).exec(segment);
+  const suffix = operator ? operator[0] : '';
+  const core = suffix ? segment.slice(0, -suffix.length) : segment;
+  const step = core.split('/');
+  const range = step[0].split('-').map(reindexNumber).join('-');
+  const head = step.length === 2 ? range + '/' + step[1] : range;
+
+  return head + suffix;
+}
+
+// Re-index a single weekday token: a number maps n -> n-1 (rejecting 0, which
+// Quartz does not use); a name passes through unchanged.
+function reindexNumber(token: string): string {
+  if (!isNonNegativeInteger(token)) {
+    return token;
+  }
+
+  if (token === '0') {
+    throw new Error('`cronli5` was passed an invalid Quartz day-of-week ' +
+      'value "0"; Quartz numbers weekdays 1 (Sunday) through 7 (Saturday).');
+  }
+
+  return '' + (+token - 1);
+}
+
+export {applyQuartz, quartzTokenMessage};

package/src/core/schedule.ts

@@ -147,6 +147,7 @@ export interface DialectStyle {
 export interface NormalizedOptions<Style = DialectStyle> {
   ampm: boolean;
   lenient: boolean;
+  quartz: boolean;
   seconds: boolean;
   short: boolean;
   style: Style;

package/src/core/specs.ts

@@ -55,9 +55,9 @@ const fieldSpecs: Record<Field, FieldSpec> = {
   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},
+  date: {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,
+  weekday: {aliases: {L: '6'}, cyclic: true, max: 7, min: 0,
     numbers: weekdayNumbers, top: 6},
   year: {max: 9999, min: 1970}
 };

package/src/cronli5.ts

@@ -29,7 +29,7 @@
 
 import {analyze, prepare} from './core/index.js';
 import type {NormalizedOptions} from './core/schedule.js';
-import type {CronPattern, Cronli5Language, Cronli5Options}
+import type {Cronli5, CronPattern, Cronli5Language, Cronli5Options}
   from './types.js';
 import en from './lang/en/index.js';
 
@@ -88,8 +88,25 @@ function interpretCronPattern(
   return lang.describe({...schedule, plan}, opts);
 }
 
-export default cronli5;
+// Two named convenience methods are attached to the callable export as sugar
+// over the `sentence` option: `.sentence(...)` forces the capitalized
+// standalone, `.fragment(...)` forces the embeddable fragment (the default).
+// The method's own intent wins, so a passed-through `sentence` flag is
+// overridden. There is no `toString` method on purpose — it would shadow
+// `Function.prototype.toString` (called arg-less by `String()`, template
+// literals, and console/debug) and break coercion; named methods sidestep that.
+function sentence(cronPattern: CronPattern, options?: Cronli5Options): string {
+  return cronli5(cronPattern, {...options, sentence: true});
+}
+
+function fragment(cronPattern: CronPattern, options?: Cronli5Options): string {
+  return cronli5(cronPattern, {...options, sentence: false});
+}
+
+const callable: Cronli5 = Object.assign(cronli5, {sentence, fragment});
+
+export default callable;
 export type {
-  Cronli5Dialect, Cronli5Language, Cronli5Options, CronPattern,
+  Cronli5, Cronli5Dialect, Cronli5Language, Cronli5Options, CronPattern,
   CronPatternObject
 } from './types.js';

package/src/lang/de/index.ts

@@ -90,7 +90,7 @@ function renderStride(stride: Stride): string {
   // the cadence keeps its endpoints but drops the "jeder Stunde" tail.
   const tail = anchor ? ' ' + anchor : '';
 
-  return chooseStride({start, interval, cycle}, {
+  return chooseStride({start, interval, last, cycle}, {
     bare: () => cadence,
     offset: () => cadence + ' ab ' + unit.singular + ' ' + start + tail,
     bounded: () =>
@@ -1019,7 +1019,7 @@ function hourStrideCadence(
   const {start, interval, last} = stride;
   const cadence = everyN(interval, UNITS.hour);
 
-  return chooseStride({start, interval, cycle: 24}, {
+  return chooseStride({start, interval, last, cycle: 24}, {
     bare: () => cadence,
     offset: () => cadence + ' ab ' + start + ' Uhr',
     bounded: () => cadence + ' von ' + start + ' bis ' + last + ' Uhr'
@@ -1464,6 +1464,7 @@ function normalizeOptions(options?: Cronli5Options): Opts {
   return {
     ampm: typeof options.ampm === 'boolean' ? options.ampm : false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style,

package/src/lang/en/index.ts

@@ -137,6 +137,7 @@ function normalizeOptions(options?: Cronli5Options): NormalizedOptions {
   return {
     ampm: typeof options.ampm === 'boolean' ? options.ampm : true,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style: resolveDialect(options.dialect),
@@ -1313,7 +1314,7 @@ function renderStride(stride: Stride, opts: NormalizedOptions): string {
   const {interval, start, last, cycle, unit, anchor} = stride;
   const cadence = 'every ' + getNumber(interval, opts) + ' ' + unit + 's';
 
-  return chooseStride({start, interval, cycle}, {
+  return chooseStride({start, interval, last, cycle}, {
     bare: () => cadence,
 
     // A clean wrap from a non-zero offset: name the start, no endpoint.
@@ -1419,7 +1420,7 @@ function hourStrideCadence(stride: {start: number; interval: number;
   const {start, interval, last} = stride;
   const cadence = 'every ' + getNumber(interval, opts) + ' hours';
 
-  return chooseStride({start, interval, cycle: 24}, {
+  return chooseStride({start, interval, last, cycle: 24}, {
     bare: () => cadence,
     offset: () => cadence + ' from ' + getTime({hour: start, minute: 0}, opts),
     bounded: () =>

package/src/lang/es/index.ts

@@ -125,6 +125,7 @@ function normalizeOptions(options?: Cronli5Options): Opts {
     // 12-hour for Mexico/US); an explicit `{ampm}` option overrides it.
     ampm: typeof options.ampm === 'boolean' ? options.ampm : style.ampm,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style,
@@ -1326,7 +1327,7 @@ function renderStride(stride: Stride, opts: Opts): string {
   // the cadence keeps its endpoints but drops the "de cada <anchor>" tail.
   const tail = anchor ? ' de cada ' + anchor : '';
 
-  return chooseStride({start, interval, cycle}, {
+  return chooseStride({start, interval, last, cycle}, {
     bare: () => cadence,
     offset: () => cadence + ' a partir del ' + unit + ' ' + start + tail,
     bounded: () =>
@@ -1429,7 +1430,7 @@ function hourStrideCadence(
   const {start, interval, last} = stride;
   const cadence = 'cada ' + numero(interval, opts) + ' horas';
 
-  return chooseStride({start, interval, cycle: 24}, {
+  return chooseStride({start, interval, last, cycle: 24}, {
     bare: () => cadence,
     offset: () => cadence + ' a partir de ' + timePhrase(start, 0, null, opts),
     bounded: () => cadence + ' de ' + timePhrase(start, 0, null, opts) + ' a ' +

package/src/lang/fi/index.ts

@@ -200,6 +200,7 @@ function normalizeOptions(options?: Cronli5Options): NormalizedOptions {
   return {
     ampm: false,
     lenient: !!options.lenient,
+    quartz: !!options.quartz,
     seconds: !!options.seconds,
     short: !!options.short,
     style: resolveDialect(options.dialect),
@@ -1108,7 +1109,7 @@ function renderStride(stride: Stride, opts: NormalizedOptions): string {
   const {interval, start, last, cycle, unit} = stride;
   const cadence = genitive(interval, opts) + ' ' + unit.gen + ' välein';
 
-  return chooseStride({start, interval, cycle}, {
+  return chooseStride({start, interval, last, cycle}, {
     bare: () => cadence,
     offset: () =>
       cadence + ' ' + unit.anchor + ' ' + unit.ela + ' ' + start + ' alkaen',
@@ -1206,7 +1207,7 @@ function hourStrideCadence(
   const {start, interval, last} = stride;
   const cadence = genitive(interval, opts) + ' tunnin välein';
 
-  return chooseStride({start, interval, cycle: 24}, {
+  return chooseStride({start, interval, last, cycle: 24}, {
     bare: () => cadence,
     offset: () => cadence + ' klo ' + hourElatives[start] + ' alkaen',
     bounded: () => cadence + ' ' +

package/src/lang/fr/dialects.ts

@@ -0,0 +1,49 @@
+// French dialect style tables. Dialect names are language-scoped; the default
+// `fr` style is anchored to the fr-FR norm (Imprimerie nationale / Académie
+// française, plus cronstrue `fr`); see notes.md. Custom objects merge over the
+// `fr` defaults. fr-CA is a future dialect axis (notes.md §"Dialect axis"); no
+// regional dialect ships yet.
+import type {Cronli5Options} from '../../types.js';
+
+/**
+ * French's own resolved style shape: a separator and the spacing of the `h`
+ * clock mark. fr is 24-hour only, so there is no `ampm`/`meridiem` axis.
+ */
+export interface FrenchStyle {
+  // The mark between hour and minute on the default clock. fr-FR writes the
+  // typographic "h" ("9 h 30"); a custom style can opt into a colon or other
+  // separator ("9:30"), which replaces the spaced "h" form entirely.
+  sep: string;
+  // When `sep` is the default "h", whether to drop the surrounding spaces. The
+  // spaced "9 h 30" is the ratified fr-FR default; the unspaced "9h30" is the
+  // opt-in casual register (notes.md §Dialect axis).
+  unspaced: boolean;
+}
+
+// The fr-FR default: the spaced "h" clock mark.
+const fr: FrenchStyle = {
+  sep: 'h',
+  unspaced: false
+};
+
+// One `fr` table today = fr-FR. fr-CA is a future dialect axis (notes.md);
+// it would clear its own native panel before shipping, so it is not declared
+// here yet.
+const dialects: {[name: string]: FrenchStyle} = {
+  fr,
+  // France is the default; named explicitly so it is a recognized choice and
+  // has a home if it ever diverges.
+  'fr-FR': fr
+};
+
+// Resolve the `dialect` option to a style table.
+function resolveDialect(dialect: Cronli5Options['dialect']): FrenchStyle {
+  if (typeof dialect === 'object' && dialect !== null) {
+    return {...dialects.fr, ...dialect};
+  }
+
+  // A string dialect indexes the table; unknown names fall back to `fr`.
+  return dialects[dialect as string] || dialects.fr;
+}
+
+export {resolveDialect};