@design-edito/tools 0.4.23 → 0.5.1

package/agnostic/objects/record-format/index.d.ts

@@ -4,8 +4,8 @@ import type { UnwrapPromise } from '../../typescript/types.js';
  *
  * @template InputType - The type of the input value the formatter receives.
  * @template OutputType - The type of the value the formatter returns (or resolves to if Promise).
- * @param {InputType} val - The input value to transform.
- * @returns {OutputType | Promise<OutputType>} The transformed value or a Promise resolving to it.
+ * @param val - The input value to transform.
+ * @returns The transformed value or a Promise resolving to it.
  */
 export type FormatterFunc<InputType, OutputType> = (val: InputType) => OutputType | Promise<OutputType>;
 /**
@@ -14,8 +14,8 @@ export type FormatterFunc<InputType, OutputType> = (val: InputType) => OutputTyp
  *
  * @template InputObject - The type of the input object being formatted.
  */
-export type Format<InputObject extends Record<PropertyKey, any>> = {
-    [Key in keyof InputObject]?: FormatterFunc<InputObject[Key], any>;
+export type Format<InputObject extends Record<PropertyKey, unknown>> = {
+    [Key in keyof InputObject]?: FormatterFunc<InputObject[Key], unknown>;
 };
 /**
  * The resulting object after applying all formatters and unwrapping any returned Promises.
@@ -23,15 +23,15 @@ export type Format<InputObject extends Record<PropertyKey, any>> = {
  * @template FormatObject - The type of the format object mapping keys to formatter functions.
  */
 export type Formatted<FormatObject> = {
-    [Key in keyof FormatObject]: FormatObject[Key] extends FormatterFunc<any, any> ? UnwrapPromise<ReturnType<FormatObject[Key]>> : never;
+    [Key in keyof FormatObject]: FormatObject[Key] extends FormatterFunc<unknown, unknown> ? UnwrapPromise<ReturnType<FormatObject[Key]>> : never;
 };
 /**
  * Applies a set of formatter functions to the corresponding properties of an input object.
  *
  * @template InputObject - The type of the input object.
  * @template FormatObject - The type of the format object mapping keys to formatter functions.
- * @param {InputObject} input - The object whose properties are to be formatted.
- * @param {FormatObject} format - An object containing formatter functions for each key.
- * @returns {Promise<Formatted<FormatObject>>} A Promise resolving to the formatted object with all promises unwrapped.
+ * @param input - The object whose properties are to be formatted.
+ * @param format - An object containing formatter functions for each key.
+ * @returns A Promise resolving to the formatted object with all promises unwrapped.
  */
-export declare function recordFormat<InputObject extends Record<PropertyKey, any>, FormatObject extends Format<InputObject>>(input: InputObject, format: FormatObject): Promise<Formatted<FormatObject>>;
+export declare function recordFormat<InputObject extends Record<PropertyKey, unknown>, FormatObject extends Format<InputObject>>(input: InputObject, format: FormatObject): Promise<Formatted<FormatObject>>;

package/agnostic/objects/record-format/index.js

@@ -3,17 +3,22 @@
  *
  * @template InputObject - The type of the input object.
  * @template FormatObject - The type of the format object mapping keys to formatter functions.
- * @param {InputObject} input - The object whose properties are to be formatted.
- * @param {FormatObject} format - An object containing formatter functions for each key.
- * @returns {Promise<Formatted<FormatObject>>} A Promise resolving to the formatted object with all promises unwrapped.
+ * @param input - The object whose properties are to be formatted.
+ * @param format - An object containing formatter functions for each key.
+ * @returns A Promise resolving to the formatted object with all promises unwrapped.
  */
 export async function recordFormat(input, format) {
     const result = {};
     for (const key in format) {
+        // eslint-disable-next-line prefer-object-has-own
+        if (!Object.prototype.hasOwnProperty.call(format, key))
+            continue;
         const formatter = format[key];
         if (formatter === undefined)
             continue;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-explicit-any
         result[key] = await formatter(input[key]);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- result was populated with a formatted value for every key of format in the loop above
     return result;
 }

package/agnostic/objects/record-map/index.d.ts

@@ -3,10 +3,10 @@
  *
  * @template Input - The type of the input record.
  * @template MappedValue - The type of the mapped values.
- * @param {Input} record - The record whose values will be mapped.
- * @param {(value: Input[keyof Input], key: keyof Input) => MappedValue} mapper - Function to transform each value.
- * @returns {{ [K in keyof Input]: MappedValue }} A new record with the same keys and mapped values.
+ * @param record - The record whose values will be mapped.
+ * @param mapper - Function to transform each value.
+ * @returns A new record with the same keys and mapped values.
  */
-export declare function recordMap<Input extends Record<string, any>, MappedValue>(record: Input, mapper: (value: Input[keyof Input], key: keyof Input) => MappedValue): {
+export declare function recordMap<Input extends Record<string, unknown>, MappedValue>(record: Input, mapper: (value: Input[keyof Input], key: keyof Input) => MappedValue): {
     [K in keyof Input]: MappedValue;
 };

package/agnostic/objects/record-map/index.js

@@ -3,16 +3,18 @@
  *
  * @template Input - The type of the input record.
  * @template MappedValue - The type of the mapped values.
- * @param {Input} record - The record whose values will be mapped.
- * @param {(value: Input[keyof Input], key: keyof Input) => MappedValue} mapper - Function to transform each value.
- * @returns {{ [K in keyof Input]: MappedValue }} A new record with the same keys and mapped values.
+ * @param record - The record whose values will be mapped.
+ * @param mapper - Function to transform each value.
+ * @returns A new record with the same keys and mapped values.
  */
 export function recordMap(record, mapper) {
     const result = {};
     for (const key in record) {
+        // eslint-disable-next-line prefer-object-has-own
         if (Object.prototype.hasOwnProperty.call(record, key)) {
             result[key] = mapper(record[key], key);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- result was populated with a mapped value for every key of Input in the loop above
     return result;
 }

package/agnostic/objects/sort-keys/index.d.ts

@@ -2,9 +2,9 @@
  * Returns a new object with the keys sorted according to the provided sorter.
  *
  * @template T - The type of the input object.
- * @param {T} obj - The object whose keys should be sorted.
- * @param {(a: keyof T, b: keyof T) => number} [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
- * @returns {{ [K in keyof T]: T[K] }} A new object with the same keys and values as the input, but sorted by key.
+ * @param obj - The object whose keys should be sorted.
+ * @param [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
+ * @returns A new object with the same keys and values as the input, but sorted by key.
  */
 export declare function sortKeys<T extends Record<string, unknown>>(obj: T, sorter?: (a: keyof T, b: keyof T) => number): {
     [K in keyof T]: T[K];

package/agnostic/objects/sort-keys/index.js

@@ -2,9 +2,9 @@
  * Returns a new object with the keys sorted according to the provided sorter.
  *
  * @template T - The type of the input object.
- * @param {T} obj - The object whose keys should be sorted.
- * @param {(a: keyof T, b: keyof T) => number} [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
- * @returns {{ [K in keyof T]: T[K] }} A new object with the same keys and values as the input, but sorted by key.
+ * @param obj - The object whose keys should be sorted.
+ * @param [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
+ * @returns A new object with the same keys and values as the input, but sorted by key.
  */
 export function sortKeys(obj, sorter = (a, b) => String(a).localeCompare(String(b))) {
     const out = {};
@@ -12,5 +12,6 @@ export function sortKeys(obj, sorter = (a, b) => String(a).localeCompare(String(
     for (const key of keys.sort(sorter)) {
         out[key] = obj[key];
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- out was populated with every key of T in the loop above
     return out;
 }

package/agnostic/objects/validation/index.d.ts

@@ -4,8 +4,8 @@
  * 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 declare function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;

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/index.d.ts

@@ -1,3 +1,3 @@
-export * as hexChar from './hex-char/index.js'
 export * as random from './random/index.js'
 export * as uuid from './uuid/index.js'
+export * as hexChar from './hex-char/index.js'

package/agnostic/random/index.js

@@ -1,3 +1,3 @@
-export * as hexChar from './hex-char/index.js'
 export * as random from './random/index.js'
 export * as uuid from './uuid/index.js'
+export * as hexChar from './hex-char/index.js'

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;