@design-edito/tools 0.4.22 → 0.5.0

package/agnostic/objects/validation/index.js

@@ -11,12 +11,13 @@
  * Performs a shallow equality check for each property in `partial`.
  *
  * @template T - The type of the full object.
- * @param {T} obj - The object to validate.
- * @param {Partial<T>} partial - The partial object with key-value pairs to check.
- * @returns {boolean} `true` if all entries in `partial` match those in `obj`, otherwise `false`.
+ * @param obj - The object to validate.
+ * @param partial - The partial object with key-value pairs to check.
+ * @returns `true` if all entries in `partial` match those in `obj`, otherwise `false`.
  */
 export function fromPartial(obj, partial) {
     return Object.entries(partial).every(([key, val]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- key comes from Object.entries(partial), so it's always a key of T
         return obj[key] === val;
     });
 }

package/agnostic/optim/memoize/index.d.ts

@@ -5,8 +5,8 @@ type BasicFunc = (...args: any[]) => any;
  * Only performs shallow equality checks on arguments (strict equality `===`).
  *
  * @template T - The type of the function to memoize.
- * @param {T} toMemoizeFunc - The function to memoize.
- * @returns {T} A memoized version of the input function.
+ * @param toMemoizeFunc - The function to memoize.
+ * @returns A memoized version of the input function.
  */
 export declare function memoize<T extends BasicFunc>(toMemoizeFunc: T): T;
 export {};

package/agnostic/optim/memoize/index.js

@@ -4,8 +4,8 @@
  * Only performs shallow equality checks on arguments (strict equality `===`).
  *
  * @template T - The type of the function to memoize.
- * @param {T} toMemoizeFunc - The function to memoize.
- * @returns {T} A memoized version of the input function.
+ * @param toMemoizeFunc - The function to memoize.
+ * @returns A memoized version of the input function.
  */
 export function memoize(toMemoizeFunc) {
     let cachedArgs;
@@ -16,10 +16,12 @@ export function memoize(toMemoizeFunc) {
             && args.every((arg, i) => arg === cachedArgs?.[i]);
         if (argsMatch && cachedResult !== undefined)
             return cachedResult.value;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         const result = toMemoizeFunc(...args);
         cachedArgs = args;
         cachedResult = { value: result };
         return result;
     };
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- memoizedFunc has the same call signature as T by construction
     return memoizedFunc;
 }

package/agnostic/optim/throttle-debounce/index.d.ts

