@design-edito/tools 0.2.39 → 0.2.40

package/agnostic/strings/parse-table/index.d.ts

@@ -1,88 +1,145 @@
-import { Outcome } from '../../misc/outcome/index.js';
+import * as Outcome from '../../misc/outcome/index.js';
+/**
+ * Options for delimiter-based table parsing mode.
+ *
+ * In this mode, the table is split into rows and cells using delimiter functions.
+ * The header row is parsed into column names, which are then mapped to each body row's cell values.
+ *
+ * @template T - The type of objects in the resulting array, extending `Record<string, string>`.
+ *
+ * @example
+ * ```typescript
+ * const options: ParseTableLineModeOptions<MyRow> = {
+ *   mode: 'line',
+ *   splitLines: input => input.split('\n'),
+ *   headerPos: 0,
+ *   splitHeaderCells: header => header.split('\t'),
+ *   bodyBounds: [1, Infinity],
+ *   splitBodyCells: row => row.split('\t'),
+ *   schema: obj => validateMyRow(obj)
+ * }
+ * ```
+ */
 export type ParseTableLineModeOptions<T extends Record<string, string>> = {
-    inputToLines: (input: string) => string[];
-    headLinePos: number;
-    headLineToHeaders: (input: string) => string[];
-    bodyLinesBounds: [number, number];
-    bodyLineToCellValue: (input: string) => string[];
+    /** Parsing mode identifier. Must be 'line' for delimiter-based parsing. */
+    mode?: 'line';
+    /** Function to split the input string into lines. @default input => input.split('\n') */
+    splitLines: (input: string) => string[];
+    /** Zero-based index of the header line within the split lines array. @default 0 */
+    headerPos: number;
+    /** Tuple `[start, end]` indicating the range of line indices to parse as body rows (inclusive start, exclusive end). Use `Infinity` as the end value to parse until the last line. @default [1, Infinity] */
+    bodyBounds: [number, number];
+    /** Function to split the header line into individual column names. @default header => header.split('\t') */
+    splitHeaderCells: (input: string) => string[];
+    /** Function to split each body line into individual cell values. @default input => input.split('\t') */
+    splitBodyCells: (input: string) => string[];
+    /** Function to validate and transform each parsed row object. Return `undefined` to skip invalid rows. Skipped rows will not appear in the result and will not produce error messages. */
     schema: (obj: unknown) => T | undefined;
 };
+/**
+ * Options for fixed-width column parsing mode.
+ *
+ * In this mode, the table is parsed using fixed character positions to define column boundaries.
+ * This is useful for parsing terminal output, formatted reports, or any text with consistent column alignment.
+ *
+ * @template T - The type of objects in the resulting array, extending `Record<string, string>`.
+ *
+ * @example
+ * ```typescript
+ * const options: ParseTableColumnModeOptions<MyRow> = {
+ *   mode: 'column',
+ *   splitLines: input => input.split('\n'),
+ *   headerPos: 0,
+ *   bodyBounds: [1, Infinity],
+ *   columns: [0, 10, 25],  // Columns start at positions 0, 10, and 25
+ *   headerCellRefine: header => header.trim().toLowerCase(),
+ *   bodyCellRefine: value => value.trim(),
+ *   schema: obj => validateMyRow(obj)
+ * }
+ * ```
+ */
 export type ParseTableColumnModeOptions<T extends Record<string, string>> = {
-    inputToLines: (input: string) => string[];
-    headLinePos: number;
-    bodyLinesBounds: [number, number];
+    /** Parsing mode identifier. Must be 'column' for fixed-width column parsing. */
+    mode?: 'column';
+    /** Function to split the input string into lines. @default input => input.split('\n') */
+    splitLines: (input: string) => string[];
+    /** Zero-based index of the header line within the split lines array. @default 0 */
+    headerPos: number;
+    /** Tuple `[start, end]` indicating the range of line indices to parse as body rows (inclusive start, exclusive end). Use `Infinity` as the end value to parse until the last line. @default [1, Infinity] */
+    bodyBounds: [number, number];
+    /** Array of starting character positions for each column. Each column extends from its start position to the start of the next column. The last column extends to the end of the line. @example [0, 10, 25] defines three columns: chars 0-9, 10-24, and 25-end */
     columns: number[];
-    headerRefine: (header: string) => string;
-    valueRefine: (value: string) => string;
+    /** Function to clean or normalize header names extracted from the header line. Applied to each column header after slicing. @default header => header */
+    headerCellRefine: (header: string) => string;
+    /** Function to clean or normalize cell values extracted from body rows. Applied to each cell value after slicing. @default value => value */
+    bodyCellRefine: (value: string) => string;
+    /** Function to validate and transform each parsed row object. Return `undefined` to skip invalid rows. Skipped rows will not appear in the result and will not produce error messages. */
     schema: (obj: unknown) => T | undefined;
 };
