cron-converter-u2q 1.2.1 → 1.3.1

package/README.md

@@ -1,123 +1,93 @@
 # cron-converter-u2q
 
-[![Github Repo Stars](https://img.shields.io/github/stars/rahu619/cron-converter-u2q?style=social)](https://github.com/rahu619/cron-converter-u2q)
 [![NPM version](https://img.shields.io/npm/v/cron-converter-u2q)](https://www.npmjs.com/package/cron-converter-u2q)
+[![npm downloads](https://img.shields.io/npm/dm/cron-converter-u2q)](https://www.npmjs.com/package/cron-converter-u2q)
 [![GitHub License](https://img.shields.io/github/license/rahu619/cron-converter-u2q?style=plastic)](LICENSE)
 [![GitHub Build](https://github.com/rahu619/cron-converter-u2q/actions/workflows/integration.yml/badge.svg?branch=main)](https://github.com/rahu619/cron-converter-u2q/actions)
-[![Github Release](https://github.com/rahu619/cron-converter-u2q/actions/workflows/release.yml/badge.svg?event=workflow_dispatch)](https://github.com/rahu619/cron-converter-u2q/actions)
-[![Github Top Language](https://img.shields.io/github/languages/top/rahu619/cron-converter-u2q?style=plastic)](https://www.typescriptlang.org/)
-[![npm downloads](https://img.shields.io/npm/dm/cron-converter-u2q)](https://www.npmjs.com/package/cron-converter-u2q)
-
-[![https://nodei.co/npm/cron-converter-u2q.png?downloads=true&downloadRank=true&stars=true](https://nodei.co/npm/cron-converter-u2q.png?downloads=true&downloadRank=true&stars=true)](https://www.npmjs.com/package/cron-converter-u2q)
 
-A powerful TypeScript library for working with cron expressions. Effortlessly convert between Unix and Quartz formats, generate human-readable descriptions, and validate cron expressions with ease.
+A lightweight, zero-dependency TypeScript utility to convert, validate, and describe cron expressions. Seamlessly translate between Unix and Quartz schedules, perform boundary checks, and render human-readable descriptions.
 
-## ✨ Features
+---
 
-### 🔄 Two-way Conversion
-- **Unix to Quartz**: Convert standard Unix cron expressions to Quartz format
-- **Quartz to Unix**: Convert Quartz cron expressions to standard Unix format
-- **Format Validation**: Built-in validation for both formats
-- **Error Handling**: Clear error messages for invalid expressions
+## 💡 Unix vs. Quartz Cron
 
-### 📝 Human-readable Descriptions
-- **Natural Language**: Convert cron expressions to plain English
-- **Multiple Languages**: Support for different language descriptions
-- **Customizable**: Extend with your own description templates
-- **Detailed**: Includes all schedule details (minutes, hours, days, etc.)
+| Specification | Fields | Format | Support |
+| :--- | :--- | :--- | :--- |
+| **Unix Cron** | 5 fields | `min hour dom month dow` | Standard POSIX (Linux, Crontab) |
+| **Quartz Cron** | 6–7 fields | `sec min hour dom month dow [year]` | Java/Spring, AWS EventBridge, Azure |
 
-### 🛠️ Developer Friendly
-- **TypeScript Support**: Full type definitions included
-- **Zero Dependencies**: Lightweight and fast
-- **Well Tested**: Comprehensive test coverage
-- **ES6 Modules**: Support for both CommonJS and ES6 imports
+> [!NOTE]
+> Quartz cron requires exactly one of `day-of-month` or `day-of-week` to contain `?` (when specifying a constraint on the other field) to prevent scheduling conflicts.
 
-### 🔍 Validation & Error Handling
-- **Format Validation**: Ensures cron expressions are valid
-- **Range Checking**: Validates field values within acceptable ranges
-- **Clear Errors**: Descriptive error messages for debugging
-- **Type Safety**: TypeScript types for better development experience
+---
 
 ## 📦 Installation
 
 ```bash
-# Using npm
 npm install cron-converter-u2q
-
-# Using yarn
+# or
 yarn add cron-converter-u2q
-
-# Using pnpm
+# or
 pnpm add cron-converter-u2q
 ```
 
-## 🚀 Quick Start
+---
+
+## 🚀 Usage
+
+### 1. Two-Way Conversion
+Convert seamlessly between formats. Wildcards and aliases are normalized automatically.
 
 ```typescript
 import { CronConverterU2Q } from 'cron-converter-u2q';
 
-// Convert Unix to Quartz
-const quartzExpression = CronConverterU2Q.unixToQuartz('5 * * * *');
-console.log(quartzExpression); // "0 5 * * * ? *"
-
-// Convert Quartz to Unix
-const unixExpression = CronConverterU2Q.quartzToUnix('0 0 8 * * ?');
-console.log(unixExpression); // "0 8 * * *"
+// Unix -> Quartz (adds 0 seconds)
+CronConverterU2Q.unixToQuartz('*/15 * * * *');   // "0 */15 * * * * *"
+CronConverterU2Q.unixToQuartz('0 12 * * 1');     // "0 0 12 ? * 2 *"
 
-// Get human-readable description
-const description = CronConverterU2Q.describeUnix('*/5 * * * *');
-console.log(description); // "Every 5 minutes"
+// Quartz -> Unix (drops seconds/year)
+CronConverterU2Q.quartzToUnix('0 0 8 * * ?');    // "0 8 * * *"
+CronConverterU2Q.quartzToUnix('0 */5 * ? * 2');  // "*/5 * * * 1"
 ```
 
-## 📚 Examples
-
-### Basic Conversions
+### 2. Validation
+Perform boundary checks, detect syntax errors, and validate range limits.
 
 ```typescript
-// Unix to Quartz
-CronConverterU2Q.unixToQuartz('0 12 * * *');     // "0 0 12 * * ? *"
-CronConverterU2Q.unixToQuartz('*/15 * * * *');   // "0 */15 * * * ? *"
+import { CronValidatorU2Q } from 'cron-converter-u2q';
 
-// Quartz to Unix
-CronConverterU2Q.quartzToUnix('0 0 8 * * ?');    // "0 8 * * *"
-CronConverterU2Q.quartzToUnix('0 */5 * * * ?');  // "*/5 * * * *"
+// Validate and throw detailed error messages
+CronValidatorU2Q.validateUnix('60 * * * *');    // Throws: "Value 60 is out of range (0-59) for Minute"
+CronValidatorU2Q.validateQuartz('0 */0 * ? * *'); // Throws: "Invalid step value in Minute: 0"
+
+// Boolean check
+CronValidatorU2Q.isValidUnix('*/5 * * * *');    // true
+CronValidatorU2Q.isValidQuartz('0 0 12 * * * *'); // true (both are allowed to be '*' in this package)
 ```
 
-### Human-readable Descriptions
+### 3. Human-Readable Descriptions
+Render cron schedules into clear, natural English. Fully supports lists, ranges, step modifiers, and Quartz special symbols.
 
 ```typescript
-// Unix format descriptions
-CronConverterU2Q.describeUnix('0 12 * * *');     // "At 12:00 PM"
-CronConverterU2Q.describeUnix('*/15 * * * *');   // "Every 15 minutes"
+import { CronDescriberU2Q } from 'cron-converter-u2q';
+
+// Unix
+CronDescriberU2Q.describeUnix('*/15 * * * *');   // "Every 15 minutes"
+CronDescriberU2Q.describeUnix('0 12 1-5 * *');   // "At 12 o'clock from the 1st to the 5th of the month"
 
-// Quartz format descriptions
-CronConverterU2Q.describeQuartz('0 0 8 * * ?');  // "At 8:00 AM"
-CronConverterU2Q.describeQuartz('0 */5 * * * ?'); // "Every 5 minutes"
+// Quartz
+CronDescriberU2Q.describeQuartz('0 0 8,12 ? * 2-6 *'); // "At 8 and 12 o'clock from Monday to Friday"
+CronDescriberU2Q.describeQuartz('0 0 0 L * ?');        // "At 0 o'clock on the last day of the month"
 ```
 
+---
+
 ## 🤝 Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+Contributions are welcome! Please feel free to open issues or submit Pull Requests.
 
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add some amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
+---
 
 ## 📄 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 💬 Support
-
-- 📧 Email: rahu619@gmail.com
-- 💻 GitHub Issues: [Create an issue](https://github.com/rahu619/cron-converter-u2q/issues)
-- ⭐ Star the repository if you find it useful!
-
-## 🙏 Acknowledgments
-
-- Thanks to all contributors who have helped shape this project
-- Inspired by the need for a simple, reliable cron expression converter
-- Built with TypeScript for better developer experience
-
+This project is licensed under the MIT License.

package/lib/converter.d.ts

@@ -1,7 +1,4 @@
 export declare class CronConverterU2Q {
-    static readonly delimiter = " ";
-    static readonly unixExpressionLength = 5;
-    static readonly quartzExpressionLengths: number[];
     /**
      * Converts a unix cron expression to a quartz cron expression by adding '0' seconds
      * @param unixExpression - the unix expression
@@ -14,5 +11,21 @@ export declare class CronConverterU2Q {
      * @returns the corresponding unix expression
      */
     static quartzToUnix(quartzExpression: string): string;
-    private static validateIfNullOrEmpty;
+    /**
+     * Converts interval parts for both Unix and Quartz expressions.
+     * In both directions, normalises step notation to the Unix `*\/N` format.
+     */
+    private static convertIntervalParts;
+    /**
+     * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     */
+    private static unixDowToQuartz;
+    /**
+     * Converts Quartz DOW to Unix DOW, supporting lists, ranges, and special cases.
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat
+     */
+    static quartzDowToUnix(dow: string): string;
 }

package/lib/converter.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CronConverterU2Q = void 0;
+const helper_1 = require("./helper");
+const validator_1 = require("./validator");
 class CronConverterU2Q {
     /**
      * Converts a unix cron expression to a quartz cron expression by adding '0' seconds
@@ -8,18 +10,21 @@ class CronConverterU2Q {
      * @returns the corresponding quartz expression
      */
     static unixToQuartz(unixExpression) {
-        this.validateIfNullOrEmpty(unixExpression);
-        const parts = unixExpression.split(this.delimiter);
-        if (parts.length !== this.unixExpressionLength)
-            throw new Error(`Invalid unix cron format`);
-        const [min, hour, dom, month, dow] = parts;
+        validator_1.CronValidatorU2Q.validateUnix(unixExpression);
+        const parts = helper_1.ExpressionHelper.GetExpressionParts(unixExpression);
+        const [min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part));
+        // Enhanced DOW conversion: handle lists, ranges, and special cases
+        let quartzDow = this.unixDowToQuartz(dow);
         let quartzDom = dom;
-        let quartzDow = dow;
-        if (dom === '*' && (dow === '*' || dow !== '*'))
+        // Per Quartz spec, exactly one of DOM or DOW must be '?'
+        // When DOM is '*' and DOW is specific, DOM gets '?'; otherwise DOW gets '?'
+        if (dom === '*' && dow !== '*') {
             quartzDom = '?';
-        else if (dom !== '*' && dow === '*')
+        }
+        else if (dom !== '*' && dow === '*') {
             quartzDow = '?';
-        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow}`;
+        }
+        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow} *`;
     }
     /**
      * Converts a quartz cron expression to a unix cron expression
@@ -27,27 +32,87 @@ class CronConverterU2Q {
      * @returns the corresponding unix expression
      */
     static quartzToUnix(quartzExpression) {
-        this.validateIfNullOrEmpty(quartzExpression);
-        const parts = quartzExpression.split(this.delimiter);
-        if (!this.quartzExpressionLengths.includes(parts.length))
-            throw new Error(`Invalid quartz cron format`);
-        const [_, min, hour, dom, month, dow] = parts;
-        let unixDom = dom;
-        let unixDow = dow;
-        if (dom === '?' && dow === '*')
-            unixDom = '*';
-        else if (dow === '?' && dom === '*')
-            unixDow = '*';
-        else if (dom !== '?' && dom === '?')
-            unixDom = '*';
+        validator_1.CronValidatorU2Q.validateQuartz(quartzExpression);
+        const parts = helper_1.ExpressionHelper.GetExpressionParts(quartzExpression);
+        const [_, min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part, true));
+        if (dom.includes('L') || dom.includes('W')) {
+            throw new Error("Unix cron does not support 'L' or 'W' in Day of Month");
+        }
+        if (dow.includes('L') || dow.includes('#')) {
+            throw new Error("Unix cron does not support 'L' or '#' in Day of Week");
+        }
+        // Enhanced DOW conversion: handle lists, ranges, and special cases
+        let unixDow = this.quartzDowToUnix(dow);
+        let unixDom = dom === '?' ? '*' : dom;
         return `${min} ${hour} ${unixDom} ${month} ${unixDow}`;
     }
-    static validateIfNullOrEmpty(cronExpression) {
-        if (!cronExpression || cronExpression.trim() === '')
-            throw new Error('Empty or null expression');
+    /**
+     * Converts interval parts for both Unix and Quartz expressions.
+     * In both directions, normalises step notation to the Unix `*\/N` format.
+     */
+    static convertIntervalParts(part, isQuartz = false) {
+        if (isQuartz) {
+            return part.replace(/^0\/(\d+)$/, '*/$1');
+        }
+        return part;
+    }
+    /**
+     * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     */
+    static unixDowToQuartz(dow) {
+        if (dow === '*' || dow === '?')
+            return dow;
+        if (dow.includes(','))
+            return dow.split(',').map(d => this.unixDowToQuartz(d)).join(',');
+        if (dow.includes('-'))
+            return dow.split('-').map(d => this.unixDowToQuartz(d)).join('-');
+        if (dow.endsWith('L')) {
+            const day = dow.slice(0, -1);
+            return `${this.unixDowToQuartz(day)}L`;
+        }
+        if (dow.includes('#')) {
+            const [day, nth] = dow.split('#');
+            return `${this.unixDowToQuartz(day)}#${nth}`;
+        }
+        if (dow === '0' || dow === '7')
+            return '1'; // Sunday
+        const num = parseInt(dow, 10);
+        if (!isNaN(num) && num >= 1 && num <= 6)
+            return (num + 1).toString(); // Mon(1)→2 … Sat(6)→7
+        return dow;
+    }
+    /**
+     * Converts Quartz DOW to Unix DOW, supporting lists, ranges, and special cases.
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat
+     */
+    static quartzDowToUnix(dow) {
+        if (dow === '*' || dow === '?')
+            return dow === '?' ? '*' : dow;
+        // Split compound expressions so each element is converted individually
+        if (dow.includes(','))
+            return dow.split(',').map(d => this.quartzDowToUnix(d)).join(',');
+        if (dow.includes('-'))
+            return dow.split('-').map(d => this.quartzDowToUnix(d)).join('-');
+        // Last (L) — convert the numeric day part, preserve L suffix
+        if (dow.endsWith('L')) {
+            const day = dow.slice(0, -1);
+            return `${this.quartzDowToUnix(day)}L`;
+        }
+        // Nth weekday (#) — convert the numeric day part, preserve #N
+        if (dow.includes('#')) {
+            const [day, nth] = dow.split('#');
+            return `${this.quartzDowToUnix(day)}#${nth}`;
+        }
+        // Numeric mapping
+        if (dow === '1')
+            return '0'; // Sunday
+        const num = parseInt(dow, 10);
+        if (!isNaN(num) && num >= 2 && num <= 7)
+            return (num - 1).toString(); // Mon(2)→1 … Sat(7)→6
+        return dow;
     }
 }
 exports.CronConverterU2Q = CronConverterU2Q;
-CronConverterU2Q.delimiter = ' ';
-CronConverterU2Q.unixExpressionLength = 5;
-CronConverterU2Q.quartzExpressionLengths = [6, 7];

package/lib/describer.d.ts

@@ -0,0 +1,41 @@
+export declare class CronDescriberU2Q {
+    /**
+     * Generates a human-readable description for a Unix-style cron expression.
+     *
+     * Unix-style cron expressions consist of 5 parts:
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (0-6, where 0 = Sunday)
+     * @param unixExpression - A string containing the Unix-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeUnix(unixExpression: string): string;
+    /**
+     * Generates a human-readable description for a Quartz-style cron expression.
+     *
+     * Quartz-style cron expressions consist of 6 or 7 parts:
+     * - Second (0-59)
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (1-7, where 1 = Sunday)
+     * - Year (optional)
+     * @param quartzExpression - A string containing the Quartz-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeQuartz(quartzExpression: string): string;
+    private static describeSecond;
+    private static describeMinute;
+    private static describeHour;
+    private static describeDayOfMonth;
+    private static describeMonth;
+    private static describeDayOfWeek;
+    private static describeYear;
+    private static resolveValue;
+    private static describeField;
+    private static ordinalSuffix;
+    private static combineDescriptions;
+}

package/lib/describer.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronDescriberU2Q = void 0;
+const helper_1 = require("./helper");
+const validator_1 = require("./validator");
+const converter_1 = require("./converter");
+class CronDescriberU2Q {
+    /**
+     * Generates a human-readable description for a Unix-style cron expression.
+     *
+     * Unix-style cron expressions consist of 5 parts:
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (0-6, where 0 = Sunday)
+     * @param unixExpression - A string containing the Unix-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeUnix(unixExpression) {
+        try {
+            validator_1.CronValidatorU2Q.validateUnix(unixExpression);
+            const parts = helper_1.ExpressionHelper.GetExpressionParts(unixExpression);
+            const [min, hour, dom, month, dow] = parts;
+            const descriptions = [
+                this.describeMinute(min, true),
+                this.describeHour(hour),
+                this.describeDayOfMonth(dom),
+                this.describeMonth(month),
+                this.describeDayOfWeek(dow),
+            ];
+            return this.combineDescriptions(descriptions);
+        }
+        catch (error) {
+            return "Invalid Unix cron expression";
+        }
+    }
+    /**
+     * Generates a human-readable description for a Quartz-style cron expression.
+     *
+     * Quartz-style cron expressions consist of 6 or 7 parts:
+     * - Second (0-59)
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (1-7, where 1 = Sunday)
+     * - Year (optional)
+     * @param quartzExpression - A string containing the Quartz-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeQuartz(quartzExpression) {
+        try {
+            validator_1.CronValidatorU2Q.validateQuartz(quartzExpression);
+            const parts = helper_1.ExpressionHelper.GetExpressionParts(quartzExpression);
+            const [second, min, hour, dom, month, dow, year] = parts;
+            // Normalize Quartz DOW to Unix DOW for consistent description mapping
+            const normalizedDow = converter_1.CronConverterU2Q.quartzDowToUnix(dow);
+            const descriptions = [
+                this.describeSecond(second, true),
+                this.describeMinute(min, true),
+                this.describeHour(hour),
+                this.describeDayOfMonth(dom),
+                this.describeMonth(month),
+                this.describeDayOfWeek(normalizedDow),
+                this.describeYear(year),
+            ];
+            return this.combineDescriptions(descriptions);
+        }
+        catch (error) {
+            return "Invalid Quartz cron expression";
+        }
+    }
+    static describeSecond(second, suppressZero = false) {
+        if (second === "*" || (suppressZero && second === "0"))
+            return "";
+        const desc = this.describeField(second, { nameMap: null, unitSingular: "second", unitPlural: "seconds" });
+        if (desc.startsWith("every") || desc.startsWith("from")) {
+            return desc.charAt(0).toUpperCase() + desc.slice(1);
+        }
+        return `At second ${desc}`;
+    }
+    static describeMinute(min, suppressZero = false) {
+        if (min === "*" || (suppressZero && min === "0"))
+            return "";
+        const desc = this.describeField(min, { nameMap: null, unitSingular: "minute", unitPlural: "minutes" });
+        if (desc.startsWith("every") || desc.startsWith("from")) {
+            return desc.charAt(0).toUpperCase() + desc.slice(1);
+        }
+        return `At minute ${desc}`;
+    }
+    static describeHour(hour) {
+        if (hour === "*")
+            return "";
+        const desc = this.describeField(hour, { nameMap: null, unitSingular: "hour", unitPlural: "hours" });
+        if (desc.startsWith("every") || desc.startsWith("from")) {
+            return desc.charAt(0).toUpperCase() + desc.slice(1);
+        }
+        return `At ${desc} o'clock`;
+    }
+    static describeDayOfMonth(dom) {
+        const desc = this.describeField(dom, {
+            nameMap: null,
+            unitSingular: "day of month",
+            unitPlural: "days of month",
+            isDom: true
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `on the ${desc} of the month`;
+    }
+    static describeMonth(month) {
+        const desc = this.describeField(month, {
+            nameMap: [
+                "January",
+                "February",
+                "March",
+                "April",
+                "May",
+                "June",
+                "July",
+                "August",
+                "September",
+                "October",
+                "November",
+                "December",
+            ],
+            unitSingular: "month",
+            unitPlural: "months"
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `in ${desc}`;
+    }
+    static describeDayOfWeek(dow) {
+        const desc = this.describeField(dow, {
+            nameMap: [
+                "Sunday",
+                "Monday",
+                "Tuesday",
+                "Wednesday",
+                "Thursday",
+                "Friday",
+                "Saturday",
+            ],
+            unitSingular: "day of week",
+            unitPlural: "days of week",
+            isDow: true
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `on ${desc}`;
+    }
+    static describeYear(year) {
+        if (!year || year === "*")
+            return "";
+        const desc = this.describeField(year, {
+            nameMap: null,
+            unitSingular: "year",
+            unitPlural: "years"
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `in ${desc}`;
+    }
+    static resolveValue(val, config) {
+        if (config.isDow) {
+            if (val.endsWith("L")) {
+                const day = val.slice(0, -1);
+                return `last ${this.resolveValue(day, config)}`;
+            }
+            if (val.includes("#")) {
+                const [day, nth] = val.split("#");
+                const nthStr = this.ordinalSuffix(Number(nth));
+                return `${nthStr} ${this.resolveValue(day, config)}`;
+            }
+            let dowVal = val.toUpperCase();
+            const dayNames = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
+            const aliasIndex = dayNames.indexOf(dowVal);
+            let index = aliasIndex !== -1 ? aliasIndex : Number(val);
+            if (index === 7)
+                index = 0;
+            return config.nameMap ? config.nameMap[index] || val : val;
+        }
+        if (config.isDom) {
+            if (val === "L")
+                return "last day";
+            if (val === "LW")
+                return "last weekday";
+            if (val.endsWith("W")) {
+                const day = val.slice(0, -1);
+                return `nearest weekday to the ${this.resolveValue(day, config)}`;
+            }
+            if (val.startsWith("L-")) {
+                const offset = val.slice(2);
+                return `${offset} days before the last day`;
+            }
+            return this.ordinalSuffix(Number(val));
+        }
+        if (config.nameMap) {
+            let mVal = val.toUpperCase();
+            const monthNames = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
+            const aliasIndex = monthNames.indexOf(mVal);
+            let index = aliasIndex !== -1 ? aliasIndex : Number(val) - 1;
+            return config.nameMap[index] || val;
+        }
+        return val;
+    }
+    static describeField(value, config) {
+        if (value === "*" || value === "?")
+            return "";
+        const parts = value.split(",");
+        const descriptions = parts.map(part => {
+            if (part.includes("/")) {
+                const [start, step] = part.split("/");
+                const stepNum = Number(step);
+                const unit = stepNum === 1 ? config.unitSingular : config.unitPlural;
+                if (start === "*" || start === "0") {
+                    return `every ${step} ${unit}`;
+                }
+                else {
+                    const startDesc = this.resolveValue(start, config);
+                    return `every ${step} ${unit} starting from ${startDesc}`;
+                }
+            }
+            if (part.includes("-")) {
+                const [start, end] = part.split("-");
+                const startDesc = this.resolveValue(start, config);
+                const endDesc = this.resolveValue(end, config);
+                return `from ${startDesc} to ${endDesc}`;
+            }
+            return this.resolveValue(part, config);
+        });
+        if (descriptions.length === 1) {
+            return descriptions[0];
+        }
+        else if (descriptions.length === 2) {
+            return `${descriptions[0]} and ${descriptions[1]}`;
+        }
+        else {
+            return `${descriptions.slice(0, -1).join(", ")}, and ${descriptions[descriptions.length - 1]}`;
+        }
+    }
+    static ordinalSuffix(i) {
+        if (isNaN(i) || i <= 0)
+            return "Invalid day";
+        const j = i % 10;
+        const k = i % 100;
+        if (j === 1 && k !== 11)
+            return i + "st";
+        if (j === 2 && k !== 12)
+            return i + "nd";
+        if (j === 3 && k !== 13)
+            return i + "rd";
+        return i + "th";
+    }
+    static combineDescriptions(descriptions) {
+        const filteredDescriptions = descriptions.filter((part) => part && part !== "");
+        return filteredDescriptions.length > 0
+            ? filteredDescriptions.join(" ").trim()
+            : "Every moment";
+    }
+}
+exports.CronDescriberU2Q = CronDescriberU2Q;