@@ -1,6 +1,6 @@
 type BasicFunction = (...args: any[]) => any;
 type ThrottledResult<T extends BasicFunction> = {
-    throttled: (...args: any[]) => {
+    throttled: (...args: unknown[]) => {
         returnValue: ReturnType<T> | undefined;
         lastExecutedOn: number;
         delayMs: number;
@@ -15,7 +15,7 @@ type ThrottledResult<T extends BasicFunction> = {
  */
 export declare function throttle<T extends BasicFunction = BasicFunction>(toThrottleFunc: T, delayMs: number): ThrottledResult<T>;
 type DebounceResult<T extends BasicFunction> = {
-    debounced: (...args: any[]) => {
+    debounced: (...args: unknown[]) => {
         returnValue: ReturnType<T> | undefined;
         lastExecutedOn: number;
         delayMs: number;

package/agnostic/optim/throttle-debounce/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment */
 /**
  * Returns a throttled version of the function passed as an argument
  * @param toThrottleFunc - The function that has to be throttled
@@ -20,19 +21,19 @@ export function throttle(toThrottleFunc, delayMs) {
         const msTillNextExecution = nextExecutionTimestamp - now;
         nextExecutionTimeout = setTimeout(() => {
             nextExecutionTimeout = null;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const returnValue = toThrottleFunc(...lastArgs);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             lastReturnValue = returnValue;
             lastExecutedOn = now;
-        }, msTillNextExecution) ?? null;
+        }, msTillNextExecution);
     }
     /** The throttled function */
     function throttled(...args) {
         const now = Date.now();
         lastArgs = args;
         if (now - lastExecutedOn >= delayMs) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const returnValue = toThrottleFunc(...lastArgs);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             lastReturnValue = returnValue;
             lastExecutedOn = now;
             return {
@@ -85,11 +86,11 @@ export function debounce(toDebounceFunc, delayMs) {
         const msTillNextExecution = nextExecutionTimestamp - now;
         nextExecutionTimeout = setTimeout(() => {
             nextExecutionTimeout = null;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const returnValue = toDebounceFunc(...lastArgs);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             lastReturnValue = returnValue;
             lastExecutedOn = now;
-        }, msTillNextExecution) ?? null;
+        }, msTillNextExecution);
     }
     /** The debounced function */
     function debounced(...args) {
@@ -97,8 +98,8 @@ export function debounce(toDebounceFunc, delayMs) {
         lastArgs = args;
         if (now - lastCalledOn >= currentDelayMs) {
             lastCalledOn = now;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             const returnValue = toDebounceFunc(...lastArgs);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             lastReturnValue = returnValue;
             lastExecutedOn = now;
             return {

package/agnostic/optim/throttle-debounce/types.d.ts

@@ -1,2 +1,3 @@
-import { type setTimeout } from 'node:timers';
+import type { setTimeout } from 'node:timers';
+/** The return type of Node.js `setTimeout`, used for typed timeout handles. */
 export type NodeTimeout = ReturnType<typeof setTimeout>;

package/agnostic/random/random/index.d.ts

@@ -1,17 +1,16 @@
 /**
  * Generates a random number within a range.
  *
- * @param {number} [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
- * @param {number} [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
- * @returns {number | undefined} A random floating-point number in `[min, max)`, or `undefined` if bounds are invalid.
+ * @param [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
+ * @param [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
+ * @returns A random floating-point number in `[min, max)`, or `undefined` if bounds are invalid.
  */
-export declare function random(bound1?: number): number | undefined;
-export declare function random(bound1?: number, bound2?: number | undefined): number | undefined;
+export declare function random(bound1?: number, bound2?: number): number | undefined;
 /**
  * Generates a random integer within a range.
  *
- * @param {number} [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
- * @param {number} [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
- * @returns {number | undefined} A random integer in `[min, max)`, or `undefined` if bounds are invalid.
+ * @param [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
+ * @param [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
+ * @returns A random integer in `[min, max)`, or `undefined` if bounds are invalid.
  */
 export declare function randomInt(...args: Parameters<typeof random>): number | undefined;

package/agnostic/random/random/index.js

@@ -9,9 +9,9 @@ export function random(bound1 = 1, bound2) {
 /**
  * Generates a random integer within a range.
  *
- * @param {number} [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
- * @param {number} [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
- * @returns {number | undefined} A random integer in `[min, max)`, or `undefined` if bounds are invalid.
+ * @param [bound1=1] - The lower bound if `bound2` is provided, otherwise the upper bound (min is 0).
+ * @param [bound2] - Optional upper bound. If omitted, the range is `[0, bound1)`.
+ * @returns A random integer in `[min, max)`, or `undefined` if bounds are invalid.
  */
 export function randomInt(...args) {
     const rand = random(...args);

package/agnostic/random/uuid/index.d.ts

@@ -1,21 +1,21 @@
 /**
  * Generates a random hexadecimal string of given length.
  *
- * @param {number} [length=4] - Number of hex characters.
- * @returns {string} Random hexadecimal string.
+ * @param [length=4] - Number of hex characters.
+ * @returns Random hexadecimal string.
  */
 export declare function randomHash(length?: number): string;
 /**
  * Generates a random hexadecimal string following a pattern.
  *
- * @param {number[]} pattern - Array of segment lengths.
- * @param {string} [joiner='-'] - String used to join the segments.
- * @returns {string} Random hexadecimal string with segments joined by `joiner`.
+ * @param pattern - Array of segment lengths.
+ * @param [joiner='-'] - String used to join the segments.
+ * @returns Random hexadecimal string with segments joined by `joiner`.
  */
 export declare function randomHashPattern(pattern: number[], joiner?: string): string;
 /**
  * Generates a random UUID-like string (version 4 style, not RFC-compliant).
  *
- * @returns {string} Random UUID-like string.
+ * @returns Random UUID-like string.
  */
 export declare function randomUUID(): string;

package/agnostic/random/uuid/index.js

@@ -2,8 +2,8 @@ import { randomHexChar } from '../hex-char/index.js';
 /**
  * Generates a random hexadecimal string of given length.
  *
- * @param {number} [length=4] - Number of hex characters.
- * @returns {string} Random hexadecimal string.
+ * @param [length=4] - Number of hex characters.
+ * @returns Random hexadecimal string.
  */
 export function randomHash(length = 4) {
     return new Array(length)
@@ -14,9 +14,9 @@ export function randomHash(length = 4) {
 /**
  * Generates a random hexadecimal string following a pattern.
  *
- * @param {number[]} pattern - Array of segment lengths.
- * @param {string} [joiner='-'] - String used to join the segments.
- * @returns {string} Random hexadecimal string with segments joined by `joiner`.
+ * @param pattern - Array of segment lengths.
+ * @param [joiner='-'] - String used to join the segments.
+ * @returns Random hexadecimal string with segments joined by `joiner`.
  */
 export function randomHashPattern(pattern, joiner = '-') {
     return pattern.map(randomHash).join(joiner);
@@ -24,7 +24,7 @@ export function randomHashPattern(pattern, joiner = '-') {
 /**
  * Generates a random UUID-like string (version 4 style, not RFC-compliant).
  *
- * @returns {string} Random UUID-like string.
+ * @returns Random UUID-like string.
  */
 export function randomUUID() {
     return randomHashPattern([8, 4, 4, 4, 12]);

package/agnostic/regexps/index.d.ts

@@ -1,89 +1,59 @@
 /**
  * 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 declare function mergeFlags(...flagStrs: string[]): string;
 /**
  * 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 declare function setFlags(regexp: RegExp, flags: string): RegExp;
 /**
  * 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 declare function fromStart(regexp: RegExp, flags?: string): RegExp;
 /**
  * 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 declare function toEnd(regexp: RegExp, flags?: string): RegExp;
 /**
  * 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 declare function fromStartToEnd(regexp: RegExp, flags?: string): RegExp;
-/**
- * Checks if a string starts with a pattern.
- *
- * @param string - The string to test.
- * @param regexp - The regular expression pattern.
- * @param [returnMatches=false] - If true, returns matches; otherwise, returns boolean.
- * @param [flags='g'] - Optional flags.
- * @returns {boolean | RegExpMatchArray | null} Boolean or match array based on `returnMatches`.
- */
-export declare function stringStartsWith(string: string, regexp: RegExp): boolean;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: false): boolean;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: false, flags: string): boolean;
-export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: true, flags: string): RegExpMatchArray | null;
-/**
- * Checks if a string ends with a pattern.
- *
- * @param string - The string to test.
- * @param regexp - The regular expression pattern.
- * @param [returnMatches=false] - If true, returns matches; otherwise, returns boolean.
- * @param [flags='g'] - Optional flags.
- * @returns {boolean | RegExpMatchArray | null} Boolean or match array based on `returnMatches`.
- */
-export declare function stringEndsWith(string: string, regexp: RegExp): boolean;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: false): boolean;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: false, flags: string): boolean;
-export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: true, flags: string): RegExpMatchArray | null;
-/**
- * Checks if a string fully matches a pattern.
- *
- * @param string - The string to test.
- * @param regexp - The regular expression pattern.
- * @param [returnMatches=false] - If true, returns matches; otherwise, returns boolean.
- * @param [flags='g'] - Optional flags.
- * @returns {boolean | RegExpMatchArray | null} Boolean or match array based on `returnMatches`.
- */
-export declare function stringIs(string: string, regexp: RegExp): boolean;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: false): boolean;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: false, flags: string): boolean;
-export declare function stringIs(string: string, regexp: RegExp, returnMatches: true, flags: string): RegExpMatchArray | null;
+/** Returns `true` if `string` starts with `regexp`. */
+export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches?: false, flags?: string): boolean;
+/** Returns the match array if `string` starts with `regexp` using `flags`, or `null` if not. */
+export declare function stringStartsWith(string: string, regexp: RegExp, returnMatches: true, flags?: string): RegExpMatchArray | null;
+/** Returns `true` if `string` ends with `regexp`, applying `flags`. */
+export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches?: false, flags?: string): boolean;
+/** Returns the match array if `string` ends with `regexp` using `flags`, or `null` if not. */
+export declare function stringEndsWith(string: string, regexp: RegExp, returnMatches: true, flags?: string): RegExpMatchArray | null;
+/** Returns `true` if `string` fully matches `regexp`, applying `flags`. */
+export declare function stringIs(string: string, regexp: RegExp, returnMatches?: false, flags?: string): boolean;
+/** Returns the match array if `string` fully matches `regexp` using `flags`, or `null` if not. */
+export declare function stringIs(string: string, regexp: RegExp, returnMatches: true, flags?: string): RegExpMatchArray | null;
 /**
  * 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 declare function fromStrings(strings: string[]): RegExp;
 /**
@@ -92,7 +62,7 @@ export declare function fromStrings(strings: string[]): RegExp;
  * - 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 declare function escape(string: string): string;

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/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.