-export type ParseTableOptions<T extends Record<string, string>> = ParseTableLineModeOptions<T> | ParseTableColumnModeOptions<T>;
 /**
- * Parses a tabular string input into an array of objects, where each object represents a row in the table.
- *
- * There are two parsing modes:
- *
- * 1. **Delimiter-based parsing** (default)
- *    - The table is split into rows and then into cells using functions such as splitting on `\n` and `\t`.
- *    - The header row is parsed into an array of header names, which are mapped to each cell value.
- *    - Defaults: `inputToLines = s => s.split('\n')`, `headLinePos = 0`, `headLineToHeaders = h => h.split('\t')`,
- *      `bodyLinesBounds = [0, Infinity]`, `bodyLineToCellValue = r => r.split('\t')`.
- *
- * 2. **Column-slice parsing**
- *    - The table is split into fixed-width columns based on start indices provided in `options.columns`.
- *    - The header row and body rows are sliced using these column boundaries.
- *    - Each header and cell value can be refined with user-provided functions.
- *    - Defaults: `inputToLines = s => s.split('\n')`, `headLinePos = 0`, `bodyLinesBounds = [1, Infinity]`,
- *      `headerRefine = h => h`, `valueRefine = v => v`.
+ * Union type of all supported parsing mode options.
  *
- * @template T - The type of the objects in the resulting array, extending `Record<string, string>`.
- * @param {string} table - The string representation of the table to be parsed.
- * @param {Partial<ParseTableOptions<T>> & { schema: (obj: unknown) => T }} options - Configuration options for parsing the table.
- *
- * ### Required
- * @param {function(unknown): T} options.schema - Function to validate and transform each row object.
+ * @template T - The type of objects in the resulting array, extending `Record<string, string>`.
+ */
+export type ParseTableOptions<T extends Record<string, string>> = ParseTableLineModeOptions<T> | ParseTableColumnModeOptions<T>;
+/**
+ * Parses a tabular string input into an array of typed objects.
  *
- * ### Common (optional)
- * @param {function(string): string[]} [options.inputToLines] - Function to split the input string into lines. Default: `s => s.split('\n')`.
- * @param {number} [options.headLinePos] - Index of the header line. Default: `0`.
- * @param {[number, number]} [options.bodyLinesBounds] - Tuple `[start, end]` indicating the range of lines to parse as body rows.
+ * Supports two parsing modes:
+ * 1. **Delimiter-based** (`mode: 'line'` or when `columns` is not provided): Splits rows and cells using delimiter functions
+ * 2. **Fixed-width columns** (`mode: 'column'` or when `columns` is provided): Slices text at fixed character positions
  *
- * ### Delimiter-based (optional, used when `columns` is not provided)
- * @param {function(string): string[]} [options.headLineToHeaders] - Function to parse the header line into an array of header names. Default: `h => h.split('\t')`.
- * @param {function(string): string[]} [options.bodyLineToCellValue] - Function to parse each body line into an array of cell values. Default: `r => r.split('\t')`.
+ * @template T - The type of objects in the resulting array, extending `Record<string, string>`.
+ * @param {string} table - The string representation of the table to parse.
+ * @param {Partial<ParseTableOptions<T>> & { schema: (obj: unknown) => T | undefined }} options - Configuration options.
+ * @param {function(unknown): T | undefined} options.schema - **Required.** Validates and transforms each row. Return `undefined` to skip invalid rows.
+ * @param {'line' | 'column'} [options.mode] - Parsing mode. If omitted, inferred from presence of `columns` property.
+ * @param {function(string): string[]} [options.splitLines] - How to split input into lines.
+ * @param {number} [options.headerPos=0] - Index of the header line.
+ * @param {[number, number]} [options.bodyBounds=[1, Infinity]] - Range of lines to parse as body rows `[start, end)`.
  *
- * ### Column-slice (optional, used when `columns` is provided)
- * @param {number[]} [options.columns] - Starting indices for each column. The last column extends to the end of the line.
- * @param {function(string): string} [options.headerRefine] - Function to clean or normalize header names. Default: `h => h`.
- * @param {function(string): string} [options.valueRefine] - Function to clean or normalize cell values. Default: `v => v`.
+ * **Delimiter-based mode options:**
+ * @param {function(string): string[]} [options.splitHeaderCells] - How to split header line into column names.
+ * @param {function(string): string[]} [options.splitBodyCells] - How to split body lines into cell values.
  *
- * @returns {Outcome.Either<T[], string>} An `Outcome` containing either:
- *   - `success = true` with an array of parsed row objects, or
- *   - `success = false` with an error message.
+ * **Fixed-width column mode options:**
+ * @param {number[]} [options.columns] - Starting positions for each column.
+ * @param {function(string): string} [options.headerCellRefine] - Clean/normalize header names.
+ * @param {function(string): string} [options.bodyCellRefine] - Clean/normalize cell values.
  *
- * @throws Will return a failure outcome if the header line cannot be found.
+ * @returns {Outcome.Either<T[], string>}
+ * - On success: `{ success: true, payload: T[] }` containing parsed rows.
+ * - On failure: `{ success: false, payload: string }` containing error message.
  *
  * @example
- * // Delimiter-based parsing (default)
- * const table = 'name\tage\nAlice\t30\nBob\t25';
- * const result = parseTable(table, { schema: row => row });
- * if (result.success) {
- *   console.log(result.payload); // [{ name: 'Alice', age: '30' }, { name: 'Bob', age: '25' }]
- * }
+ * // Delimiter-based parsing (TSV)
+ * const tsvTable = 'name\tage\nAlice\t30\nBob\t25';
+ * const result = parseTable(tsvTable, { schema: row => row });
+ * // result.payload = [{ name: 'Alice', age: '30' }, { name: 'Bob', age: '25' }]
  *
  * @example
- * // Column-slice parsing
- * const table = 'Name      Age\nAlice     30 \nBob       25 ';
- * const result = parseTable(table, {
- *   schema: row => row,
- *   columns: [0, 10, 15],
- *   headerRefine: h => h.trim(),
- *   valueRefine: v => v.trim()
+ * // Fixed-width column parsing
+ * const fixedTable = 'Name      Age\nAlice     30 \nBob       25 ';
+ * const result = parseTable(fixedTable, {
+ *   mode: 'column',
+ *   columns: [0, 10],
+ *   headerCellRefine: h => h.trim().toLowerCase(),
+ *   bodyCellRefine: v => v.trim(),
+ *   schema: row => row
  * });
- * if (result.success) {
- *   console.log(result.payload); // [{ Name: 'Alice', Age: '30' }, { Name: 'Bob', Age: '25' }]
- * }
+ * // result.payload = [{ name: 'Alice', age: '30' }, { name: 'Bob', age: '25' }]
+ *
+ * @example
+ * // With schema validation
+ * type Person = { name: string; age: string };
+ * const validatePerson = (obj: unknown): Person | undefined => {
+ *   if (typeof obj !== 'object' || obj === null) return undefined;
+ *   const { name, age } = obj as any;
+ *   if (typeof name !== 'string' || typeof age !== 'string') return undefined;
+ *   return { name, age };
+ * };
+ * const result = parseTable(tsvTable, { schema: validatePerson });
  */
 export declare function parseTable<T extends Record<string, string>>(table: string, _options: Partial<ParseTableOptions<T>> & {
-    schema: (obj: unknown) => T;
+    schema: (obj: unknown) => T | undefined;
 }): Outcome.Either<T[], string>;

