@design-edito/tools 0.2.39 → 0.2.40

package/agnostic/objects/is-object/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Checks if a value is of type "object", including `null`.
+ *
+ * @param {unknown} unk - The value to check.
+ * @returns {unk is object | null} `true` if the value is an object or `null`, otherwise `false`.
+ */
 export declare function isObject(unk: unknown): unk is object | null;
+/**
+ * Checks if a value is a non-null object.
+ *
+ * @param {unknown} unk - The value to check.
+ * @returns {unk is object} `true` if the value is a non-null object, otherwise `false`.
+ */
 export declare function isNonNullObject(unk: unknown): unk is object;

package/agnostic/objects/is-object/index.js

@@ -2,7 +2,7 @@ import {
   isNonNullObject,
   isObject
 } from "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   isNonNullObject,
   isObject

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

@@ -1 +1,7 @@
+/**
+ * Checks if a value is a plain object with string keys.
+ *
+ * @param {unknown} input - The value to check.
+ * @returns {input is Record<string, unknown>} `true` if the value is an object with string keys, otherwise `false`.
+ */
 export declare function isRecord(input: unknown): input is Record<string, unknown>;

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

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

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

@@ -1,11 +1,38 @@
+/**
+ * A key of the input object or a string.
+ */
 export type FormatKey<Input extends {} = any> = keyof Input | string;
+/**
+ * The value type of a given key in the input object, or `undefined` if the key does not exist.
+ */
 export type InputValue<Input extends {}, Key extends FormatKey<Input>> = Input extends Record<Key, infer V> ? V : undefined;
+/**
+ * A function that transforms a value of type I into type O, can return a Promise.
+ */
 export type FormatterFunc<I, O> = (val: I) => O | Promise<O>;
+/**
+ * An object mapping keys to formatter functions.
+ */
 export type Format<Input extends {} = any> = {
     [Key in FormatKey<Input>]: FormatterFunc<InputValue<Input, Key>, any>;
 };
+/**
+ * Utility type that extracts the resolved type of a Promise, or returns the type itself if not a Promise.
+ */
 export type UnwrapPromise<PromiseOrNot> = PromiseOrNot extends Promise<infer Resolved> ? Resolved : PromiseOrNot;
+/**
+ * The object type resulting from applying all formatters and unwrapping any Promises.
+ */
 export type Formatted<F extends Format<{}>> = {
     [Key in keyof F]: UnwrapPromise<ReturnType<F[Key]>>;
 };
+/**
+ * Applies a set of formatter functions to the corresponding properties of an input object.
+ *
+ * @template I - Input object type.
+ * @template F - Format object type mapping keys to formatter functions.
+ * @param {I} input - The object to format.
+ * @param {F} format - An object of formatter functions for each key.
+ * @returns {Promise<Formatted<F>>} A Promise resolving to the formatted object with all promises unwrapped.
+ */
 export declare function recordFormat<I extends {}, F extends Format<I>>(input: I, format: F): Promise<Formatted<F>>;

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

@@ -1,7 +1,18 @@
-import {
-  recordFormat
-} from "../../../chunks/chunk-YP64J65L.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/objects/record-format/index.ts
+async function recordFormat(input, format) {
+  const result = {};
+  for (const key in format) {
+    const formatter = format[key];
+    if (typeof formatter === "function") {
+      result[key] = await formatter(input[key]);
+    } else {
+      result[key] = formatter;
+    }
+  }
+  return result;
+}
 export {
   recordFormat
 };

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

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

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

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

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

@@ -1,3 +1,11 @@
-export declare namespace Validation {
-    function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;
-}
+/**
+ * Checks if an object contains all the key-value pairs from a partial object.
+ *
+ * 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`.
+ */
+export declare function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;

package/agnostic/objects/validation/index.js

@@ -1,7 +1,11 @@
-import {
-  Validation
-} from "../../../chunks/chunk-FPEW3A27.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/objects/validation/index.ts
+function fromPartial(obj, partial) {
+  return Object.entries(partial).every(([key, val]) => {
+    return obj[key] === val;
+  });
+}
 export {
-  Validation
+  fromPartial
 };

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

@@ -1,3 +1,12 @@
 type BasicFunc = (...args: any[]) => any;
