@design-edito/tools 0.4.23 → 0.5.0

package/agnostic/regexps/index.js

@@ -1,33 +1,33 @@
 /**
  * Merges multiple flag strings into a single string containing each flag only once.
  *
- * @param {...string[]} flagStrs - Flag strings to merge.
- * @returns {string} Merged flags string.
+ * @param flagStrs - Flag strings to merge.
+ * @returns Merged flags string.
  */
 export function mergeFlags(...flagStrs) {
     const flagsSet = new Set();
     flagStrs.forEach(flagStr => flagStr
         .split('')
-        .forEach(char => flagsSet.add(char)));
+        .forEach(char => { flagsSet.add(char); }));
     return Array.from(flagsSet.values()).join('');
 }
 /**
  * Returns a new RegExp with combined flags.
  *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} flags - Flags to add.
- * @returns {RegExp} New regular expression with combined flags.
+ * @param regexp - The original regular expression.
+ * @param flags - Flags to add.
+ * @returns New regular expression with combined flags.
  */
 export function setFlags(regexp, flags) {
     const mergedFlags = mergeFlags(regexp.flags, flags);
-    return new RegExp(`${regexp.source}`, mergedFlags);
+    return new RegExp(regexp.source, mergedFlags);
 }
 /**
  * Anchors a RegExp to the start of a string.
  *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} [flags='g'] - Optional flags to apply.
- * @returns {RegExp} Anchored RegExp.
+ * @param regexp - The original regular expression.
+ * @param [flags='g'] - Optional flags to apply.
+ * @returns Anchored RegExp.
  */
 export function fromStart(regexp, flags = 'g') {
     const mergedFlags = mergeFlags(regexp.flags, flags);
@@ -36,9 +36,9 @@ export function fromStart(regexp, flags = 'g') {
 /**
  * Anchors a RegExp to the end of a string.
  *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} [flags='g'] - Optional flags to apply.
- * @returns {RegExp} Anchored RegExp.
+ * @param regexp - The original regular expression.
+ * @param [flags='g'] - Optional flags to apply.
+ * @returns Anchored RegExp.
  */
 export function toEnd(regexp, flags = 'g') {
     const mergedFlags = mergeFlags(regexp.flags, flags);
@@ -47,9 +47,9 @@ export function toEnd(regexp, flags = 'g') {
 /**
  * Anchors a RegExp to match the entire string.
  *
- * @param {RegExp} regexp - The original regular expression.
- * @param {string} [flags='g'] - Optional flags to apply.
- * @returns {RegExp} Anchored RegExp.
+ * @param regexp - The original regular expression.
+ * @param [flags='g'] - Optional flags to apply.
+ * @returns Anchored RegExp.
  */
 export function fromStartToEnd(regexp, flags = 'g') {
     const mergedFlags = mergeFlags(regexp.flags, flags);
@@ -70,13 +70,13 @@ export function stringIs(string, regexp, returnMatches = false, flags = 'g') {
 /**
  * Creates a RegExp that matches any of the provided strings.
  *
- * @param {string[]} strings - Strings to match.
- * @returns {RegExp} Regular expression matching all strings.
+ * @param strings - Strings to match.
+ * @returns Regular expression matching all strings.
  */
 export function fromStrings(strings) {
     const rootsMap = stringsToRootsMap(strings);
     const source = sourceFromRootsMap(rootsMap, false);
-    const regexp = new RegExp(source);
+    const regexp = new RegExp(source, 'v');
     return regexp;
 }
 /**
@@ -85,8 +85,8 @@ export function fromStrings(strings) {
  * - Other whitespace characters are normalized to `\\s`
  * - RegExp special characters (including backslash) are escaped
  *
- * @param {string} string - String to escape.
- * @returns {string} Escaped string.
+ * @param string - String to escape.
+ * @returns Escaped string.
  */
 export function escape(string) {
     let result = '';
@@ -94,11 +94,11 @@ export function escape(string) {
         if (ch === '\n') {
             result += '\\n';
         }
-        else if (/\s/.test(ch)) {
+        else if (/\s/v.test(ch)) {
             result += '\\s'; // any other whitespace (space, tab, etc.)
         }
-        else if (/[.*+?^${}()|[\]\\]/.test(ch)) {
-            result += '\\' + ch; // regex special chars (including backslash)
+        else if (/[.*+?^$\{\}\(\)\|\[\]\\]/v.test(ch)) {
+            result += `\\${ch}`; // regex special chars (including backslash)
         }
         else {
             result += ch;
@@ -114,14 +114,15 @@ function stringsToRootsMap(strings, rootsMap = new Map()) {
         if (firstChar === undefined)
             return;
         const roots = Array.from(rootsMap.keys());
-        const foundRoot = roots.find(root => new RegExp(`^(${escape(root)})`).test(string));
+        const foundRoot = roots.find(root => new RegExp(`^(${escape(root)})`, 'v').test(string));
         const subRootsMap = foundRoot !== undefined
             ? rootsMap.get(foundRoot)?.subRootsMap
             : undefined;
         if (foundRoot === undefined || subRootsMap === undefined) {
             const subRootsMap = new Map();
             stringsToRootsMap([lastChars.join('')], subRootsMap);
-            return rootsMap.set(firstChar, { subRootsMap, isWordEnd });
+            rootsMap.set(firstChar, { subRootsMap, isWordEnd });
+            return;
         }
         stringsToRootsMap([lastChars.join('')], subRootsMap);
     });

package/agnostic/sanitization/file-name/index.d.ts

@@ -6,8 +6,8 @@
  * - Replaces multiple dots with a single dot and removes leading/trailing dots.
  * - Normalizes Unicode to NFKC form to prevent homoglyph attacks.
  *
- * @param {string} input - The file name to sanitize.
- * @param {number} [maxLength=255] - Maximum allowed length of the sanitized file name.
- * @returns {string | null} Sanitized file name, or null if empty or exceeds maxLength.
+ * @param input - The file name to sanitize.
+ * @param [maxLength=255] - Maximum allowed length of the sanitized file name.
+ * @returns Sanitized file name, or null if empty or exceeds maxLength.
  */
 export declare function sanitizeFileName(input: string, maxLength?: number): string | null;

package/agnostic/sanitization/file-name/index.js

@@ -6,20 +6,20 @@
  * - Replaces multiple dots with a single dot and removes leading/trailing dots.
  * - Normalizes Unicode to NFKC form to prevent homoglyph attacks.
  *
- * @param {string} input - The file name to sanitize.
- * @param {number} [maxLength=255] - Maximum allowed length of the sanitized file name.
- * @returns {string | null} Sanitized file name, or null if empty or exceeds maxLength.
+ * @param input - The file name to sanitize.
+ * @param [maxLength=255] - Maximum allowed length of the sanitized file name.
+ * @returns Sanitized file name, or null if empty or exceeds maxLength.
  */
 export function sanitizeFileName(input, maxLength = 255) {
-    input = input
+    const _input = input
         .normalize('NFKC') // Normalize Unicode to avoid homoglyph attacks
         // eslint-disable-next-line no-control-regex
-        .replace(/[<>:"/\\|?*\x00-\x1F]/g, '') // Remove invalid characters (e.g., Windows and Unix forbidden characters)
+        .replace(/[<>:"\/\\\|?*\x00-\x1F]/gv, '') // Remove invalid characters (e.g., Windows and Unix forbidden characters)
         .trim() // Trim whitespace
-        .replace(/\s+/g, ' ') // Replace multiple spaces with a single space
-        .replace(/\.+/g, '.') // Replace multiple dots with a single dot
-        .replace(/^\.+|\.+$/g, ''); // Remove leading/trailing dots
-    if (input.length > maxLength)
+        .replace(/\s+/gv, ' ') // Replace multiple spaces with a single space
+        .replace(/\.+/gv, '.') // Replace multiple dots with a single dot
+        .replace(/^\.+|\.+$/gv, ''); // Remove leading/trailing dots
+    if (_input.length > maxLength)
         return null;
-    return input.length > 0 ? input : null;
+    return _input.length > 0 ? _input : null;
 }

package/agnostic/sanitization/html/index.d.ts

@@ -24,9 +24,9 @@ export declare const defaultOptions: SanitizeHtmlOptions;
  * This API must not be used as a security boundary for untrusted HTML.
  * For security-critical sanitization, use a dedicated, security-audited library.
  *
- * @param {string} inputStr - The HTML string to sanitize.
- * @param {SanitizeHtmlOptions} [options=defaultOptions] - Sanitization configuration.
- * @returns {string} The sanitized HTML string.
+ * @param inputStr - The HTML string to sanitize.
+ * @param [options=defaultOptions] - Sanitization configuration.
+ * @returns The sanitized HTML string.
  *
  * @throws Will throw an error if no document object is available for creating elements.
  */
@@ -50,9 +50,9 @@ export declare function sanitizeHtml(inputStr: string, options?: SanitizeHtmlOpt
  * This API must not be used as a security boundary for untrusted HTML.
  * For security-critical sanitization, use a dedicated, security-audited library.
  *
- * @param {Element} element - The DOM element to sanitize.
- * @param {SanitizeHtmlOptions} [options=defaultOptions] - Sanitization configuration.
- * @returns {Element | null}
+ * @param element - The DOM element to sanitize.
+ * @param [options=defaultOptions] - Sanitization configuration.
+ * @returns
  * - A sanitized clone of the original element with allowed attributes and children.
  * - `null` if the element is forbidden or maximum recursion depth is reached.
  *

package/agnostic/sanitization/html/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import * as Window from '../../misc/crossenv/window/index.js';
 /**
  * Default sanitization options.
@@ -24,9 +25,9 @@ export const defaultOptions = { depth: 20 };
  * This API must not be used as a security boundary for untrusted HTML.
  * For security-critical sanitization, use a dedicated, security-audited library.
  *
- * @param {string} inputStr - The HTML string to sanitize.
- * @param {SanitizeHtmlOptions} [options=defaultOptions] - Sanitization configuration.
- * @returns {string} The sanitized HTML string.
+ * @param inputStr - The HTML string to sanitize.
+ * @param [options=defaultOptions] - Sanitization configuration.
+ * @returns The sanitized HTML string.
  *
  * @throws Will throw an error if no document object is available for creating elements.
  */
@@ -35,6 +36,7 @@ export function sanitizeHtml(inputStr, options = defaultOptions) {
     const wrapperDiv = document.createElement('div');
     const { inputFreeTransform } = options;
     wrapperDiv.innerHTML = inputFreeTransform !== undefined ? inputFreeTransform(inputStr) : inputStr;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     const sanitizedWrapper = sanitizeElement(wrapperDiv, options);
     const returned = sanitizedWrapper?.innerHTML;
     return returned ?? '';
@@ -58,9 +60,9 @@ export function sanitizeHtml(inputStr, options = defaultOptions) {
  * This API must not be used as a security boundary for untrusted HTML.
  * For security-critical sanitization, use a dedicated, security-audited library.
  *
- * @param {Element} element - The DOM element to sanitize.
- * @param {SanitizeHtmlOptions} [options=defaultOptions] - Sanitization configuration.
- * @returns {Element | null}
+ * @param element - The DOM element to sanitize.
+ * @param [options=defaultOptions] - Sanitization configuration.
+ * @returns
  * - A sanitized clone of the original element with allowed attributes and children.
  * - `null` if the element is forbidden or maximum recursion depth is reached.
  *
@@ -163,6 +165,7 @@ export function sanitizeElement(element, options = defaultOptions) {
     // Element's children sanitization
     const sanitizedChildNodes = Array.from(childNodes)
         .map((node) => {
+        // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unsafe-type-assertion -- nodeType === ELEMENT_NODE just checked above
         if (node.nodeType === Node.ELEMENT_NODE)
             return sanitizeElement(node, { ...options, depth: depth - 1 });
         else if (node.nodeType === Node.TEXT_NODE)

package/agnostic/sanitization/index.d.ts

@@ -1,4 +1,4 @@
-export * as html from './html/index.js'
 export * as fileName from './file-name/index.js'
+export * as html from './html/index.js'
 export * as path from './path/index.js'
 export * as userInput from './user-input/index.js'

package/agnostic/sanitization/index.js

@@ -1,4 +1,4 @@
-export * as html from './html/index.js'
 export * as fileName from './file-name/index.js'
+export * as html from './html/index.js'
 export * as path from './path/index.js'
 export * as userInput from './user-input/index.js'

package/agnostic/sanitization/path/index.d.ts

@@ -5,7 +5,7 @@
  * - Sanitizes each segment using `sanitizeFileName`.
  * - Ensures the returned path starts with a `/`.
  *
- * @param {string} targetPath - The path to sanitize.
- * @returns {string | null} Sanitized absolute path, or null if invalid/empty.
+ * @param targetPath - The path to sanitize.
+ * @returns Sanitized absolute path, or null if invalid/empty.
  */
 export declare function sanitizePath(targetPath: string): string | null;

package/agnostic/sanitization/path/index.js

@@ -6,8 +6,8 @@ import { sanitizeFileName } from '../file-name/index.js';
  * - Sanitizes each segment using `sanitizeFileName`.
  * - Ensures the returned path starts with a `/`.
  *
- * @param {string} targetPath - The path to sanitize.
- * @returns {string | null} Sanitized absolute path, or null if invalid/empty.
+ * @param targetPath - The path to sanitize.
+ * @returns Sanitized absolute path, or null if invalid/empty.
  */
 export function sanitizePath(targetPath) {
     const sanitized = targetPath

package/agnostic/sanitization/user-input/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-type-assertion -- sanitizeUserInput always returns a value of the same shape as its generic input T, which TS can't verify through the recursive sanitization logic */
 import xss from 'xss';
 /**
  * Recursively sanitizes user input to prevent XSS.

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

@@ -5,8 +5,6 @@
  * @returns Base-36 encoded character code.
  */
 export function charCodeToB36(charCode) {
-    if (charCode === null)
-        return '\x00';
     return charCode.toString(36);
 }
 /**
@@ -15,8 +13,6 @@ export function charCodeToB36(charCode) {
  * @returns Unicode character code.
  */
 export function b36CharCodeToCharCode(b36CharCode) {
-    if (b36CharCode === null)
-        return 0;
     const charCode = parseInt(b36CharCode, 36);
     if (!Number.isInteger(charCode))
         return 0;
@@ -91,7 +87,7 @@ export function toB36CharCodes(string) {
 export function fromCharCodes(charCodes) {
     return charCodes
         .map(charFromCharCode)
-        .map(char => char ?? '\x00')
+        .map(char => char)
         .join('');
 }
 /**
@@ -102,7 +98,7 @@ export function fromCharCodes(charCodes) {
 export function fromB36CharCodes(b36CharCodes) {
     return b36CharCodes
         .map(charFromB36CharCode)
-        .map(char => char ?? '\x00')
+        .map(char => char)
         .join('');
 }
 // Serialization

package/agnostic/strings/index.d.ts

@@ -1,8 +1,8 @@
 export * as charCodes from './char-codes/index.js'
 export * as matches from './matches/index.js'
 export * as normalizeIndent from './normalize-indent/index.js'
+export * as parseTable from './parse-table/index.js'
 export * as replaceAll from './replace-all/index.js'
 export * as splitTrim from './split-trim/index.js'
-export * as parseTable from './parse-table/index.js'
 export * as toAlphanum from './to-alphanum/index.js'
 export * as trim from './trim/index.js'

package/agnostic/strings/index.js

@@ -1,8 +1,8 @@
 export * as charCodes from './char-codes/index.js'
 export * as matches from './matches/index.js'
 export * as normalizeIndent from './normalize-indent/index.js'
+export * as parseTable from './parse-table/index.js'
 export * as replaceAll from './replace-all/index.js'
 export * as splitTrim from './split-trim/index.js'
-export * as parseTable from './parse-table/index.js'
 export * as toAlphanum from './to-alphanum/index.js'
 export * as trim from './trim/index.js'

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

@@ -23,9 +23,9 @@
 export function normalizeIndent(input, indentLevel = 0) {
     const indent = (' ').repeat(indentLevel);
     const lines = input.split('\n');
-    const noIndentLines = lines.map(line => line.replace(/^\s*/igm, ''));
+    const noIndentLines = lines.map(line => line.replace(/^\s*/igmv, ''));
     const pipeReplacedLines = noIndentLines.map(line => {
-        const nbPipeCharsOnLineStart = line.match(/^\|+/igm)?.[0].length ?? 0;
+        const nbPipeCharsOnLineStart = line.match(/^\|+/igmv)?.[0].length ?? 0;
         const noPipeLine = line.slice(nbPipeCharsOnLineStart);
         const replacedPipes = (' ').repeat(nbPipeCharsOnLineStart);
         return replacedPipes + noPipeLine;

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

@@ -90,24 +90,24 @@ export type ParseTableOptions<T extends Record<string, string>> = ParseTableLine
  * 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)`.
+ * @param table - The string representation of the table to parse.
+ * @param options - Configuration options.
+ * @param options.schema - **Required.** Validates and transforms each row. Return `undefined` to skip invalid rows.
+ * @param [options.mode] - Parsing mode. If omitted, inferred from presence of `columns` property.
+ * @param [options.splitLines] - How to split input into lines.
+ * @param [options.headerPos=0] - Index of the header line.
+ * @param [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.
+ * @param [options.splitHeaderCells] - How to split header line into column names.
+ * @param [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.
+ * @param [options.columns] - Starting positions for each column.
+ * @param [options.headerCellRefine] - Clean/normalize header names.
+ * @param [options.bodyCellRefine] - Clean/normalize cell values.
  *
- * @returns {Outcome.Either<T[], string>}
+ * @returns
  * - On success: `{ success: true, payload: T[] }` containing parsed rows.
  * - On failure: `{ success: false, payload: string }` containing error message.
  *

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

@@ -1,4 +1,5 @@
 import * as Outcome from '../../misc/outcome/index.js';
+import { isRecord } from '../../objects/is-record/index.js';
 const defaultLineModeOptions = {
     mode: 'line',
     splitLines: i => i.split('\n'),
@@ -6,7 +7,14 @@ const defaultLineModeOptions = {
     splitHeaderCells: h => h.split('\t'),
     bodyBounds: [1, Infinity],
     splitBodyCells: i => i.split('\t'),
-    schema: i => i
+    schema: i => {
+        if (isRecord(i)
+            && Object.values(i).every(v => typeof v === 'string')) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return i;
+        }
+        return {};
+    }
 };
 const defaultColumnModeOptions = {
     mode: 'column',
@@ -16,7 +24,14 @@ const defaultColumnModeOptions = {
     columns: [],
     headerCellRefine: h => h,
     bodyCellRefine: v => v,
-    schema: i => i
+    schema: i => {
+        if (isRecord(i)
+            && Object.values(i).every(v => typeof v === 'string')) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return i;
+        }
+        return {};
+    }
 };
 /**
  * Parses a tabular string input into an array of typed objects.
@@ -26,24 +41,24 @@ const defaultColumnModeOptions = {
  * 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)`.
+ * @param table - The string representation of the table to parse.
+ * @param options - Configuration options.
+ * @param options.schema - **Required.** Validates and transforms each row. Return `undefined` to skip invalid rows.
+ * @param [options.mode] - Parsing mode. If omitted, inferred from presence of `columns` property.
+ * @param [options.splitLines] - How to split input into lines.
+ * @param [options.headerPos=0] - Index of the header line.
+ * @param [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.
+ * @param [options.splitHeaderCells] - How to split header line into column names.
+ * @param [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.
+ * @param [options.columns] - Starting positions for each column.
+ * @param [options.headerCellRefine] - Clean/normalize header names.
+ * @param [options.bodyCellRefine] - Clean/normalize cell values.
  *
- * @returns {Outcome.Either<T[], string>}
+ * @returns
  * - On success: `{ success: true, payload: T[] }` containing parsed rows.
  * - On failure: `{ success: false, payload: string }` containing error message.
  *
@@ -102,7 +117,7 @@ export function parseTable(table, _options) {
         bodyLinesSplit.forEach(lineCells => {
             const row = {};
             const cellCount = Math.min(lineCells.length, headers.length);
-            for (let cellPos = 0; cellPos < cellCount; cellPos++) {
+            for (let cellPos = 0; cellPos < cellCount; cellPos = cellPos + 1) {
                 const cellName = headers[cellPos];
                 const cellValue = lineCells[cellPos];
                 if (cellName !== undefined

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

@@ -18,4 +18,4 @@
  * 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;
+export declare function replaceAll(input: string, pattern: string | RegExp, replacer: string | ((substring: string, ...args: unknown[]) => string)): string;

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

@@ -21,6 +21,7 @@
  * // => 'ABC 123 ABC'
  */
 export function replaceAll(input, pattern, replacer) {
+    // eslint-disable-next-line no-console
     console.warn('[DEPRECATED] Use String.replaceAll instead');
     const found = Array.from(input.match(pattern) ?? []);
     const foundReplaced = typeof replacer === 'string'

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

@@ -17,8 +17,8 @@
  * // => "Hello-World"
  */
 export function toAlphanum(string, replacer = '') {
-    const replaced = string.replace(/[^a-z0-9]/igm, replacer);
+    const replaced = string.replace(/[^a-z0-9]/igmv, replacer);
     if (replacer.length === 0)
         return replaced;
-    return replaced.replace(new RegExp(`${replacer}+`, 'igm'), replacer);
+    return replaced.replace(new RegExp(`${replacer}+`, 'igmv'), replacer);
 }

package/agnostic/strings/trim/index.js

@@ -8,7 +8,7 @@
  * trimStart("   hello") // => "hello"
  */
 export function trimStart(string) {
-    return string.replace(/^\s*/, '');
+    return string.replace(/^\s*/v, '');
 }
 /**
  * Removes all trailing whitespace characters from a string.
@@ -20,5 +20,5 @@ export function trimStart(string) {
  * trimEnd("hello   ") // => "hello"
  */
 export function trimEnd(string) {
-    return string.replace(/\s*$/, '');
+    return string.replace(/\s*$/v, '');
 }

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

@@ -52,6 +52,7 @@ export function formatDate(date, format, locale = 'en') {
     if (Intl
         .DateTimeFormat
         .supportedLocalesOf(locale).length === 0) {
+        // eslint-disable-next-line no-param-reassign
         locale = 'en';
     }
     const day = date.getDate();
@@ -109,7 +110,8 @@ export function formatDate(date, format, locale = 'en') {
             return '';
         }
     };
-    const regexp = /{{(DD|D|dd|d|MM|M|MMMM|MMM|YYYY|YY|HH|H|hh|h|mm|m|ss|s|A|a|th|ms)}}/g;
+    const regexp = /\{\{(DD|D|dd|d|MM|M|MMMM|MMM|YYYY|YY|HH|H|hh|h|mm|m|ss|s|A|a|th|ms)\}\}/gv;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     return format.replace(regexp, (match, token) => replacements[token]?.() ?? match);
 }
 // [WIP] this was removed since JavaScript's Date object don't hold timezone data

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

@@ -1 +1,2 @@
 export * as formatDate from './format-date/index.js'
+export * as toFrenchRepublican from './to-french-republican/index.js'

package/agnostic/time/dates/index.js

@@ -1 +1,2 @@
 export * as formatDate from './format-date/index.js'
+export * as toFrenchRepublican from './to-french-republican/index.js'

package/agnostic/time/dates/to-french-republican/index.d.ts

@@ -0,0 +1,16 @@
+import type { FrenchRepublicanDate } from './types.js';
+/**
+ * Converts a `Date` to the French Republican calendar.
+ *
+ * @param date - The date to convert.
+ * @returns The equivalent {@link FrenchRepublicanDate}.
+ *
+ * @remarks
+ * The date's local calendar day (`getFullYear` / `getMonth` / `getDate`) is
+ * used as the Gregorian date, so the result reflects the runtime's local
+ * timezone. Build the `Date` in the timezone you care about if this matters.
+ *
+ * @example
+ * toFrenchRepublican(new Date(1799, 10, 9)).formatted // => '18 Brumaire an VIII'
+ */
+export declare function toFrenchRepublican(date: Date): FrenchRepublicanDate;