package/agnostic/strings/parse-table/index.js

@@ -1,8 +1,87 @@
 import {
-  parseTable
-} from "../../../chunks/chunk-A3CDUWGR.js";
-import "../../../chunks/chunk-JMU5PDBD.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  makeFailure,
+  makeSuccess
+} from "../../../chunks/chunk-QEKI6WGQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/strings/parse-table/index.ts
+var defaultLineModeOptions = {
+  mode: "line",
+  splitLines: (i) => i.split("\n"),
+  headerPos: 0,
+  splitHeaderCells: (h) => h.split("	"),
+  bodyBounds: [1, Infinity],
+  splitBodyCells: (i) => i.split("	"),
+  schema: (i) => i
+};
+var defaultColumnModeOptions = {
+  mode: "column",
+  splitLines: (i) => i.split("\n"),
+  headerPos: 0,
+  bodyBounds: [1, Infinity],
+  columns: [],
+  headerCellRefine: (h) => h,
+  bodyCellRefine: (v) => v,
+  schema: (i) => i
+};
+function parseTable(table, _options) {
+  const inferredMode = "mode" in _options && _options.mode !== void 0 ? _options.mode : "columns" in _options ? "column" : "splitHeaderCells" in _options ? "line" : "line";
+  const options = inferredMode === "column" ? { ...defaultColumnModeOptions, ..._options, mode: "column" } : { ...defaultLineModeOptions, ..._options, mode: "line" };
+  const lines = options.splitLines(table);
+  const headLine = lines.at(options.headerPos);
+  if (headLine === void 0) return makeFailure(`Header line not found at position ${options.headerPos}`);
+  if (options.mode === "line" && "splitHeaderCells" in options) {
+    const headers = options.splitHeaderCells(headLine);
+    const [bodyStart, bodyEnd] = options.bodyBounds;
+    const bodyLines = lines.slice(bodyStart, bodyEnd);
+    const bodyLinesSplit = bodyLines.map(options.splitBodyCells);
+    const rows = [];
+    bodyLinesSplit.forEach((lineCells) => {
+      const row = {};
+      const cellCount = Math.min(lineCells.length, headers.length);
+      for (let cellPos = 0; cellPos < cellCount; cellPos++) {
+        const cellName = headers[cellPos];
+        const cellValue = lineCells[cellPos];
+        if (cellName !== void 0 && cellValue !== void 0) {
+          row[cellName] = cellValue;
+        }
+      }
+      const validated = options.schema(row);
+      if (validated !== void 0) rows.push(validated);
+    });
+    return makeSuccess(rows);
+  }
+  if (options.mode === "column" && "columns" in options) {
+    const { columns, headerCellRefine, bodyCellRefine } = options;
+    if (columns.length === 0) return makeFailure("Column mode requires at least one column position");
+    const colBounds = columns.map((colStartPos, colIndex) => {
+      const nextColStartPos = columns[colIndex + 1];
+      return [colStartPos, nextColStartPos ?? Infinity];
+    });
+    const headers = colBounds.map(([start, end]) => {
+      const rawHeader = headLine.slice(start, end);
+      return headerCellRefine(rawHeader);
+    });
+    const [bodyStart, bodyEnd] = options.bodyBounds;
+    const bodyLines = lines.slice(bodyStart, bodyEnd);
+    const rows = [];
+    bodyLines.forEach((line) => {
+      const row = {};
+      colBounds.forEach(([start, end], colIndex) => {
+        const header = headers[colIndex];
+        if (header !== void 0) {
+          const rawValue = line.slice(start, end);
+          const refinedValue = bodyCellRefine(rawValue);
+          row[header] = refinedValue;
+        }
+      });
+      const validated = options.schema(row);
+      if (validated !== void 0) rows.push(validated);
+    });
+    return makeSuccess(rows);
+  }
+  return makeFailure("Invalid parsing mode configuration");
+}
 export {
   parseTable
 };

