@design-edito/tools 0.3.0 → 1.0.1

package/agnostic/strings/char-codes/index.js

@@ -1,70 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/strings/char-codes/index.ts
-function charCodeToB36(charCode) {
-  if (charCode === null) return "\0";
-  return charCode.toString(36);
-}
-function b36CharCodeToCharCode(b36CharCode) {
-  if (b36CharCode === null) return 0;
-  const charCode = parseInt(b36CharCode, 36);
-  if (!Number.isInteger(charCode)) return 0;
-  return charCode;
-}
-function charToCharCode(char) {
-  const charCode = char.charCodeAt(0);
-  if (!Number.isInteger(charCode)) return 0;
-  return charCode;
-}
-function charToB36CharCode(char) {
-  const charCode = charToCharCode(char);
-  return charCodeToB36(charCode);
-}
-function charFromCharCode(charCode) {
-  return String.fromCharCode(charCode);
-}
-function charFromB36CharCode(b36CharCode) {
-  const charCode = parseInt(b36CharCode, 36);
-  if (!Number.isInteger(charCode)) return "\0";
-  return charFromCharCode(charCode);
-}
-function toCharCodes(string) {
-  const chars = string.split("");
-  return chars.map(charToCharCode);
-}
-function toB36CharCodes(string) {
-  const chars = string.split("");
-  return chars.map(charToB36CharCode);
-}
-function fromCharCodes(charCodes) {
-  return charCodes.map(charFromCharCode).map((char) => char === null ? "\0" : char).join("");
-}
-function fromB36CharCodes(b36CharCodes) {
-  return b36CharCodes.map(charFromB36CharCode).map((char) => char === null ? "\0" : char).join("");
-}
-function serialize(charCodes) {
-  return charCodes.map((c) => typeof c === "string" ? c : charCodeToB36(c)).join(",");
-}
-function deserialize(serializedCharCodes) {
-  const b36CharCodes = serializedCharCodes.split("");
-  return b36CharCodes.map(b36CharCodeToCharCode);
-}
-function fromSerialized(serializedCharCodes) {
-  const charCodes = deserialize(serializedCharCodes);
-  return fromCharCodes(charCodes);
-}
-export {
-  b36CharCodeToCharCode,
-  charCodeToB36,
-  charFromB36CharCode,
-  charFromCharCode,
-  charToB36CharCode,
-  charToCharCode,
-  deserialize,
-  fromB36CharCodes,
-  fromCharCodes,
-  fromSerialized,
-  serialize,
-  toB36CharCodes,
-  toCharCodes
-};

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

@@ -1,28 +0,0 @@
-/**
- * A matcher can be a string, a regular expression, or a function that returns a boolean for a given input.
- */
-export type Matcher = string | RegExp | ((input: string) => boolean);
-/**
- * Checks whether a string matches a single matcher.
- *
- * @param input - The string to test.
- * @param matcher - The matcher to test against.
- * @returns `true` if the input matches, otherwise `false`.
- */
-export declare function matches(input: string, matcher: Matcher): boolean;
-/**
- * Checks whether a string matches at least one matcher in a list (or a single matcher).
- *
- * @param input - The string to test.
- * @param matchers - A matcher or array of matchers.
- * @returns `true` if the input matches at least one matcher, otherwise `false`.
- */
-export declare function matchesSome(input: string, matchers: Matcher | Array<Matcher>): boolean;
-/**
- * Checks whether a string matches every matcher in a list (or a single matcher).
- *
- * @param input - The string to test.
- * @param matchers - A matcher or array of matchers.
- * @returns `true` if the input matches all matchers, otherwise `false`.
- */
-export declare function matchesEvery(input: string, matchers: Matcher | Array<Matcher>): boolean;

package/agnostic/strings/matches/index.js

@@ -1,11 +0,0 @@
-import {
-  matches,
-  matchesEvery,
-  matchesSome
-} from "../../../chunks/chunk-R3AWQXMY.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  matches,
-  matchesEvery,
-  matchesSome
-};

package/agnostic/strings/normalize-indent/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * Normalizes the indentation of a multi-line string.
- *
- * Removes all existing leading whitespace, replaces leading `|` characters with spaces,
- * and applies a uniform indentation to all lines.
- *
- * @param input - The multi-line string to normalize.
- * @param indentLevel - The number of spaces to prepend to each line after normalization. Defaults to `0`.
- * @returns The input string with normalized indentation.
- *
- * @example
- * const str = `
- * |function test() {
- * |  console.log('hi')
- * |}`;
- *
- * console.log(normalizeIndent(str, 2));
- * // Output:
- * // "  function test() {
- * //    console.log('hi')
- * //  }"
- */
-export declare function normalizeIndent(input: string, indentLevel?: number): string;

package/agnostic/strings/normalize-indent/index.js

@@ -1,19 +0,0 @@
-import "../../../chunks/chunk-XCBH6NLF.js";
-
-// src/agnostic/strings/normalize-indent/index.ts
-function normalizeIndent(input, indentLevel = 0) {
-  const indent = " ".repeat(indentLevel);
-  const lines = input.split("\n");
-  const noIndentLines = lines.map((line) => line.replace(/^\s*/igm, ""));
-  const pipeReplacedLines = noIndentLines.map((line) => {
-    const nbPipeCharsOnLineStart = line.match(/^\|+/igm)?.[0].length ?? 0;
-    const noPipeLine = line.slice(nbPipeCharsOnLineStart);
-    const replacedPipes = " ".repeat(nbPipeCharsOnLineStart);
-    return replacedPipes + noPipeLine;
-  });
-  const normalizedLines = pipeReplacedLines.map((line) => indent + line);
-  return normalizedLines.join("\n");
-}
-export {
-  normalizeIndent
-};

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

@@ -1,145 +0,0 @@
-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>> = {
-    /** 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>> = {
-    /** 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[];
-    /** 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;
-};
-/**
- * Union type of all supported parsing mode options.
- *
- * @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.
- *
- * 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
- *
- * @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)`.
- *
- * **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.
- *
- * **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.
- *
- * @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 (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
- * // 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
- * });
- * // 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 | undefined;
-}): Outcome.Either<T[], string>;

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

@@ -1,87 +0,0 @@
-import {
-  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,21 +0,0 @@
-/**
- * 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 +0,0 @@
-import {
-  replaceAll
-} from "../../../chunks/chunk-EPUHVR7J.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  replaceAll
-};

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

@@ -1,19 +0,0 @@
-/**
- * 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,11 +0,0 @@
-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,20 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-import {
-  trimEnd,
-  trimStart
-} from "../../../chunks/chunk-6XL25OZX.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
-export {
-  trimEnd,
-  trimStart
-};

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

@@ -1,48 +0,0 @@
-/**
- * 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,61 +0,0 @@
-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,39 +0,0 @@
-/**
- * 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;