-export declare function memoize<T extends BasicFunc = BasicFunc>(toMemoizeFunc: T): (...args: Parameters<T>) => any;
+/**
+ * Creates a memoized version of a function, caching the result for repeated calls with the same arguments.
+ *
+ * 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.
+ */
+export declare function memoize<T extends BasicFunc>(toMemoizeFunc: T): T;
 export {};

package/agnostic/optim/memoize/index.js

@@ -1,7 +1,19 @@
-import {
-  memoize
-} from "../../../chunks/chunk-JWBDZPQG.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/optim/memoize/index.ts
+function memoize(toMemoizeFunc) {
+  let cachedArgs;
+  let cachedResult;
+  const memoizedFunc = (...args) => {
+    const argsMatch = cachedArgs !== void 0 && args.length === cachedArgs.length && args.every((arg, i) => arg === cachedArgs[i]);
+    if (argsMatch && cachedResult !== void 0) return cachedResult.value;
+    const result = toMemoizeFunc(...args);
+    cachedArgs = args;
+    cachedResult = { value: result };
+    return result;
+  };
+  return memoizedFunc;
+}
 export {
   memoize
 };

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

@@ -1,8 +1,113 @@
-import {
-  debounce,
-  throttle
-} from "../../../chunks/chunk-VZDUZTW6.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/optim/throttle-debounce/index.ts
+function throttle(toThrottleFunc, delayMs) {
+  let currentDelayMs = delayMs;
+  let lastArgs = [];
+  let lastExecutedOn = 0;
+  let lastReturnValue = void 0;
+  let nextExecutionTimeout = null;
+  function scheduleNextCall() {
+    if (nextExecutionTimeout !== null) {
+      clearTimeout(nextExecutionTimeout);
+      nextExecutionTimeout = null;
+    }
+    const now = Date.now();
+    const nextExecutionTimestamp = lastExecutedOn + currentDelayMs;
+    const msTillNextExecution = nextExecutionTimestamp - now;
+    nextExecutionTimeout = setTimeout(() => {
+      nextExecutionTimeout = null;
+      const returnValue = toThrottleFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+    }, msTillNextExecution) ?? null;
+  }
+  function throttled(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (now - lastExecutedOn >= delayMs) {
+      const returnValue = toThrottleFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+      return {
+        returnValue: lastReturnValue,
+        lastExecutedOn,
+        delayMs: currentDelayMs,
+        isCached: false
+      };
+    }
+    if (nextExecutionTimeout === null) scheduleNextCall();
+    return {
+      returnValue: lastReturnValue,
+      lastExecutedOn,
+      delayMs: currentDelayMs,
+      isCached: true
+    };
+  }
+  function setDelay(delayMs2) {
+    currentDelayMs = delayMs2;
+    if (nextExecutionTimeout !== null) scheduleNextCall();
+  }
+  return {
+    throttled,
+    setDelay
+  };
+}
+function debounce(toDebounceFunc, delayMs) {
+  let currentDelayMs = delayMs;
+  let lastArgs = [];
+  let lastCalledOn = 0;
+  let lastExecutedOn = 0;
+  let lastReturnValue = void 0;
+  let nextExecutionTimeout = null;
+  function scheduleNextCall() {
+    if (typeof nextExecutionTimeout === "number") {
+      clearTimeout(nextExecutionTimeout);
+      nextExecutionTimeout = null;
+    }
+    const now = Date.now();
+    const nextExecutionTimestamp = lastCalledOn + currentDelayMs;
+    const msTillNextExecution = nextExecutionTimestamp - now;
+    nextExecutionTimeout = setTimeout(() => {
+      nextExecutionTimeout = null;
+      const returnValue = toDebounceFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+    }, msTillNextExecution) ?? null;
+  }
+  function debounced(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (now - lastCalledOn >= currentDelayMs) {
+      lastCalledOn = now;
+      const returnValue = toDebounceFunc(...lastArgs);
+      lastReturnValue = returnValue;
+      lastExecutedOn = now;
+      return {
+        returnValue: lastReturnValue,
+        lastExecutedOn,
+        delayMs: currentDelayMs,
+        isCached: false
+      };
+    }
+    lastCalledOn = now;
+    scheduleNextCall();
+    return {
+      returnValue: lastReturnValue,
+      lastExecutedOn,
+      delayMs: currentDelayMs,
+      isCached: true
+    };
+  }
+  function setDelay(delayMs2) {
+    currentDelayMs = delayMs2;
+    if (nextExecutionTimeout !== null) scheduleNextCall();
+  }
+  return {
+    debounced,
+    setDelay
+  };
+}
 export {
   debounce,
   throttle

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

@@ -1,2 +1,2 @@
 import { setTimeout } from 'node:timers';
-export type Timeout = ReturnType<typeof setTimeout>;
+export type NodeTimeout = ReturnType<typeof setTimeout>;

package/agnostic/random/hex-char/index.d.ts

@@ -1,2 +1,4 @@
+/** List of hex chars (0-9a-f) */
 export declare const hexChars: string[];
+/** Generates a random hexadecimal char (0-9a-f) */
 export declare function randomHexChar(): string;

package/agnostic/random/hex-char/index.js

@@ -2,7 +2,7 @@ import {
   hexChars,
   randomHexChar
 } from "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   hexChars,
   randomHexChar

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

@@ -1,3 +1,17 @@
+/**
+ * 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.
+ */
 export declare function random(bound1?: number): number | undefined;
 export declare function random(bound1?: number, bound2?: number | undefined): 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.
+ */
 export declare function randomInt(...args: Parameters<typeof random>): number | undefined;

package/agnostic/random/random/index.js

@@ -2,7 +2,7 @@ import {
   random,
   randomInt
 } from "../../../chunks/chunk-D3ERTRDW.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   random,
   randomInt

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

@@ -1,3 +1,21 @@
+/**
+ * Generates a random hexadecimal string of given length.
+ *
+ * @param {number} [length=4] - Number of hex characters.
+ * @returns {string} 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`.
+ */
 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.
+ */
 export declare function randomUUID(): string;

package/agnostic/random/uuid/index.js

@@ -4,7 +4,7 @@ import {
   randomUUID
 } from "../../../chunks/chunk-75BICI4L.js";
 import "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   randomHash,
   randomHashPattern,

package/agnostic/regexps/index.d.ts

@@ -1,24 +1,95 @@
-export declare namespace Regexps {
-    function mergeFlags(...flagStrs: string[]): string;
-    function setFlags(regexp: RegExp, _flags: string): RegExp;
-    function fromStart(regexp: RegExp, _flags?: string): RegExp;
-    function toEnd(regexp: RegExp, _flags?: string): RegExp;
-    function fromStartToEnd(regexp: RegExp, _flags?: string): RegExp;
-    function stringStartsWith(string: string, _regexp: RegExp): boolean;
-    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
-    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
-    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
-    function stringEndsWith(string: string, _regexp: RegExp): boolean;
-    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
-    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
-    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
-    function stringIs(string: string, _regexp: RegExp): boolean;
-    function stringIs(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
-    function stringIs(string: string, _regexp: RegExp, returnMatches: false): boolean;
-    function stringIs(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
-    function stringIs(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
-    function fromStrings(strings: string[]): RegExp;
-    function escape(string: string): string;
-}
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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=true] - 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=true] - 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;
+/**
+ * Creates a RegExp that matches any of the provided strings.
+ *
+ * @param {string[]} strings - Strings to match.
+ * @returns {RegExp} Regular expression matching all strings.
+ */
+export declare function fromStrings(strings: string[]): RegExp;
+/**
+ * Escapes special RegExp characters in a string.
+ *
+ * @param {string} string - String to escape.
+ * @returns {string} Escaped string.
+ */
+export declare function escape(string: string): string;

package/agnostic/regexps/index.js

@@ -1,7 +1,88 @@
-import {
-  Regexps
-} from "../../chunks/chunk-YPTFPS76.js";
-import "../../chunks/chunk-WSFCRVEQ.js";
+import "../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/regexps/index.ts
+function mergeFlags(...flagStrs) {
+  const flagsSet = /* @__PURE__ */ new Set();
+  flagStrs.forEach(
+    (flagStr) => flagStr.split("").forEach((char) => flagsSet.add(char))
+  );
+  return Array.from(flagsSet.values()).join("");
+}
+function setFlags(regexp, flags) {
+  const mergedFlags = mergeFlags(regexp.flags, flags);
+  return new RegExp(`${regexp.source}`, mergedFlags);
+}
+function fromStart(regexp, flags = "g") {
+  const mergedFlags = mergeFlags(regexp.flags, flags);
+  return new RegExp(`^(${regexp.source})`, mergedFlags);
+}
+function toEnd(regexp, flags = "g") {
+  const mergedFlags = mergeFlags(regexp.flags, flags);
+  return new RegExp(`(${regexp.source})$`, mergedFlags);
+}
+function fromStartToEnd(regexp, flags = "g") {
+  const mergedFlags = mergeFlags(regexp.flags, flags);
+  return fromStart(toEnd(regexp, mergedFlags), mergedFlags);
+}
+function stringStartsWith(string, regexp, returnMatches = true, flags = "g") {
+  const actualRegexp = fromStart(regexp, flags);
+  return returnMatches ? string.match(actualRegexp) : actualRegexp.test(string);
+}
+function stringEndsWith(string, regexp, returnMatches = true, flags = "g") {
+  const actualRegexp = toEnd(regexp, flags);
+  return returnMatches ? string.match(actualRegexp) : actualRegexp.test(string);
+}
+function stringIs(string, regexp, returnMatches = false, flags = "g") {
+  const actualRegexp = fromStartToEnd(regexp, flags);
+  return returnMatches ? string.match(actualRegexp) : actualRegexp.test(string);
+}
+function fromStrings(strings) {
+  const rootsMap = stringsToRootsMap(strings);
+  const source = sourceFromRootsMap(rootsMap, false);
+  const regexp = new RegExp(source);
+  return regexp;
+}
+function escape(string) {
+  return string.replace(/\s/igm, "\\s").replace(/\n/igm, "\\n").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stringsToRootsMap(strings, rootsMap = /* @__PURE__ */ new Map()) {
+  const lengthSorted = strings.sort((strA, strB) => strA.length - strB.length);
+  lengthSorted.forEach((string) => {
+    const [firstChar, ...lastChars] = string.split("");
+    const isWordEnd = lastChars.length === 0;
+    if (firstChar === void 0) return;
+    const roots = Array.from(rootsMap.keys());
+    const foundRoot = roots.find((root) => new RegExp(`^(${escape(root)})`).test(string));
+    const subRootsMap = foundRoot !== void 0 ? rootsMap.get(foundRoot)?.subRootsMap : void 0;
+    if (foundRoot === void 0 || subRootsMap === void 0) {
+      const subRootsMap2 = /* @__PURE__ */ new Map();
+      stringsToRootsMap([lastChars.join("")], subRootsMap2);
+      return rootsMap.set(firstChar, { subRootsMap: subRootsMap2, isWordEnd });
+    }
+    stringsToRootsMap([lastChars.join("")], subRootsMap);
+  });
+  return rootsMap;
+}
+function sourceFromRootsMap(rootsMap, isOptional) {
+  const rootsMapEntries = Array.from(rootsMap.entries());
+  if (rootsMapEntries.length === 0) return "";
+  const regexpBody = rootsMapEntries.map(([root, rootData]) => {
+    return `${escape(root)}${sourceFromRootsMap(
+      rootData.subRootsMap,
+      rootData.isWordEnd
+    )}`;
+  }).join("|");
+  return isOptional ? `(${regexpBody})?` : `(${regexpBody})`;
+}
 export {
-  Regexps
+  escape,
+  fromStart,
+  fromStartToEnd,
+  fromStrings,
+  mergeFlags,
+  setFlags,
+  stringEndsWith,
+  stringIs,
+  stringStartsWith,
+  toEnd
 };

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

@@ -0,0 +1,13 @@
+/**
+ * Sanitizes a single file name by removing invalid characters and normalizing Unicode.
+ *
+ * - Removes characters forbidden in Windows and Unix file systems.
+ * - Replaces multiple spaces with a single space.
+ * - 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.
+ */
+export declare function sanitizeFileName(input: string, maxLength?: number): string | null;

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

@@ -0,0 +1,7 @@
+import {
+  sanitizeFileName
+} from "../../../chunks/chunk-HYPEWMYZ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+export {
+  sanitizeFileName
+};