package/agnostic/strings/replace-all/index.d.ts

@@ -1 +1,21 @@
+/**
+ * Replaces all occurrences of a pattern in a string.
+ *
+ * **Deprecated:** This function is mostly obsolete now that `String.prototype.replaceAll` is widely supported.
+ *
+ * @param input - The string to operate on.
+ * @param pattern - The string or RegExp pattern to replace.
+ * @param replacer - The replacement string or a function that returns a replacement for each match.
+ * @returns The resulting string with all matches replaced.
+ *
+ * @deprecated Use `String.prototype.replaceAll` instead.
+ *
+ * @example
+ * replaceAll('foo bar foo', 'foo', 'baz')
+ * // => 'baz bar baz'
+ *
+ * @example
+ * replaceAll('abc 123 abc', /abc/g, match => match.toUpperCase())
+ * // => 'ABC 123 ABC'
+ */
 export declare function replaceAll(input: string, pattern: string | RegExp, replacer: string | ((substring: string, ...args: any[]) => string)): string;

package/agnostic/strings/replace-all/index.js

@@ -1,7 +1,7 @@
 import {
   replaceAll
-} from "../../../chunks/chunk-ZTDVUXPR.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+} from "../../../chunks/chunk-EPUHVR7J.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   replaceAll
 };

package/agnostic/strings/to-alphanum/index.d.ts

@@ -1 +1,19 @@
+/**
+ * Converts a string to an alphanumeric-only string.
+ *
+ * Non-alphanumeric characters are replaced with the provided `replacer`.
+ * Consecutive occurrences of the `replacer` are collapsed into a single instance.
+ *
+ * @param string - The input string to sanitize.
+ * @param replacer - The string to replace non-alphanumeric characters with. Defaults to empty string.
+ * @returns The sanitized alphanumeric string.
+ *
+ * @example
+ * toAlphanum("Hello, World!")
+ * // => "HelloWorld"
+ *
+ * @example
+ * toAlphanum("Hello, World!", "-")
+ * // => "Hello-World"
+ */
 export declare function toAlphanum(string: string, replacer?: string): string;

package/agnostic/strings/to-alphanum/index.js

@@ -1,7 +1,11 @@
-import {
-  toAlphanum
-} from "../../../chunks/chunk-COVPTTAD.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/strings/to-alphanum/index.ts
+function toAlphanum(string, replacer = "") {
+  const replaced = string.replace(/[^a-z0-9]/igm, replacer);
+  if (replacer.length === 0) return replaced;
+  return replaced.replace(new RegExp(`${replacer}+`, "igm"), replacer);
+}
 export {
   toAlphanum
 };

package/agnostic/strings/trim/index.d.ts

@@ -1,2 +1,20 @@
+/**
+ * Removes all leading whitespace characters from a string.
+ *
+ * @param string - The string to trim.
+ * @returns The input string without leading whitespace.
+ *
+ * @example
+ * trimStart("   hello") // => "hello"
+ */
 export declare function trimStart(string: string): string;
+/**
+ * Removes all trailing whitespace characters from a string.
+ *
+ * @param string - The string to trim.
+ * @returns The input string without trailing whitespace.
+ *
+ * @example
+ * trimEnd("hello   ") // => "hello"
+ */
 export declare function trimEnd(string: string): string;

package/agnostic/strings/trim/index.js

@@ -2,7 +2,7 @@ import {
   trimEnd,
   trimStart
 } from "../../../chunks/chunk-6XL25OZX.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   trimEnd,
   trimStart

package/agnostic/time/dates/format-date/index.d.ts

@@ -1 +1,48 @@
+/**
+ * Formats a `Date` object into a string according to a custom template and locale.
+ *
+ * Supported tokens (placeholders must be wrapped in `{{...}}`):
+ *
+ * **Day**
+ * - `D` : Day of month (1–31)
+ * - `DD` : Day of month, padded (01–31)
+ * - `d` : Short weekday name (Mon, Tue, ...)
+ * - `dd` : Full weekday name (Monday, Tuesday, ...)
+ *
+ * **Month**
+ * - `M` : Month number (1–12)
+ * - `MM` : Month number, padded (01–12)
+ * - `MMM` : Short month name (Jan, Feb, ...)
+ * - `MMMM` : Full month name (January, February, ...)
+ *
+ * **Year**
+ * - `YY` : Two-digit year
+ * - `YYYY` : Four-digit year
+ *
+ * **Hours**
+ * - `H` : 24h format
+ * - `HH` : 24h format, padded
+ * - `h` : 12h format
+ * - `hh` : 12h format, padded
+ *
+ * **Minutes & Seconds**
+ * - `m` / `mm` : Minutes
+ * - `s` / `ss` : Seconds
+ *
+ * **AM/PM**
+ * - `A` : AM/PM
+ * - `a` : am/pm
+ *
+ * **Ordinal suffix**
+ * - `th` : Day ordinal suffix (`st`, `nd`, `rd`, `th` for English; `er` for French 1st)
+ *
+ * @param date - The `Date` object to format.
+ * @param format - The template string containing tokens.
+ * @param locale - Optional locale code (default: `'en'`).
+ * @returns Formatted date string.
+ *
+ * @example
+ * formatDate(new Date(2026, 0, 1, 15, 5), '{{YYYY}}-{{MM}}-{{DD}} {{hh}}:{{mm}} {{A}}')
+ * // => "2026-01-01 03:05 PM"
+ */
 export declare function formatDate(date: Date, format: string, locale?: string): string;

package/agnostic/time/dates/format-date/index.js

@@ -1,7 +1,61 @@
-import {
-  formatDate
-} from "../../../../chunks/chunk-YQWZ3EP2.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/time/dates/format-date/index.ts
+function formatDate(date, format, locale = "en") {
+  try {
+    new Intl.DateTimeFormat(locale);
+  } catch {
+    locale = "en";
+  }
+  const day = date.getDate();
+  const dayOfWeek = date.getDay();
+  const month = date.getMonth();
+  const year = date.getFullYear();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const isPM = hours >= 12;
+  const shortDateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(locale, { weekday: "short" }).format(new Date(2023, 0, i + 1)));
+  const dateNames = [...Array(7)].map((_, i) => new Intl.DateTimeFormat(locale, { weekday: "long" }).format(new Date(2023, 0, i + 1)));
+  const shortMonthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(locale, { month: "short" }).format(new Date(2023, i, 1)));
+  const monthNames = [...Array(12)].map((_, i) => new Intl.DateTimeFormat(locale, { month: "long" }).format(new Date(2023, i, 1)));
+  const replacements = {
+    "DD": () => String(day).padStart(2, "0"),
+    "D": () => String(day),
+    "dd": () => dateNames[dayOfWeek],
+    "d": () => shortDateNames[dayOfWeek],
+    "MM": () => String(month + 1).padStart(2, "0"),
+    "M": () => String(month + 1),
+    "MMMM": () => monthNames[month],
+    "MMM": () => shortMonthNames[month],
+    "YYYY": () => String(year),
+    "YY": () => String(year).slice(-2),
+    "hh": () => String(hours % 12 || 12).padStart(2, "0"),
+    "h": () => String(hours % 12 || 12),
+    "HH": () => String(hours).padStart(2, "0"),
+    "H": () => String(hours),
+    "mm": () => String(minutes).padStart(2, "0"),
+    "m": () => String(minutes),
+    "ss": () => String(seconds).padStart(2, "0"),
+    "s": () => String(seconds),
+    "A": () => isPM ? "PM" : "AM",
+    "a": () => isPM ? "pm" : "am",
+    "th": () => {
+      if (locale.startsWith("fr") && day === 1) return "er";
+      if (locale.startsWith("en")) {
+        const mod10 = day % 10;
+        const mod100 = day % 100;
+        if (mod10 === 1 && mod100 !== 11) return "st";
+        if (mod10 === 2 && mod100 !== 12) return "nd";
+        if (mod10 === 3 && mod100 !== 13) return "rd";
+        return "th";
+      }
+      return "";
+    }
+  };
+  const regexp = /{{(DD|D|dd|d|MM|M|MMMM|MMM|YYYY|YY|HH|H|hh|h|mm|m|ss|s|A|a|th)}}/g;
+  return format.replace(regexp, (match, token) => replacements[token]?.() ?? match);
+}
 export {
   formatDate
 };

package/agnostic/time/duration/index.d.ts

@@ -1,26 +1,39 @@
-export declare namespace Duration {
-    type DurationType = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
-    type DurationTypeShort = 'ms' | 's' | 'sec' | 'min' | 'm' | 'h' | 'd' | 'w' | 'mo' | 'mth' | 'y';
-    class Duration {
-        value: number;
-        type: DurationType;
-        constructor(value: number, type: DurationType | DurationTypeShort);
-        toMilliseconds: () => number;
-        toMs(): number;
-        toSeconds(): number;
-        toMinutes(): number;
-        toHours(): number;
-        toDays(): number;
-        toWeeks(): number;
-        toMonths(): number;
-        toYear(): number;
-    }
-    function milliseconds(value: number): Duration;
-    function seconds(value: number): Duration;
-    function minutes(value: number): Duration;
-    function hours(value: number): Duration;
-    function days(value: number): Duration;
-    function weeks(value: number): Duration;
-    function months(value: number): Duration;
-    function years(value: number): Duration;
+/**
+ * Supported duration types (long form).
+ */
+export type DurationType = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+/**
+ * Supported duration types (short form aliases).
+ */
+export type DurationTypeShort = 'ms' | 's' | 'sec' | 'min' | 'm' | 'h' | 'd' | 'w' | 'mo' | 'mth' | 'y';
+/**
+ * Represents a duration in a specific unit and allows conversion to other units.
+ */
+export declare class Duration {
+    value: number;
+    type: DurationType;
+    /**
+     * Creates a new Duration instance.
+     *
+     * @param value - The numeric value of the duration.
+     * @param type - The unit of the duration, either long or short form.
+     */
+    constructor(value: number, type: DurationType | DurationTypeShort);
+    toMilliseconds: () => number;
+    toMs(): number;
+    toSeconds(): number;
+    toMinutes(): number;
+    toHours(): number;
+    toDays(): number;
+    toWeeks(): number;
+    toMonths(): number;
+    toYear(): number;
 }
+export declare function milliseconds(value: number): Duration;
+export declare function seconds(value: number): Duration;
+export declare function minutes(value: number): Duration;
+export declare function hours(value: number): Duration;
+export declare function days(value: number): Duration;
+export declare function weeks(value: number): Duration;
+export declare function months(value: number): Duration;
+export declare function years(value: number): Duration;