@dxtmisha/functional-basic 1.14.0 → 2.0.1

package/ai-types.md

@@ -1,4 +1,4 @@
-All these methods are in the @dxtmisha/functional-basic (v1.14.0) library.
+All these methods are in the @dxtmisha/functional-basic (v2.0.1) library.
 
 ```typescript
 /** HTTP client manager for making requests and configuring API settings. @keywords http, client, api, request, fetch */
@@ -79,18 +79,20 @@ export declare class Cache {
     getAsync<T>(name: string, callback: () => T, comparison?: unknown[]): Promise<T>;
 }
 
-/** Class for managing browser cookies. @keywords cookie, storage, browser */
-export declare class Cookie<T> {
-    /** Creates a new Cookie manager instance for the specified cookie name. @keywords cookie, constructor */
-    constructor(name: string);
-    /** Retrieves or creates an instance for the specified cookie name. @keywords cookie, getInstance, factory */
-    static getInstance<T>(name: string): Cookie<T>;
-    /** Retrieves cookie data or initializes with default value if absent. @keywords get, read, cookie */
-    get(defaultValue?: T | string | (() => (T | string)), options?: CookieOptions): T | string | undefined;
-    /** Updates or sets cookie data. @keywords set, write, update, cookie */
-    set(value?: T | string | (() => (T | string)), options?: CookieOptions): void;
-    /** Deletes the cookie. @keywords delete, remove, cookie */
-    remove(): void;
+/** Resolves the return type of Cookie.get based on generic type and default fallback. @keywords cookie, return type, fallback */
+export type CookieGet<T, D = undefined> = [D] extends [undefined] ? (T | undefined) : unknown extends T ? (D extends () => infer R ? R : D) : (T | (D extends () => infer R ? R : D));
+/** Cookie manager for reading, writing, and deleting browser cookies. @keywords cookie, storage, browser */
+export declare class Cookie<T = unknown> {
+  /** Initializes a Cookie instance for the specified cookie name. @keywords cookie, init, constructor */
+  constructor(name: string);
+  /** Retrieves a Cookie instance by the specified cookie name. @keywords cookie, getInstance, factory */
+  static getInstance<T = unknown>(name: string): Cookie<T>;
+  /** Retrieves the cookie value or sets and returns a default value if not set. @keywords cookie, get, read, fallback */
+  get<D extends T | string | (() => (T | string)) | undefined = undefined>(defaultValue?: D, options?: CookieOptions): CookieGet<T, D>;
+  /** Updates the cookie value with optional configuration parameters. @keywords cookie, set, write, update */
+  set(value?: T | string | (() => (T | string)), options?: CookieOptions): void;
+  /** Deletes the cookie. @keywords cookie, remove, delete, clear */
+  remove(): void;
 }
 
 /** Manages cookie access and blocking status. @keywords cookie, block, access, permissions */
@@ -103,9 +105,13 @@ export declare class CookieBlock {
     static getItem(): CookieBlockInstance;
 }
 
-export type CookieSameSite = 'strict' | 'lax';
-
-/** Cookie configuration options @keywords cookie, options, settings */
+export type CookieSameSite = 'strict' | 'lax' | 'none';
+/** Resolves return type of CookieStorage.get based on fallback value. @keywords cookie return type */
+export type CookieStorageGet<T, D = undefined> = [
+    D
+] extends [
+    undefined
+] ? (T | undefined) : unknown extends T ? (D extends () => infer R ? R : D) : T;
 export type CookieOptions = {
     age?: number;
     sameSite?: CookieSameSite;
@@ -114,216 +120,237 @@ export type CookieOptions = {
     secure?: boolean;
     httpOnly?: boolean;
     partitioned?: boolean;
-    arguments?: string[] | Record<string, string | number | boolean>;
+    arguments?: string[] | Record<string, unknown>;
 };
-
-/** Universal cookie storage manager supporting custom listeners for DOM and SSR environments @keywords cookie, storage, ssr, persistence */
+/** Manages cookies with support for DOM, SSR, and custom storage listeners. @keywords cookie storage ssr browser */
 export declare class CookieStorage {
-    /** Retrieves data from cookie storage with optional fallback @keywords cookie, get, read */
-    static get<T>(name: string, defaultValue?: T | (() => T)): T | undefined;
-    /** Stores a value in cookies with configurable options @keywords cookie, set, write, save */
-    static set<T>(name: string, value: T | (() => T), options?: CookieOptions): T;
-    /** Removes a cookie by name from storage @keywords cookie, remove, delete */
-    static remove(name: string): void;
-    /** Synchronizes and updates data from current cookies @keywords cookie, update, sync, refresh */
+    /** Retrieves a cookie value or returns the default fallback. @keywords cookie get read storage */
+    static get<T = unknown, D extends T | (() => T) | undefined = undefined>(name: string, defaultValue?: D, options?: CookieOptions): CookieStorageGet<T, D>;
+    /** Writes a cookie value with optional attributes. @keywords cookie set save write */
+    static set<T = unknown>(name: string, value: T | (() => T), options?: CookieOptions): T;
+    /** Deletes a cookie from storage. @keywords cookie remove delete */
+    static remove(name: string, options?: CookieOptions): void;
+    /** Synchronizes and updates cache from current cookie sources. @keywords cookie update refresh sync */
     static update(): void;
-    /** Clears all in-memory items and resets registered listeners @keywords cookie, reset, clear */
+    /** Clears in-memory items and resets listeners to default state. @keywords cookie reset clear */
     static reset(): void;
-    /** Initializes storage listeners for custom cookie retrieval and persistence @keywords cookie, init, setup, listeners */
+    /**
+     * Initializes storage listeners and hooks for custom or SSR runtimes.
+     * @remarks When omitted, DOM runtime defaults to `document.cookie`, while non-DOM/SSR falls back to in-memory caching.
+     * @keywords cookie init setup listeners ssr
+     */
     static init(getListener?: (key: string) => unknown, getListenerRaw?: () => string, setListener?: (key: string, value: string, cookie: string, options?: CookieOptions) => void): void;
 }
 
-/** Storage manager for localStorage and sessionStorage with prefix, TTL expiration, and SSR isolation support. @keywords localstorage, sessionstorage, storage, cache, ssr */
-export declare class DataStorage<T> {
-    /** Initializes storage key, storage type, and optional error handler. @keywords constructor, init, storage */
+/** Resolution type for DataStorage.get return value with fallback handling. @keywords storage, return type */
+export type DataStorageGet<T, D = undefined> = [
+    D
+] extends [
+    undefined
+] ? (T | undefined) : unknown extends T ? (D extends () => infer R ? R : D) : T;
+/** Manages localStorage and sessionStorage with prefixing, expiration caching, and SSR request isolation. @keywords storage, localStorage, sessionStorage, cache, ssr */
+export declare class DataStorage<T = unknown> {
+    /** Initializes storage instance with key name, storage target, and error handler. @keywords storage, constructor, session */
     constructor(name: string, isSession?: boolean, errorCenter?: ErrorCenterInstance);
-    /** Retrieves stored value with optional fallback and cache expiration in seconds. @keywords get, read, retrieve, cache */
-    get(defaultValue?: T | (() => T), cache?: number): T | undefined;
-    /** Updates stored value using a direct value or resolver function. @keywords set, write, update, store */
+    /** Retrieves item from storage with optional default fallback and cache TTL in seconds. @keywords storage, get, read, cache */
+    get<D extends T | (() => T) | undefined = undefined>(defaultValue?: D, cache?: number): DataStorageGet<T, D>;
+    /** Writes value or generator result to storage. @keywords storage, set, write */
     set(value?: T | (() => T)): T | undefined;
-    /** Configures global storage key prefix. @keywords setPrefix, prefix, namespace */
+    /** Returns fully-qualified storage key including prefix. @keywords storage, key, index, prefix */
+    getIndex(): string;
+    /** Sets process-wide key prefix for bootstrapping. @note Applies globally to entire runtime process in SSR. @keywords storage, prefix, config */
     static setPrefix(newPrefix: string): void;
-    /** Removes stored item from storage. @keywords remove, delete, clear */
+    /** Deletes item from storage. @keywords storage, remove, delete, clear */
     remove(): this;
-    /** Synchronizes data from storage into instance. @keywords update, sync, refresh */
+    /** Synchronizes and refreshes data from storage. @keywords storage, sync, update, refresh */
     update(): this;
 }
 
 /**
- * Date manipulation and localization utility class.
- *
- * @remarks
- * Creating a `Datetime` instance without a specific date (using the current time)
- * for rendering in SSR may lead to hydration mismatches because the time or time zone
- * on the server may differ from the time on the client.
- * @keywords datetime, date, calendar, timezone, localization, intl
+ * Class for working with dates, time, and internationalized calendar calculations.
+ * @remarks Creating a `Datetime` instance without a specific date (using the current time) for rendering in SSR may lead to hydration mismatches because the time or time zone on the server may differ from the time on the client.
+ * @keywords datetime, date, calendar, time, timezone, intl
  */
 export declare class Datetime {
-    /** Constructs a Datetime instance. @keywords constructor, init */
+    /** Initializes a Datetime instance with date, format type, and locale. @keywords init, constructor */
     constructor(date?: NumberOrStringOrDate, type?: GeoDate, code?: string);
-    /** Gets the GeoIntl localization formatting instance. @keywords intl, localization */
+    /** Returns the GeoIntl internationalization helper instance. @keywords intl, localization, format */
     getIntl(): GeoIntl;
-    /** Gets the underlying native Date object. @keywords date, native */
+    /** Returns the underlying native Date instance. @keywords date, native */
     getDate(): Date;
-    /** Gets the configured output date type format. @keywords type, format */
+    /** Returns the date output format type. @keywords type, format */
     getType(): GeoDate;
-    /** Gets the hour display format type. @keywords hours, format */
+    /** Returns the hour display format type. @keywords hours, format */
     getHoursType(): GeoHours;
-    /** Checks whether 24-hour time format is enabled. @keywords hour24, format, time */
+    /** Checks whether the 24-hour time format is enabled. @keywords 24-hour, time format */
     getHour24(): boolean;
-    /** Returns time zone offset in minutes relative to UTC. @keywords timezone, offset, utc */
+    /** Returns the country and language locale code. @keywords locale, language, country, code */
+    getCode(): string;
+    /** Returns the time zone offset in minutes relative to UTC. @keywords timezone, offset, utc */
     getTimeZoneOffset(): number;
-    /** Gets the time zone representation string. @keywords timezone, tz */
+    /** Returns the formatted time zone string. @keywords timezone, tz */
     getTimeZone(style?: GeoTimeZoneStyle): string;
-    /** Gets the code for the first day of the week. @keywords firstDay, weekday */
+    /** Returns the first day of the week code for the current locale. @keywords first day, week, weekday */
     getFirstDayCode(): GeoFirstDay;
-    /** Gets the full year in local time. @keywords year, local */
+    /** Returns the full year according to local time. @keywords year, local time */
     getYear(): number;
-    /** Gets the 1-based month (1-12) in local time. @keywords month, local */
+    /** Returns the 1-based month (1-12) according to local time. @keywords month */
     getMonth(): number;
-    /** Gets the day of the month (1-31) in local time. @keywords day, date, local */
+    /** Returns the day of the month (1-31) according to local time. @keywords day, day of month */
     getDay(): number;
-    /** Gets the hour (0-23) in local time. @keywords hour, local */
+    /** Returns the day of the week (0-6) according to local time. @keywords weekday, day of week */
+    getWeekday(): number;
+    /** Returns the hour (0-23) according to local time. @keywords hour, time */
     getHour(): number;
-    /** Gets the minute (0-59) in local time. @keywords minute, local */
+    /** Returns the minutes (0-59) according to local time. @keywords minute, time */
     getMinute(): number;
-    /** Gets the second (0-59) in local time. @keywords second, local */
+    /** Returns the seconds (0-59) according to local time. @keywords second, time */
     getSecond(): number;
-    /** Gets the total number of days (28-31) in the current month. @keywords maxDay, daysInMonth */
+    /** Returns the total number of days in the current month (28-31). @keywords max day, days in month */
     getMaxDay(): number;
-    /** Replaces the current date value. @keywords setDate, update */
-    setDate(value: NumberOrStringOrDate): this;
-    /** Sets the output date type format. @keywords setType, format */
+    /** Sets the date value completely. @keywords set date */
+    setDate(value?: NumberOrStringOrDate): this;
+    /** Sets the date format output type. @keywords set type, format */
     setType(value: GeoDate): this;
-    /** Sets whether to use 24-hour time format. @keywords setHour24, format */
+    /** Configures whether to use the 24-hour time format. @keywords 24-hour, format */
     setHour24(value: boolean): this;
-    /** Sets the locale/country code. @keywords setCode, locale */
-    setCode(code: string): this;
-    /** Registers a change listener callback. @keywords watch, observer, listener */
-    setWatch(watch: (date: Date, type: GeoDate, hour24: boolean) => void): this;
-    /** Sets the full year in local time. @keywords setYear, year */
+    /** Updates the locale code and triggers watcher notification. @keywords set locale, code */
+    setCode(code?: string): this;
+    /** Registers a callback invoked whenever date values update. @keywords watch, listener, callback */
+    setWatch(watch?: (date: Date, type: GeoDate, hour24: boolean) => void): this;
+    /** Sets the full year in local time, clamping day to avoid month overflow. @keywords set year */
     setYear(value: number): this;
-    /** Sets the 1-based month (1-12) in local time. @keywords setMonth, month */
+    /** Sets the 1-based month (1-12) in local time, clamping day to avoid overflow. @keywords set month */
     setMonth(value: number): this;
-    /** Sets the day of the month (1-31) in local time. @keywords setDay, day */
+    /** Sets the day of the month in local time. @keywords set day */
     setDay(value: number): this;
-    /** Sets the hour (0-23) in local time. @keywords setHour, hour */
+    /** Sets the hour in local time. @keywords set hour */
     setHour(value: number): this;
-    /** Sets the minute (0-59) in local time. @keywords setMinute, minute */
+    /** Sets the minutes in local time. @keywords set minute */
     setMinute(value: number): this;
-    /** Sets the second (0-59) in local time. @keywords setSecond, second */
+    /** Sets the seconds in local time. @keywords set second */
     setSecond(value: number): this;
-    /** Formats date and time according to locale and format options. @keywords locale, format, string */
+    /** Formats date and time according to locale and format options. @keywords locale, format, intl */
     locale(type?: GeoDate, styleOptions?: Intl.DateTimeFormatOptions['month'] | Intl.DateTimeFormatOptions): string;
-    /** Formats the year according to locale. @keywords localeYear, year, format */
+    /** Formats the year according to locale options. @keywords format year, locale */
     localeYear(style?: Intl.DateTimeFormatOptions['year']): string;
-    /** Formats the month according to locale. @keywords localeMonth, month, format */
+    /** Formats the month according to locale options. @keywords format month, locale */
     localeMonth(style?: Intl.DateTimeFormatOptions['month']): string;
-    /** Formats the day according to locale. @keywords localeDay, day, format */
+    /** Formats the day according to locale options. @keywords format day, locale */
     localeDay(style?: Intl.DateTimeFormatOptions['day']): string;
-    /** Formats the hour according to locale. @keywords localeHour, hour, format */
+    /** Formats the hour according to locale options. @keywords format hour, locale */
     localeHour(style?: Intl.DateTimeFormatOptions['hour']): string;
-    /** Formats the minute according to locale. @keywords localeMinute, minute, format */
+    /** Formats the minute according to locale options. @keywords format minute, locale */
     localeMinute(style?: Intl.DateTimeFormatOptions['minute']): string;
-    /** Formats the second according to locale. @keywords localeSecond, second, format */
+    /** Formats the second according to locale options. @keywords format second, locale */
     localeSecond(style?: Intl.DateTimeFormatOptions['second']): string;
-    /** Formats date to a standard ISO-like string. @keywords standard, iso, format */
+    /** Outputs date in standard format with optional timezone offset. @keywords standard, iso, format */
     standard(timeZone?: boolean): string;
-    /** Shifts the date by a specified number of years. @keywords moveByYear, addYears */
+    /** Shifts the date by a given number of years. @keywords move year, shift, offset */
     moveByYear(value: number): this;
-    /** Shifts the date by a specified number of months. @keywords moveByMonth, addMonths */
+    /** Shifts the date by a given number of months. @keywords move month, shift, offset */
     moveByMonth(value: number): this;
-    /** Shifts the date by a specified number of days. @keywords moveByDay, addDays */
+    /** Shifts the date by a given number of days. @keywords move day, shift, offset */
     moveByDay(value: number): this;
-    /** Shifts the date by a specified number of hours. @keywords moveByHour, addHours */
+    /** Shifts the date by a given number of hours. @keywords move hour, shift, offset */
     moveByHour(value: number): this;
-    /** Shifts the date by a specified number of minutes. @keywords moveByMinute, addMinutes */
+    /** Shifts the date by a given number of minutes. @keywords move minute, shift, offset */
     moveByMinute(value: number): this;
-    /** Shifts the date by a specified number of seconds. @keywords moveBySecond, addSeconds */
+    /** Shifts the date by a given number of seconds. @keywords move second, shift, offset */
     moveBySecond(value: number): this;
-    /** Moves the date to January of the current year. @keywords moveMonthFirst, january */
+    /** Sets the month to January. @keywords january, first month */
     moveMonthFirst(): this;
-    /** Moves the date to December of the current year. @keywords moveMonthLast, december */
+    /** Sets the month to December. @keywords december, last month */
     moveMonthLast(): this;
-    /** Advances the date to the first day of the next month. @keywords moveMonthNext, nextMonth */
+    /** Moves date to the first day of the next month. @keywords next month */
     moveMonthNext(): this;
-    /** Rewinds the date to the first day of the previous month. @keywords moveMonthPrevious, prevMonth */
+    /** Moves date to the first day of the previous month. @keywords previous month */
     moveMonthPrevious(): this;
-    /** Moves the date to the first day of the current week. @keywords moveWeekdayFirst, weekStart */
+    /** Moves date to the first day of the current week. @keywords first day, week */
     moveWeekdayFirst(): this;
-    /** Moves the date to the last day of the current week. @keywords moveWeekdayLast, weekEnd */
+    /** Moves date to the last day of the current week. @keywords last day, week */
     moveWeekdayLast(): this;
-    /** Moves to the first weekday of the month's first week. @keywords moveWeekdayFirstByMonth */
+    /** Moves date to the first day of the first week of the month. @keywords first week, calendar grid */
     moveWeekdayFirstByMonth(): this;
-    /** Moves to the first weekday of the following month's first full week. @keywords moveWeekdayLastByMonth */
+    /** Moves date to the last day of the last week of the month. @keywords last week, calendar grid */
     moveWeekdayLastByMonth(): this;
-    /** Advances the date by one full week. @keywords moveWeekdayNext, nextWeek */
+    /** Shifts date to the next week. @keywords next week */
     moveWeekdayNext(): this;
-    /** Rewinds the date by one full week. @keywords moveWeekdayPrevious, prevWeek */
+    /** Shifts date to the previous week. @keywords previous week */
     moveWeekdayPrevious(): this;
-    /** Moves the date to the first day of the current month. @keywords moveDayFirst, startOfMonth */
+    /** Moves date to the first day of the month. @keywords start of month, day first */
     moveDayFirst(): this;
-    /** Moves the date to the last day of the current month. @keywords moveDayLast, endOfMonth */
+    /** Moves date to the last day of the month. @keywords end of month, day last */
     moveDayLast(): this;
-    /** Advances the date by one day. @keywords moveDayNext, tomorrow */
+    /** Shifts date forward by one day. @keywords next day, tomorrow */
     moveDayNext(): this;
-    /** Rewinds the date by one day. @keywords moveDayPrevious, yesterday */
+    /** Shifts date backward by one day. @keywords previous day, yesterday */
     moveDayPrevious(): this;
-    /** Clones and returns a native Date instance. @keywords clone, date */
+    /** Clones date as a native Date instance. @keywords clone date */
     clone(): Date;
-    /** Clones and returns a new Datetime instance. @keywords cloneClass, copy */
+    /** Clones the Datetime instance. @keywords clone datetime */
     cloneClass(): Datetime;
-    /** Clones instance and sets month to January. @keywords cloneMonthFirst, january */
+    /** Clones Datetime instance and sets month to January. @keywords clone, january */
     cloneMonthFirst(): Datetime;
-    /** Clones instance and sets month to December. @keywords cloneMonthLast, december */
+    /** Clones Datetime instance and sets month to December. @keywords clone, december */
     cloneMonthLast(): Datetime;
-    /** Clones instance shifted to the next month. @keywords cloneMonthNext, nextMonth */
+    /** Clones Datetime instance and shifts one month ahead. @keywords clone, next month */
     cloneMonthNext(): Datetime;
-    /** Clones instance shifted to the previous month. @keywords cloneMonthPrevious, prevMonth */
+    /** Clones Datetime instance and shifts one month back. @keywords clone, previous month */
     cloneMonthPrevious(): Datetime;
-    /** Clones instance set to the first day of the week. @keywords cloneWeekdayFirst, weekStart */
+    /** Clones Datetime instance set to the first day of the week. @keywords clone, start of week */
     cloneWeekdayFirst(): Datetime;
-    /** Clones instance set to the last day of the week. @keywords cloneWeekdayLast, weekEnd */
+    /** Clones Datetime instance set to the last day of the week. @keywords clone, end of week */
     cloneWeekdayLast(): Datetime;
-    /** Clones instance set to the first weekday of the month's first week. @keywords cloneWeekdayFirstByMonth */
+    /** Clones Datetime instance set to the first day of the first week of the month. @keywords clone, calendar start */
     cloneWeekdayFirstByMonth(): Datetime;
-    /** Clones instance set to the first weekday of the following month's first full week. @keywords cloneWeekdayLastByMonth */
+    /** Clones Datetime instance set to the last day of the last week of the month. @keywords clone, calendar end */
     cloneWeekdayLastByMonth(): Datetime;
-    /** Clones instance advanced by one week. @keywords cloneWeekdayNext, nextWeek */
+    /** Clones Datetime instance shifted one week ahead. @keywords clone, next week */
     cloneWeekdayNext(): Datetime;
-    /** Clones instance rewound by one week. @keywords cloneWeekdayPrevious, prevWeek */
+    /** Clones Datetime instance shifted one week back. @keywords clone, previous week */
     cloneWeekdayPrevious(): Datetime;
-    /** Clones instance set to the first day of the month. @keywords cloneDayFirst, startOfMonth */
+    /** Clones Datetime instance set to the first day of the month. @keywords clone, start of month */
     cloneDayFirst(): Datetime;
-    /** Clones instance set to the last day of the month. @keywords cloneDayLast, endOfMonth */
+    /** Clones Datetime instance set to the last day of the month. @keywords clone, end of month */
     cloneDayLast(): Datetime;
-    /** Clones instance advanced by one day. @keywords cloneDayNext, tomorrow */
+    /** Clones Datetime instance shifted one day ahead. @keywords clone, next day */
     cloneDayNext(): Datetime;
-    /** Clones instance rewound by one day. @keywords cloneDayPrevious, yesterday */
+    /** Clones Datetime instance shifted one day back. @keywords clone, previous day */
     cloneDayPrevious(): Datetime;
 }
 
-/** Error storage and centralized handling manager. @keywords error, center, manager, storage, handling */
+/** Manages error storage and dispatching. @keywords error management, handler, error center */
 export declare class ErrorCenter {
-    /** Retrieves an error cause by code and optional group. @keywords get, error cause, lookup, code, group */
-    static get(code: string, group?: string): ErrorCenterCauseItem | undefined;
-    /** Checks whether an error cause exists by code and optional group. @keywords has, exists, check, error cause */
-    static has(code: string, group?: string): boolean;
-    /** Returns the global singleton instance of ErrorCenterInstance. @keywords singleton, instance, error center */
+    /** Retrieves a specific error cause by code and group. @keywords get error, find cause */
+    static get(code: string, group?: ErrorCenterGroup): ErrorCenterCauseItem | undefined;
+    /** Returns the error handler instance. @keywords error handler, get handler */
+    static getHandler(): ErrorCenterHandler;
+    /** Checks if an error cause exists for a code and group. @keywords check error, has cause */
+    static has(code: string, group?: ErrorCenterGroup): boolean;
+    /** Returns the global singleton instance of ErrorCenterInstance. @keywords singleton, instance */
     static getItem(): ErrorCenterInstance;
-    /** Configures console logging behavior or custom filter for errors. @keywords console, logging, debug, filter */
+    /** Configures console logging flag or filter for errors. @keywords console log, filter, debug */
     static setIsConsole(isConsole: ErrorCenterHandlerIsConsole): void;
-    /** Registers a single error cause in storage. @keywords add, register, error cause */
+    /** Adds an error cause item to storage. @keywords add error, register cause */
     static add(cause: ErrorCenterCauseItem): void;
-    /** Registers a global callback executed on any triggered error. @keywords callback, listener, global, on error */
+    /** Registers a global callback executed on any error. @keywords global error callback, listener */
     static addCallback(callback: ErrorCenterHandlerCallback): void;
-    /** Registers an error handler callback for a specific group. @keywords handler, group, error listener */
+    /** Registers an error handler for a specific group. @keywords register handler, group error */
     static addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): void;
-    /** Registers multiple group-specific error handlers. @keywords handler list, batch register, error handlers */
+    /** Registers multiple error handlers simultaneously. @keywords batch handlers, handler list */
     static addHandlerList(handlers: ErrorCenterHandlerList): void;
-    /** Registers a list of error causes in storage. @keywords batch add, error cause list, register */
+    /** Adds a list of error causes to storage. @keywords batch causes, error list */
     static addList(causes: ErrorCenterCauseList): void;
-    /** Triggers error handling workflow for the specified error cause. @keywords trigger, dispatch, handle, error */
+    /** Removes an error cause from storage by code and group. @keywords remove error, delete cause */
+    static remove(code: string, group?: ErrorCenterGroup): void;
+    /** Removes a specific handler or all handlers for a group. @keywords remove handler, unregister */
+    static removeHandler(group?: ErrorCenterGroup, handler?: ErrorCenterHandlerCallback): void;
+    /** Removes a registered global callback. @keywords remove callback, unbind */
+    static removeCallback(callback: ErrorCenterHandlerCallback): void;
+    /** Resets all registered handlers and callbacks. @keywords reset, clear handlers */
+    static reset(): void;
+    /** Dispatches error handling for a given cause. @keywords trigger error, dispatch, notify */
     static on(cause: ErrorCenterCauseItem): void;
 }
 
@@ -387,56 +414,56 @@ export declare class Formatters<Options extends FormattersOptionsList = Formatte
     to(): FormattersReturn<List, Options>;
 }
 
-/** Static manager for geographical data, locale, country, and time zone. @keywords geo, locale, country, timezone */
+/** Static class providing centralized interface for managing locale, country, and time zone data. @keywords geo, locale, country, timezone */
 export declare class Geo {
-    /** Returns information about the current country and language. @keywords current, country, language, geo */
+    /** Returns current country and language data. @keywords current, geo, country, language */
     static get(): GeoItemFull;
-    /** Sets the current geographical location and updates instance state. @keywords set, location, locale */
-    static set(code: string, save?: boolean): void;
-    /** Resolves geo data by country or language code from the global database. @keywords lookup, code, country, language */
+    /** Sets current geographical location and updates instance state. @keywords set, location, locale */
+    static set(code?: string, save?: boolean): void;
+    /** Resolves geo data by country or language code from global database. @keywords lookup, code, country, language */
     static getByCode(code?: string): GeoItemFull;
-    /** Finds exact geo data matching a full locale string. @keywords match, locale, full */
-    static getByCodeFull(code: string): GeoItem | undefined;
-    /** Retrieves geo data for a specific country code. @keywords country, lookup */
-    static getByCountry(country: string): GeoItem | undefined;
-    /** Retrieves geo data for a specific language code. @keywords language, lookup */
-    static getByLanguage(language: string): GeoItem | undefined;
-    /** Returns the 2-letter code of the current country. @keywords country, code, iso */
+    /** Resolves exact geo data by matching full locale string (e.g., 'en-US'). @keywords lookup, exact, full, locale */
+    static getByCodeFull(code?: string): GeoItem | undefined;
+    /** Resolves geo data for specific country code. @keywords country, code, lookup */
+    static getByCountry(country?: string): GeoItem | undefined;
+    /** Resolves geo data for specific language code. @keywords language, code, lookup */
+    static getByLanguage(language?: string): GeoItem | undefined;
+    /** Returns 2-letter code of current country. @keywords country, code, current */
     static getCountry(): string;
-    /** Returns the first day of the week for the current locale. @keywords firstDay, week, calendar */
+    /** Returns code for first day of the week for current locale. @keywords firstDay, week, locale */
     static getFirstDay(): string;
-    /** Returns fully processed geo data updated with the current language. @keywords item, full, locale */
+    /** Returns fully processed geo data updated with current language. @note Deprecated: use get() @keywords item, current, language */
     static getItem(): GeoItemFull;
-    /** Returns the 2-letter code of the current language. @keywords language, code, iso */
+    /** Returns 2-letter code of current language. @keywords language, code, current */
     static getLanguage(): string;
-    /** Returns the list of all available countries and regions. @keywords list, countries, regions */
+    /** Returns complete list of available countries and regions. @keywords list, countries, regions */
     static getList(): GeoItem[];
-    /** Returns the current location string identifier. @keywords location, current */
+    /** Returns current location string. @keywords location, current */
     static getLocation(): string;
-    /** Returns the country code extracted from the location string. @keywords location, country, extract */
-    static getLocationCountry(): string;
-    /** Returns the language code extracted from the location string. @keywords location, language, extract */
+    /** Returns country code extracted from current location string. @keywords location, country, code */
     static getLocationLanguage(): string;
-    /** Returns a request-isolated instance of GeoInstance. @keywords instance, isolated, context */
+    /** Returns language code extracted from current location string. @keywords location, language, code */
+    static getLocationCountry(): string;
+    /** Returns request-isolated instance of GeoInstance. @keywords instance, isolated, request */
     static getObject(): GeoInstance;
-    /** Returns the combined standard locale string (e.g. 'en-US'). @keywords standard, locale, format */
+    /** Returns combined locale string in standard format (e.g., 'en-US'). @keywords standard, locale, format */
     static getStandard(): string;
-    /** Returns the timezone offset in minutes for the current context. @keywords timezone, offset, minutes */
+    /** Returns timezone offset in minutes for current context. @keywords timezone, offset, minutes */
     static getTimezone(): number;
-    /** Returns the formatted timezone string (e.g. '+00:00'). @keywords timezone, format, offset */
+    /** Returns formatted timezone string (e.g., '+00:00') for current context. @keywords timezone, format, offset */
     static getTimezoneFormat(): string;
-    /** Sets a custom timezone offset in minutes for the current context. @keywords timezone, set, offset */
+    /** Sets custom timezone offset in minutes for current context. @keywords timezone, set, offset */
     static setTimezone(timezone: number): void;
-    /** Sets the default country code or provider function. @keywords default, country, fallback */
-    static setValueDefault(code?: string | (() => string)): void;
-    /** Adds or updates country geo data and merges with existing records. @keywords add, country, update, merge */
-    static add(country: string, item: Partial<GeoItem>): GeoInstance;
-    /** Adds or updates multiple country entries in the geo registry. @keywords addList, bulk, countries */
-    static addList(list: Record<string, Partial<GeoItem>>): GeoInstance;
-    /** Resolves geo data for a given code (alias for getByCode). @keywords find, search, code */
-    static find(code: string): GeoItemFull;
-    /** Generates a standard formatted locale string from a geo item. @keywords standard, format, locale */
-    static toStandard(item: GeoItem): string;
+    /** Sets default value or resolver for country code. @keywords default, country, code */
+    static setValueDefault(code?: string | (() => string | undefined)): void;
+    /** Adds or updates country geo data and merges with existing records. @keywords add, country, update */
+    static add(country: string, item?: Partial<GeoItem>): GeoInstance;
+    /** Adds or updates multiple countries in geo list. @keywords add, batch, countries, list */
+    static addList(list?: Record<string, Partial<GeoItem>>): GeoInstance;
+    /** Resolves geo data for given code. Alias for getByCode. @note Deprecated: use getByCode() @keywords find, lookup, code */
+    static find(code?: string): GeoItemFull;
+    /** Formats geo item into standard concatenated locale string (e.g., 'en-US'). @keywords standard, locale, format */
+    static toStandard(item?: GeoItem, language?: string, raw?: boolean): string;
 }
 
 export declare const GEO_FLAG_ICON_NAME = "f";
@@ -531,6 +558,24 @@ export declare class GeoIntl {
     ]): T[];
 }
 
+/** Cookie key for storing the geo location code. @keywords cookie, geo, key */
+export declare const UI_GEO_COOKIE_KEY = "ui-geo-code";
+/** Manages and resolves the current location code, storage persistence, and DOM fallbacks. @keywords geo, location, locale, storage */
+export declare class GeoLocation {
+    /** Initializes location state from storage, cookies, DOM, or defaults. @keywords constructor, init, geo */
+    constructor(valueDefault?: string | (() => string | undefined) | undefined);
+    /** Gets the current location code string. @keywords get, location, code */
+    get(): string;
+    /** Updates the current location code with optional storage and cookie persistence. @keywords set, update, persist */
+    set(code?: string, save?: boolean): this;
+    /** Gets the country code extracted from the current location. @keywords country, code */
+    getCountry(): string;
+    /** Gets the language code extracted from the current location. @keywords language, locale */
+    getLanguage(): string;
+    /** Sets the default location code value or dynamic resolver. @keywords default, fallback */
+    setValueDefault(code?: string | (() => string | undefined)): this;
+}
+
 /** Manages phone number masks, country codes, and formatting. @keywords phone mask country code parser */
 export declare class GeoPhone {
     /** Retrieves phone code and country mask data by country or language code. @keywords phone mask country code lookup */
@@ -789,31 +834,30 @@ export declare class SearchList<T extends SearchItem, K extends SearchColumns<T>
     to(): SearchFormatList<T, K>;
 }
 
-type ServerStorageItem = {
+export type ServerStorageItem = {
     value: unknown;
     hydration: boolean;
 };
-type ServerStorageList = Record<string, ServerStorageItem>;
-/** Manages isolated data storage during server-side rendering (SSR). @keywords ssr server storage request isolation */
+export type ServerStorageList = Record<string, ServerStorageItem>;
+/** Manages request-isolated data storage and client hydration during SSR. @keywords ssr, storage, hydration, context */
 export declare class ServerStorage {
-    /** Retrieves a stored value or initializes it using the default value factory. @keywords get retrieve cache default */
-    static get<T = unknown>(key: string, defaultValue?: () => T, hydration?: boolean): T;
-    /** Stores a value produced by a factory function. @keywords set save store cache */
-    static set<T = unknown>(key: string, value: () => T, hydration?: boolean, storageList?: ServerStorageList): T;
-    /** Checks if a key exists in the storage. @keywords has exists contains key */
+    /** Checks whether a key exists in storage. @keywords has, exists, check */
     static has(key: string): boolean;
-    /** Configures whether error messages should be suppressed. @keywords error status visibility hide */
+    /** Retrieves a value from storage or initializes it with a fallback. @keywords get, read, default, hydration */
+    static get<T = unknown>(key: string, defaultValue?: (() => T) | T, hydration?: boolean): T;
+    /** Saves a value to storage with optional client hydration flag. @keywords set, store, write, hydration */
+    static set<T = unknown>(key: string, value: (() => T) | T, hydration?: boolean, storageList?: ServerStorageList): T;
+    /** Sets the visibility of error messages. @keywords error, status, logging */
     static setErrorStatus(hide: boolean): void;
-    /** Removes a specific item from storage by key. @keywords remove delete clear key */
+    /** Removes a key and its value from storage. @keywords remove, delete, purge */
     static remove(key: string): void;
-    /** Clears all stored values from the current storage context. @keywords reset clear purge */
+    /** Resets the storage state. @keywords reset, clear, flush */
     static reset(): void;
-    /** Initializes storage with a context resolver for request isolation. @keywords init initialize context ssr */
+    /** Initializes storage with a per-request context provider. @keywords init, setup, context, listener */
     static init(listener: () => Record<string, unknown> | undefined): typeof ServerStorage;
-    /** Serializes storage state into a script tag string for client hydration. @keywords toString hydration serialize script */
+    /** Serializes hydratable storage state into a script string. @keywords toString, serialize, hydration, script */
     static toString(): string;
 }
-export {};
 
 /** Manages storage callback lists and execution state. @keywords storage, callbacks, listeners */
 export declare class StorageCallback<T = unknown, Callback = (value: T) => void | Promise<void>> {
@@ -919,61 +963,109 @@ export declare class UrlItem {
     toJSON(): string;
 }
 
-/** Wraps matched search substrings with an HTML highlight tag. @keywords highlight match search replace tag html */
-export declare function addTagHighlightMatch(value: string, search?: string | RegExp, className?: string, shouldEscape?: boolean): string;
+export interface AddTagHighlightMatchOptions {
+    className?: string;
+    shouldEscape?: boolean;
+    shouldRemoveTag?: boolean;
+}
+/** Wraps matched substrings in an HTML tag for visual search highlighting. @keywords highlight, search, match, tag, mark, html */
+export declare function addTagHighlightMatch(value?: string | number | null, search?: string | RegExp, options?: AddTagHighlightMatchOptions): string;
 
-/** Converts any value to a string, joining flat arrays with commas if specified or serializing to JSON. @keywords convert, stringify, toString, serialize */
-export declare function anyToString<V>(value: V, isArrayString?: boolean, trim?: boolean): string;
+export interface AnyToStringOptions {
+  isArrayString?: boolean;
+  isBooleanString?: boolean;
+  trim?: boolean;
+}
 
-/** Replaces placeholder keys like [key] or {key} in text with corresponding values from an object or array. @keywords template, interpolate, format, placeholder, replace */
-export declare function applyTemplate(text: string, replacement?: Record<string, unknown> | readonly unknown[]): string;
+/**
+ * Safely converts any value to a string with configurable array, boolean, and trimming rules.
+ * @keywords any to string, convert, cast, serialize, stringify
+ * @example
+ * anyToString('  Hello  ') // => 'Hello'
+ * anyToString('  Hello  ', { trim: false }) // => '  Hello  '
+ * anyToString([1, 2, 3]) // => '1,2,3'
+ * anyToString([1, 2, 3], { isArrayString: false }) // => '[1,2,3]'
+ * anyToString({ a: 1 }) // => '{"a":1}'
+ * anyToString(true) // => '1'
+ * anyToString(false) // => '0'
+ * anyToString(true, { isBooleanString: true }) // => 'true'
+ * anyToString(false, { isBooleanString: true }) // => 'false'
+ * anyToString(null) // => ''
+ */
+export declare function anyToString<V = unknown>(value?: V, options?: AnyToStringOptions): string;
+
+/** Replaces template placeholders in text with values from an object or array. @keywords template, replace, interpolate, string format, placeholders */
+export declare function applyTemplate(text: unknown, replacement?: Record<string, unknown> | readonly unknown[]): string;
 
 /** Creates an array of specified length filled with the given value. @keywords array, fill, repeat, populate, initialize */
 export declare function arrFill<T>(value: T, count: number): T[];
 
-/** Converts a Blob to a Base64 string, optionally stripping the data URL prefix. Returns undefined if empty or unreadable. @keywords blob, base64, encode, file, data url */
-export declare function blobToBase64(blob: Blob, clean?: boolean): Promise<string | undefined>;
+/** Converts a Blob to a Base64 string, optionally removing the data URL prefix. @keywords blob, base64, convert, data url, file, encode */
+export declare function blobToBase64(blob?: Blob | null, clean?: boolean): Promise<string | undefined>;
 
-/** Capitalizes the first letter of a string. @keywords capitalize, uppercase, string, formatting */
-export declare function capitalize<T extends string = string>(value?: T, locale?: boolean | string): Capitalize<T>;
+/** Capitalizes the first letter of a string. @keywords capitalize, uppercase, first letter, string */
+export declare function capitalize<T = string>(value?: T, locale?: boolean | string): T extends string ? Capitalize<T> : string;
 
-/** Creates a deep copy of an object to prevent unwanted mutations. @keywords deep copy, clone, duplicate */
+/** Creates a deep copy of an object to prevent unintended mutations. @keywords deep copy clone duplicate object */
 export declare function copyObject<T>(value: T): T;
 
-/** Creates a simple copy of an object with optional additional properties. @keywords copy, clone, shallow copy, object clone */
-export declare function copyObjectLite<T, R = T>(value: T, source?: Record<PropertyKey, unknown> | null): R;
+/** Creates a shallow copy of an object with optional additional properties. @keywords copy, clone, shallow copy, object lite, merge */
+export declare function copyObjectLite<T = Record<PropertyKey, unknown>, R = T>(value?: T | null, source?: Record<PropertyKey, unknown> | null): R;
 
 /**
- * Creates an HTML element, configures its attributes or logic, and optionally mounts it to a parent DOM node.
- * @remarks Designed for standard HTML elements via `document.createElement` (use `document.createElementNS` for SVG/MathML). Returns `undefined` in SSR environments; execute within client-only lifecycle hooks to avoid hydration mismatches.
- * @keywords createElement, create dom element, html, dom manipulation, mount
+ * Creates an HTML element, configures attributes or runs a modifier callback, and optionally appends it to a parent node.
+ * @remarks Returns `undefined` during SSR. Uses `document.createElement`; use `document.createElementNS` for SVG/MathML. Sanitize input when providing `innerHTML` through options.
+ * @keywords createElement, dom, html, create element, insert node
  */
-export declare function createElement<T extends HTMLElement>(parentElement?: Element | DocumentFragment, tagName?: string, options?: Partial<T> | Record<string, unknown> | ((element: T) => void), referenceElement?: Node | null): T | undefined;
+export declare function createElement<T extends HTMLElement = HTMLDivElement>(parentElement?: Element | DocumentFragment | null, tagName?: string, options?: Partial<T> | Record<string, unknown> | ((element: T) => void) | null, referenceElement?: Node | null): T | undefined;
 
-/** Executes a callback when DOMContentLoaded fires, or immediately if already ready. @remarks In non-DOM/SSR environments, execution can be disabled with `isServer: false`. @keywords domContentLoaded, dom ready, readyState, ssr */
-export declare function domContentLoaded<T = void>(callback?: () => T | Promise<T>, isServer?: boolean): Promise<T>;
+/**
+ * Executes a callback when DOMContentLoaded fires, or immediately if the DOM is already loaded.
+ * @remarks In non-DOM environments (SSR), execution can be disabled by passing `isServer: false`.
+ * @keywords dom, ready, domContentLoaded, ssr, readyState, event
+ */
+export declare function domContentLoaded<T = void>(callback?: (() => T | Promise<T>) | null, isServer?: boolean): Promise<T>;
 
-/** Selects the first element matching specified CSS selectors. @keywords dom, querySelector, element, find, select */
+/**
+ * Returns an array of all elements at the specified coordinates.
+ * @remarks In non-DOM (SSR) environments or when `document.elementsFromPoint` is unsupported, the function returns an empty array `[]`. Coordinates are evaluated relative to the viewport.
+ * @keywords dom, elementsFromPoint, hit test, coordinates, viewport elements
+ */
+export declare function domElementsFromPoint(coordinator?: ImageCoordinator | null): Element[];
+
+/** Selects the first element matching the specified selectors. @keywords dom, querySelector, find element */
 export declare function domQuerySelector<E extends Element = Element>(selectors: string): E | undefined;
 
-/** Selects all elements matching the specified selectors. @keywords dom, querySelectorAll, query, selector, elements */
+/** Selects all DOM elements matching the specified selectors. @keywords dom, querySelectorAll, selector, query, elements */
 export declare function domQuerySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E> | undefined;
 
-/** Encodes special characters in a string for safe use in HTML attributes. @keywords html attribute encode escape sanitize */
-export declare function encodeAttribute(text: string): string;
+/**
+ * Encodes special characters for safe use in HTML attributes.
+ * @keywords html, attribute, encode, escape, sanitize
+ * @example
+ * 
+ * encodeAttribute('<div class="box">') // => '&lt;div class=&quot;box&quot;&gt;'
+ * encodeAttribute(undefined) // => ''
+ * 
+ */
+export declare function encodeAttribute(text?: string | number | null): string;
 
 /**
- * Encodes basic HTML characters (<, >, &) while preserving quotes.
- * @remarks Does NOT encode quotes; use `encodeAttribute` for untrusted attribute values.
- * @keywords html, encode, escape, lite attribute, sanitize
+ * Encodes basic HTML special characters (<, >, &) while preserving quotes.
+ * @keywords html encode, escape html, lite attribute, html entities, title encode
+ * @example
+ * encodeLiteAttribute('Tom & Jerry') // => 'Tom &amp; Jerry'
+ * encodeLiteAttribute('<title> "Hello" </title>') // => '&lt;title&gt; "Hello" &lt;/title&gt;'
+ * encodeLiteAttribute(undefined) // => ''
+ * @remarks Does NOT encode quotes (" and '). For untrusted input inside HTML attributes, use `encodeAttribute`.
  */
-export declare function encodeLiteAttribute(text: string): string;
+export declare function encodeLiteAttribute(text?: string | number | null): string;
 
 /** Resizes an image if it exceeds the maximum size, returning base64 encoded data. @keywords resize, compress, image, max size, base64 */
 export declare function ensureMaxSize(file: Uint8Array, compress?: number, type?: string): Promise<string>;
 
-/** Escapes special regex characters in a string for safe use in RegExp. @keywords regex, regexp, escape, sanitize */
-export declare function escapeExp(value: string): string;
+/** Escapes special regex characters in a string or number for safe RegExp usage. @keywords escape, regex, regexp, sanitize, pattern */
+export declare function escapeExp(value?: string | number | null): string;
 
 /** Stops event propagation in the DOM tree. @keywords event, stopPropagation, prevent bubbling */
 export declare function eventStopPropagation(event: Event): void;
@@ -984,20 +1076,15 @@ export declare function executeFunction<T, Args extends unknown[] = unknown[]>(c
 /** Safely executes a function, promise, or static value and awaits its resolution. @keywords execute promise, async executor, run promise, safe call */
 export declare function executePromise<T, Args extends unknown[] = unknown[]>(callback: ((...args: Args) => PromiseLike<T> | T) | PromiseLike<T> | T, ...args: Args): Promise<Awaited<T>>;
 
-/** Supported collection types for iteration. @keywords collection iterable */
-export type ForEachData<T> = readonly T[] | Record<string, T> | Map<unknown, T> | Set<T>;
-/** Resolves key type based on collection structure. @keywords key type inference */
+export type ForEachData<T = any> = readonly T[] | Record<PropertyKey, T> | Map<unknown, T> | Set<T> | object;
+export type ForEachItem<D> = D extends readonly (infer T)[] ? T : D extends Set<infer S> ? S : D extends Map<unknown, infer V> ? V : D extends object ? D[keyof D] : unknown;
 export type ForEachKey<D> = D extends readonly unknown[] ? number : D extends Set<infer S> ? S : D extends Map<infer K, unknown> ? K : string;
-/** Iterates over an array and returns mapped callback results. @keywords forEach array iterate map */
-export declare function forEach<T, R>(data: readonly T[], callback: (item: T, index: number, collection: readonly T[]) => R, saveUndefined?: boolean): R[];
-/** Iterates over a Set and returns mapped callback results. @keywords forEach set iterate map */
-export declare function forEach<T, R>(data: Set<T>, callback: (item: T, key: T, collection: Set<T>) => R, saveUndefined?: boolean): R[];
-/** Iterates over a Map and returns mapped callback results. @keywords forEach map iterate */
-export declare function forEach<K, V, R>(data: Map<K, V>, callback: (item: V, key: K, collection: Map<K, V>) => R, saveUndefined?: boolean): R[];
-/** Iterates over an object record and returns mapped callback results. @keywords forEach record object iterate */
-export declare function forEach<T, R, D extends Record<string, unknown> = Record<string, T>>(data: D & Record<string, T>, callback: (item: T, key: string, collection: D) => R, saveUndefined?: boolean): R[];
-/** Iterates over a collection and returns mapped callback results. @keywords forEach collection iterate */
-export declare function forEach<T, R, D extends ForEachData<T> = ForEachData<T>, K = ForEachKey<D>>(data: D & ForEachData<T>, callback: (item: T, key: K, collection: D) => R, saveUndefined?: boolean): R[];
+export type ForEachReturn<R, S extends boolean = false> = (S extends true ? R : Exclude<R, undefined>)[];
+/** Iterates over collection items (Array, Object, Map, Set) executing a callback and returning mapped results, omitting undefined unless specified. @keywords foreach, iterate, map, collection, array, object, set */
+export declare function forEach<T = any, R = any, D extends ForEachData<T> = ForEachData<T>, K = ForEachKey<D>, S extends boolean = false>(data: D, callback: (item: D extends object ? ForEachItem<D> : T, key: K, collection: D) => R, saveUndefined?: S): ForEachReturn<R, S>;
+
+/** Iterates over own enumerable object properties safely skipping prototype pollution keys, supporting early exit when false is returned. @keywords forOwn, iterate, loop, object, enumerable, prototype pollution */
+export declare function forOwn<T extends object = Record<string, unknown>, K extends Extract<keyof T, string> = Extract<keyof T, string>>(data?: T, callback?: (value: T[K], key: K, collection: T) => void | boolean): void;
 
 /** Cyclically calls requestAnimationFrame while the next predicate returns true. @keywords requestAnimationFrame animation loop frame ticker */
 export declare function frame(callback: (timestamp: DOMHighResTimeStamp) => void, next?: (timestamp: DOMHighResTimeStamp) => boolean, end?: () => void): void;
@@ -1028,8 +1115,8 @@ export declare function getCurrentDate(format?: GeoDate): string;
  */
 export declare function getCurrentTime(): number;
 
-/** Returns the first Element matching the specified selector or the element itself. @keywords getElement, querySelector, dom, selector */
-export declare function getElement<E extends ElementOrWindow, R extends Exclude<E, Window>>(element?: ElementOrString<E>): R | undefined;
+/** Resolves a selector string, Element, or Window to a DOM element (or document.body for Window). @keywords element, querySelector, getElement, resolve, dom, window, ssr */
+export declare function getElement<E extends ElementOrWindow = HTMLElement, R extends ElementResolved<E> = ElementResolved<E>>(element?: ElementOrString<E> | null): R | undefined;
 
 /** Returns or generates a unique element ID, targeting document.body if Window is provided. @keywords element id, get id, generate id, dom id */
 export declare function getElementId<E extends ElementOrWindow>(element?: ElementOrString<E>, selector?: string): string;
@@ -1050,17 +1137,24 @@ export declare function initGetElementId(newListener: () => string | number): vo
 export declare function resetGetElementId(): void;
 
 export type GetElementImageCallback = (image: HTMLImageElement, event?: Event | string) => void;
-/** Resolves or creates an HTMLImageElement from an image element or URL source with optional load/error callbacks. @keywords image, load image, image element, getElementImage */
-export declare function getElementImage(image?: HTMLImageElement | string, onload?: GetElementImageCallback, onerror?: GetElementImageCallback): HTMLImageElement | undefined;
+/**
+ * Resolves or creates an HTMLImageElement from an existing element or URL string.
+ * @remarks
+ * If `image` is a string, a new `HTMLImageElement` is created with load and error callbacks attached before assigning `src`.
+ * If already an `HTMLImageElement`, it is returned directly. Returns `undefined` for null, undefined, or in SSR environments.
+ * Created elements are not attached to the DOM tree.
+ * @keywords image, HTMLImageElement, load image, image loader, create element, DOM
+ */
+export declare function getElementImage(image?: HTMLImageElement | string | null, onload?: GetElementImageCallback, onerror?: GetElementImageCallback): HTMLImageElement | undefined;
 
-/** Retrieves an element or window property value by key, with an optional default fallback. @keywords element property getter window dom */
-export declare function getElementItem<T extends ElementOrWindow, K extends keyof T, D>(element: ElementOrString<T>, property: K | string, defaultValue?: D): T[K] | D | undefined;
+/** Retrieves an element property by key, resolving to document.body for Window instances, or returning a default value. @keywords element property get value dom window document */
+export declare function getElementItem<E extends ElementOrWindow = HTMLElement, K extends keyof ElementResolved<E> = keyof ElementResolved<E>, D = undefined>(element?: ElementOrString<E> | null, property?: K | string | number, defaultValue?: D): ElementResolved<E>[K] | D;
 
-/** Resolves and returns a window or DOM element by selector or reference. @keywords window, element, dom, selector */
-export declare function getElementOrWindow<E extends ElementOrWindow>(element?: ElementOrString<E>): E | undefined;
+/** Resolves the specified selector or element, returning the Element or preserving the Window object directly. @keywords dom, window, element, selector, querySelector, getElementOrWindow */
+export declare function getElementOrWindow<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null): E | undefined;
 
-/** Generates a safe script tag for data hydration. @keywords safe script, script tag, hydration, serialization */
-export declare function getElementSafeScript<T = unknown>(id: string, data: T): string;
+/** Generates a safe HTML script tag containing serialized data for client hydration. @keywords safe script, hydration, state transfer, serialization, html */
+export declare function getElementSafeScript<T = unknown>(id: string | number, data?: T): string;
 
 /** Creates a case-insensitive regular expression for an exact match of a phrase without anchors. @keywords regex, regular expression, exact match, search pattern */
 export declare function getExactSearchExp(search: string): RegExp;
@@ -1068,14 +1162,14 @@ export declare function getExactSearchExp(search: string): RegExp;
 /** Creates a RegExp object with the escaped value substituted into the pattern. @keywords regex, regexp, pattern, match, escape */
 export declare function getExp(value: string, flags?: string, pattern?: string): RegExp;
 
-/** Returns the first element of an array or object. @keywords first, head, element, array, object, get */
-export declare function getFirst<T>(value: T | T[] | Record<string, T>): T | undefined;
+/** Returns the first element of an array or object. @keywords first, head, element, array, object */
+export declare function getFirst<T = undefined>(value?: T | readonly T[] | Record<PropertyKey, T>): T;
 
-/** Retrieves and parses JSON hydration data from a DOM script element. @keywords hydration, json, script tag, dom, parse, ssr */
-export declare function getHydrationData<T>(id: string, defaultValue: T, remove?: boolean): T;
+/** Retrieves and parses JSON hydration data from a script element in the DOM. @keywords hydration, script tag, json parse, dom state */
+export declare function getHydrationData<T>(id: string | number, defaultValue: T, remove?: boolean): T;
 
-/** Returns the source URL string from an HTMLImageElement or string. @keywords image, src, url, source, element */
-export declare function getImageSrc(image?: HTMLImageElement | string): string;
+/** Extracts the image source string from an HTMLImageElement, object with a src property, or string URL. @keywords image, src, url, source, extract */
+export declare function getImageSrc(image?: HTMLImageElement | Record<string, unknown> | string | null): string;
 
 /** Retrieves a nested value from an object by its path. @keywords get by path, object path, nested property, deep get */
 export declare function getItemByPath<T extends Record<string, unknown>, R = string>(item: T, path: string): R | undefined;
@@ -1083,8 +1177,8 @@ export declare function getItemByPath<T extends Record<string, unknown>, R = str
 /** Returns the pressed key from a keyboard event. @keywords keyboard, key, event, pressed key */
 export declare function getKey(event: KeyboardEvent): string | number | undefined;
 
-/** Returns the last element of an array or object. @keywords last, element, array, object, tail */
-export declare function getLast<T>(value: T | readonly T[] | Record<string, T>): T | undefined;
+/** Returns the last element of an array or object. @keywords last, element, tail, array, object */
+export declare function getLast<T = undefined>(value?: T | readonly T[] | Record<PropertyKey, T>): T;
 
 /** Returns the length or size of arrays, objects, maps, sets, or strings, or 0 if unsupported or empty. @keywords length, size, count, collection, array, object, map, set, string */
 export declare function getLength(value: unknown): number;
@@ -1115,6 +1209,9 @@ export declare function getObjectNoUndefined<V>(data: readonly V[], exception?:
 /** Removes properties matching the exception value from an object. @keywords filter, omit, clean, undefined, compact */
 export declare function getObjectNoUndefined<T extends Record<PropertyKey, unknown>>(data: T, exception?: unknown): T;
 
+/** Creates a prototype-less object (`Object.create(null)`), optionally copying properties from the provided data. @keywords object create null prototype dictionary clean */
+export declare function getObjectNull<T = unknown>(data?: Record<string, T>): Record<string, T>;
+
 /** Returns the object if its values are set, or an empty object. @keywords object fallback empty validate */
 export declare function getObjectOrNone<T>(value: T): T & Record<string, unknown>;
 
@@ -1130,11 +1227,11 @@ export declare function getRandomText(min: number, max: number, symbol?: string,
 /** Serializes an object or array into a key-value request string. @keywords request string, query string, serialize, key value, params */
 export declare function getRequestString(request: Record<string, unknown> | readonly unknown[], sign?: string, separator?: string, subKey?: string): string;
 
-/** Builds a case-insensitive RegExp matching strings containing all search words in any order. @keywords regex search multi-word lookahead filter query */
-export declare function getSearchExp(search: string, limit?: number): RegExp;
+/** Builds a case-insensitive RegExp matching strings containing all specified words in any order. @keywords regex search query multi-word lookahead */
+export declare function getSearchExp(search?: unknown, limit?: number): RegExp;
 
-/** Creates a case-insensitive, global RegExp for word-separated search queries or clones an existing RegExp. @keywords regexp, search, word separator, pattern */
-export declare function getSeparatingSearchExp(search: string | RegExp, limit?: number): RegExp;
+/** Creates a case-insensitive, global word-separating search RegExp or clones an existing RegExp. @keywords search regexp regex query filter words */
+export declare function getSeparatingSearchExp(search?: unknown, limit?: number): RegExp;
 
 /** Calculates the step value as a percentage within a min-max range. @keywords step, percent, range, slider, scale */
 export declare function getStepPercent(min: number | undefined, max: number): number;
@@ -1154,8 +1251,11 @@ export declare function goScrollTo(container?: HTMLElement | Element | null, ele
 /** Invokes the native sharing mechanism via the Web Share API. @keywords share, web share api, navigator share, device share */
 export declare function handleShare(data: ShareData): Promise<boolean>;
 
-/** Checks if an object has the specified own property. @keywords hasKey, hasOwnProperty, property check, type guard */
-export declare function hasKey<K extends PropertyKey, T extends object = Record<K, unknown>>(object: unknown, key: K): object is T & Record<K, unknown>;
+/** Checks if an object has the specified own property. @keywords hasKey, hasOwnProperty, object, key, property check */
+export declare function hasKey<K extends PropertyKey = PropertyKey, T extends object = Record<K, unknown>>(object: unknown, key: K): object is T & Record<K, unknown>;
+
+/** Checks whether an object has at least one own property. @keywords hasKeys, object, keys, own properties, not empty */
+export declare function hasKeys<T extends object = Record<PropertyKey, unknown>>(object: unknown): object is T;
 
 /** Checks if a value exists within the specified array. @keywords inArray, array, includes, contains, search */
 export declare function inArray<T>(array: T[], value: T): boolean;
@@ -1169,7 +1269,7 @@ export declare function intersectKey<T extends Record<PropertyKey, unknown>, C e
 /** Checks if the API response indicates success. @keywords api, response, success, status, check */
 export declare function isApiSuccess<T>(data?: ApiData<T>): boolean;
 
-/** Checks if a value is an array. @keywords isArray, array check, type guard */
+/** Checks if a value is an array. @keywords isArray, array, type guard */
 export declare function isArray<T = unknown>(value: unknown): value is T[];
 
 /** Checks if the values of two objects are different. @keywords compare, diff, equality, object difference */
@@ -1181,19 +1281,19 @@ export declare function isDomData(): boolean;
 /** Checks whether code is running in a browser environment with `window` available. @keywords dom, browser, runtime, window, client */
 export declare function isDomRuntime(): boolean;
 
-/** Checks if an element is visible (not hidden by CSS and exists in the DOM). @keywords element, visibility, is visible, check visible, dom */
-export declare function isElementVisible<E extends ElementOrWindow>(elementSelectors?: ElementOrString<E>): boolean;
+/** Checks if an element is visible in the DOM and not hidden by CSS. @keywords visibility, dom, is visible, element, hidden */
+export declare function isElementVisible<E extends ElementOrWindow = HTMLElement>(elementSelectors?: ElementOrString<E> | null): boolean;
 
 /** Checks if the pressed key is Enter or Space (WAI-ARIA action key) outside of text inputs. @keywords enter space wai-aria keyboard event */
 export declare function isEnter(event: KeyboardEvent, isInputElement?: boolean): boolean;
 
-/** Checks if a value is filled (not empty), optionally treating '0' as filled. @keywords isFilled, filled, validation, empty check */
-export declare function isFilled<T>(value: T, zeroTrue?: boolean): value is Exclude<T, EmptyValue>;
+/** Checks if a value is filled (not empty), optionally considering '0' as filled. @keywords isFilled, empty check, filled, validation */
+export declare function isFilled<T>(value?: T, zeroTrue?: boolean): value is Exclude<T, EmptyValue>;
 
 /** Checks if the value is an integer or floating-point number. @keywords isFloat, float, number, numeric, check */
 export declare function isFloat(value: unknown): boolean;
 
-/** Checks if a value is a function. @keywords isFunction, function, callback, type guard */
+/** Checks whether a value is a function. @keywords isFunction, function check, type guard, predicate */
 export declare function isFunction<T>(callback: T): callback is Extract<T, FunctionAnyType>;
 
 /** Checks if an element or selector is attached to the DOM tree. @keywords dom, attached, is connected, element in dom, is in document */
@@ -1208,16 +1308,16 @@ export declare function isIntegerBetween(value: number, between: number): boolea
 /** Checks if a keyboard event contains active modifier or meta keys. @keywords meta key, modifier, keyboard event, ctrl, alt, shift, cmd */
 export declare function isMetaKey(event: KeyboardEvent): boolean;
 
-/** Checks if a value is null or undefined. @keywords isNull, isNil, null, undefined, check */
+/** Checks if a value is null or undefined. @keywords isNull, isNil, null, undefined, check, guard */
 export declare function isNull<T>(value: T): value is Extract<T, Undefined>;
 
-/** Checks if the value is a number or numeric string. @keywords isNumber, number, numeric, type guard, validate */
-export declare function isNumber(value: unknown): value is number | string;
+/** Checks if the value is a number, numeric string, or bigint. @keywords isNumber, is numeric, check number, bigint, numeric string */
+export declare function isNumber(value?: unknown): value is number | string | bigint;
 
-/** Checks if a value is an object. @keywords isObject, object, type guard, predicate */
-export declare function isObject<T>(value: T): value is Extract<T, ObjectItem>;
+/** Checks if a value is an object. @keywords isObject, object, type guard */
+export declare function isObject<T = unknown>(value: unknown): value is ObjectItem<T>;
 
-/** Checks if a value is an object and not an array. @keywords isObjectNotArray, is object, not array, type guard */
+/** Checks if the value is an object and not an array. @keywords isObjectNotArray, object, not array, record, type guard */
 export declare function isObjectNotArray<T>(value: T): value is Exclude<Extract<T, ObjectItem>, unknown[] | undefined | null>;
 
 /** Check if the device is currently online. @keywords online, network, connectivity, internet */
@@ -1226,8 +1326,11 @@ export declare function isOnLine(): boolean;
 /** Checks if a property key is a prototype pollution key (__proto__, constructor, prototype). @keywords prototype pollution, security, safe key, sanitize, proto, constructor */
 export declare function isPrototypeKey(key: unknown): boolean;
 
-/** Checks if a value is selected against a target or an array of items, supporting numeric equivalence. @keywords isSelected check selected selection match compare */
-export declare function isSelected<T>(value: T, selected?: unknown): boolean;
+/** Checks if a value is a regular expression (including cross-realm instances). @keywords regex, regexp, regular expression, type guard */
+export declare function isRegExp(value: unknown): value is RegExp;
+
+/** Checks if a value matches a target or array of selected values with numeric equivalence support. @keywords isSelected, selection, match, compare */
+export declare function isSelected<T = unknown>(value?: T, selected?: unknown): boolean;
 
 /** Checks if all specified values are selected. @keywords select, isSelected, selection, list, comparison */
 export declare function isSelectedByList<T>(values: T | T[], selected: T | T[]): boolean;
@@ -1235,8 +1338,8 @@ export declare function isSelectedByList<T>(values: T | T[], selected: T | T[]):
 /** Checks if the Web Share API is supported in the current environment. @keywords web share, navigator.share, share api, support check */
 export declare function isShare(): boolean;
 
-/** Checks if a value is of type string. @keywords isString, type guard, check string */
-export declare function isString(value: unknown): value is string;
+/** Checks if the value is of type string. @keywords is string, type guard, validation */
+export declare function isString(value?: unknown): value is string;
 
 /** Checks if the pressed key is Tab. @keywords tab key keyboard event check */
 export declare function isTab(event: KeyboardEvent): boolean;
@@ -1244,17 +1347,48 @@ export declare function isTab(event: KeyboardEvent): boolean;
 /** Checks if an object is a Window instance. @keywords window, isWindow, type guard, DOM */
 export declare function isWindow<E>(element: E): element is Extract<E, Window>;
 
-/** Generates a random integer within a specified range. @keywords random integer number math range */
+/** Generates a random integer within the specified range (inclusive). @keywords random, integer, range, math, number */
 export declare function random(min: number, max: number): number;
 
 /** Removes the common prefix from a string, optionally trimming the result. @keywords string prefix remove strip trim */
 export declare function removeCommonPrefix(mainString: string, prefix: string, trim?: boolean): string;
 
+export interface RemoveTagOptions {
+    tag?: string | string[];
+    replacement?: string;
+    removeContent?: boolean | string | string[];
+}
+/**
+ * Removes all HTML/XML tags or specified tags from a string.
+ * @keywords html, xml, strip tags, sanitize, remove tag, strip html
+ * @remarks
+ * When `removeContent` is true (or a list of tags is provided),
+ * executable and styling tags (`<script>`, `<style>`, `<noscript>`) or specified content tags
+ * are silently removed along with their inner content without applying `replacement`.
+ * Other formatting and layout tags preserve their text content, and their tag syntax
+ * is replaced with `replacement`.
+ * @example
+ * 
+ * removeTag('<p>Hello <b>world</b>!</p>') // => 'Hello world!'
+ * removeTag('<b>Hello</b> <p>world</p>', { tag: 'b' }) // => 'Hello <p>world</p>'
+ * removeTag('<b>Hello</b> <p>world</p>', { tag: ['b', 'p'] }) // => 'Hello world'
+ * removeTag('<p>Hello</p><p>world</p>', { replacement: ' ' }) // => ' Hello  world '
+ * removeTag('<p>Hello</p><script>alert(1)</script>') // => 'Hello'
+ * removeTag('<p>Hello</p><script>alert(1)</script>', { removeContent: false }) // => 'Helloalert(1)'
+ * removeTag('<div>Text</div><script>alert(1)</script>', { tag: 'script', removeContent: false }) // => '<div>Text</div>alert(1)'
+ * 
+ */
+export declare function removeTag(value?: string | number | null, options?: RemoveTagOptions): string;
+
 /** Replaces occurrences of a component name within the provided text. @keywords replace component name, text replacement, rename component */
 export declare function replaceComponentName(text: string | undefined, name: string, componentName: string): string | undefined;
 
-/** Recursively merges or replaces properties of objects or arrays. @keywords deep merge, recursive replace, object assign, array merge */
-export declare function replaceRecursive<I>(target: ObjectItem<I>, replacement?: ObjectOrArray<I>, isMerge?: boolean): ObjectItem<I>;
+/**
+ * Recursively merges a target object with elements from a replacement object or array without mutating source data.
+ * @warning Intended exclusively for plain JSON-like objects and arrays; built-in class instances (`Date`, `RegExp`, `Map`, `Set`) and functions are not supported.
+ * @keywords deep merge, recursive replace, object merge, immutable merge
+ */
+export declare function replaceRecursive<I = unknown>(target?: ObjectItem<I> | null, replacement?: ObjectOrArray<I> | readonly I[] | null, isMerge?: boolean, disableCopy?: boolean): ObjectItem<I>;
 
 /** Replaces `[key]` placeholders in a template string with matching values or function results. @keywords template, replace, placeholder, substitute, string interpolation */
 export declare function replaceTemplate(value: string, replaces: Record<string, FunctionOr<string | number | boolean>>): string;
@@ -1265,17 +1399,29 @@ export declare function resizeImage(image: HTMLImageElement | string, maxSize?:
 export type ResizeImageByMaxType = 'auto' | 'width' | 'height';
 
 /**
- * Resizes an image synchronously to fit within a maximum size constraint.
- * @remarks Requires a loaded image with valid dimensions. Returns `undefined` if already within bounds or unprocessable to prevent redundant canvas re-encoding.
- * @keywords resize image, scale image, max dimension, canvas resize, base64
+ * Resizes an image to fit within a maximum size constraint using HTML Canvas.
+ * @remarks Synchronous; requires a fully loaded image with valid natural dimensions. Returns a Base64 Data URL only when scaled; returns `undefined` if already within `maxSize` or unprocessable to prevent redundant Canvas re-encoding. For a fallback to the original source, use `resizeImage`.
+ * @keywords image resize, scale image, max dimension, canvas resize, thumbnail, base64 data url
  */
 export declare function resizeImageByMax(image: HTMLImageElement | string, maxSize: number, type?: ResizeImageByMaxType, typeData?: string, quality?: number): string | undefined;
 
+/** Validates and normalizes an external locale code string for URL safety and ECMA-402 BCP-47 compatibility. @keywords locale, sanitize, normalize, bcp47, ecma402 */
+export declare function sanitizeLocation(code?: unknown): string | undefined;
+
 /** Converts seconds into a formatted time string (MM:SS or HH:MM:SS). @keywords time format, seconds to time, duration, timestamp */
 export declare function secondToTime(second: number | string | undefined, hasHour?: boolean): string;
 
-/** Modifies the property, attribute, or style value of an element by key. @keywords element, set property, attribute, style, dom */
-export declare function setElementItem<E extends ElementOrWindow, K extends keyof E = keyof E, V extends E[K] = E[K]>(element: ElementOrString<E>, index: K | string, value: V | Record<string, V> | unknown): E | undefined;
+/** Modifies the value of an element property, attribute, or style by key. @keywords element attribute property style set modify */
+export declare function setElementItem<E extends ElementOrWindow = HTMLElement, K extends keyof E = keyof E, V extends E[K] = E[K]>(element?: ElementOrString<E> | null, index?: K | string, value?: V | Record<string, V> | unknown): boolean;
+
+/** Sets or removes an HTML or ARIA attribute on a DOM element. @keywords set attribute, remove attribute, html attribute, aria attribute, dom */
+export declare function setElementItemAttribute<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null, attribute?: string, value?: unknown): boolean;
+
+/** Sets or merges nested properties on an element with prototype pollution protection. @keywords set element property, merge properties, prototype pollution */
+export declare function setElementItemProperty<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null, index?: PropertyKey, value?: unknown): boolean;
+
+/** Sets style properties, CSS custom properties, or cssText on a DOM element or window. @keywords style, css properties, custom properties, cssText, set element style */
+export declare function setElementItemStyle<E extends ElementOrWindow = HTMLElement>(element?: ElementOrString<E> | null, styles?: unknown): boolean;
 
 export interface SetValuesOptions {
     multiple?: boolean;
@@ -1295,8 +1441,12 @@ export declare function sleep(ms: number): Promise<void>;
 /** Sorts an array of items by column paths, directions, or a custom comparison function. @keywords sort, order, multi-column, comparator, array */
 export declare function sortList<T = Record<string, unknown>>(list: T[], sortColumns: SortColumnItem[], customSort?: SortFunction<T>): T[];
 
-/** Copies enumerable own properties from a source to a target object starting at a specific index. @keywords splice, copy, merge, assign */
-export declare function splice<I>(array: ObjectItem<I>, replacement?: ObjectItem<I> | I, indexStart?: string): ObjectItem<I>;
+/**
+ * Recursively merges properties from a replacement object into a target object, optionally replacing a matched entry in place.
+ * @warning Supports plain JSON-like objects only; built-in instances (`Date`, `RegExp`, `Map`, `Set`) and functions are not supported.
+ * @keywords splice, merge, object, replace, recursive
+ */
+export declare function splice<I = unknown>(array?: ObjectItem<I> | null, replacement?: ObjectItem<I> | I | null, indexStart?: string | null): ObjectItem<I>;
 
 /** Creates a string of the specified length filled with the given character. @keywords string fill repeat pad */
 export declare function strFill(value: string, count: number): string;
@@ -1313,21 +1463,39 @@ export declare function toCamelCase(value?: string): string;
 /** Converts a string to PascalCase (CamelCase with first letter capitalized). @keywords pascalCase, camelCase, capitalize, case conversion */
 export declare function toCamelCaseFirst(value?: string): string;
 
+/** Extracts and validates a 2-letter country code from a location or locale string. @keywords country, locale, bcp47, geolist, parse country */
+export declare function toCountry(code?: unknown, raw?: boolean): string;
+
 /** Converts a value to a Date object. @keywords date, parse, convert, timestamp */
 export declare function toDate<T extends Date | number | string>(value?: T): (T & Date) | Date;
 
+/** Finds geographical country and locale data by language-country, country, or language code. @keywords geo, country, locale, language code, geo item */
+export declare function toGeoItem(code?: unknown): GeoItem | undefined;
+
+/** Transforms a basic geo item into a full geo item with resolved location data and defaults. @keywords geo item, location resolution, defaults, country code */
+export declare function toGeoItemFull(item: GeoItem, code?: string): GeoItemFull;
+
+/** Converts a geo item to its standard string representation (language-country). @keywords geo standard country language code format */
+export declare function toGeoStandard(item?: GeoItem, language?: string, raw?: boolean): string;
+
 /** Converts a string to kebab-case format by replacing spaces and separators with hyphens. @keywords kebab-case, dash-case, slugify, string */
 export declare function toKebabCase(value?: string): string;
 
+/** Extracts and validates a canonical language code from a location or language string (BCP-47, ISO 639). @keywords language, locale, bcp47, iso639, geolist, parse, normalize */
+export declare function toLanguage(code?: unknown, raw?: boolean): string;
+
+/** Converts a full locale string into canonical standard 'aa-AA' format, or returns an empty string if incomplete. @keywords locale, canonicalize, format, language, country */
+export declare function toLocale(code?: unknown): string;
+
 /**
- * Converts a string or number to a finite floating-point number, handling separators and stripping non-numeric characters.
- * @keywords toNumber, parse float, string to number, numeric cast, sanitize
+ * Converts a value to a finite floating-point number, normalizing separators and stripping non-numeric characters.
+ * @keywords parse, float, number, cast, numeric conversion, separator
  * @example
  * toNumber("1 234,56") // 1234.56
  * toNumber("1,234.56") // 1234.56
  * toNumber("1,234")    // 1.234
  */
-export declare function toNumber(value?: NumberOrString): number;
+export declare function toNumber(value?: unknown): number;
 
 /** Converts a value to a number clamped by a maximum permissible value, with optional formatting. @keywords toNumberByMax, clamp, max, number, format */
 export declare function toNumberByMax(value?: NumberOrString, max?: NumberOrString, formatting?: boolean, language?: string): string | number;
@@ -1356,15 +1524,15 @@ export declare function toPercentBy100(maxValue: number, value: number): number;
 export declare function toString<T>(value: T): string;
 
 /**
- * Transforms a string into its corresponding data type (undefined, null, boolean, number, object, or function).
- * @keywords transform, parse, cast, deserialize, type coercion, string conversion
+ * Transforms a string into its corresponding data type (boolean, number, object, null, undefined, or function).
+ * @keywords transform, parse, cast, deserialize, type conversion
  * @example
  * transformation('true') // true
  * transformation('12.5') // 12.5
  * transformation('{"a":1}') // { a: 1 }
  * transformation('null') // null
  */
-export declare function transformation<T = unknown>(value: unknown, isFunctionCheck?: boolean): T;
+export declare function transformation<T = unknown>(value?: unknown, isFunctionCheck?: boolean): T;
 
 /**
  * Converts a Uint8Array to a base64 encoded string across Node.js, modern ECMAScript, and browsers.
@@ -1374,8 +1542,8 @@ export declare function transformation<T = unknown>(value: unknown, isFunctionCh
  */
 export declare function uint8ArrayToBase64(bytes?: Uint8Array | null): string;
 
-/** Removes duplicate elements from an array. @keywords unique, deduplicate, distinct, array, filter */
-export declare function uniqueArray<T>(value: T[]): T[];
+/** Removes duplicate elements from an array. @keywords unique, deduplicate, distinct, array */
+export declare function uniqueArray<T = unknown>(value?: readonly T[] | null): T[];
 
 /** Writes text data to the system clipboard. @keywords clipboard, copy, write, text */
 export declare function writeClipboardData(text: string): Promise<void>;
@@ -1507,7 +1675,7 @@ export type ApiStatusItem = {
 export type ApiStatusType = 'success' | 'error' | 'warning' | 'info';
 
 export type Undefined = undefined | null;
-/** Union of empty or falsy values and their string equivalents @keywords empty, falsy, nullish, blank */
+/** Union representing falsy, nullish, or string-serialized empty values @keywords empty, nullish, falsy */
 export type EmptyValue = Undefined | 0 | false | '' | 'undefined' | 'null' | '0' | 'false' | '[]';
 export type NumberOrString = number | string;
 export type NumberOrStringOrBoolean = number | string | boolean;
@@ -1516,7 +1684,7 @@ export type NormalOrArray<T = NumberOrString> = T | T[];
 export type NormalOrPromise<T> = T | Promise<T>;
 export type ObjectItem<T = any> = Record<string, T>;
 export type ObjectOrArray<T = any> = T[] | ObjectItem<T>;
-/** Extracts the element type from an array type @keywords array, unwrap, element, infer */
+/** Unwraps an array type to its element type @keywords array, unwrap, extract */
 export type ArrayToItem<T> = T extends any[] ? T[number] : T;
 export type FunctionOr<T = any> = T | FunctionReturn<T>;
 export type FunctionReturn<R = any> = () => R;
@@ -1525,32 +1693,34 @@ export type FunctionArgs<T, R> = (...args: T[]) => R;
 export type FunctionAnyType<T = any, R = any> = (...args: T[]) => R;
 export type ItemList<T = any> = Record<string, T>;
 export type Item<V> = {
-  index: string;
-  value: V;
+    index: string;
+    value: V;
 };
 export type ItemValue<V> = {
-  label: string;
-  value: V;
+    label: string;
+    value: V;
 };
 export type ItemName<V> = {
-  name: string | number;
-  value: V;
+    name: string | number;
+    value: V;
 };
-export type ElementOrWindow = HTMLElement | Window;
+export type ElementOrWindow = HTMLElement | SVGElement | Element | Window;
+/** Resolves ElementOrWindow types, substituting Window with HTMLElement @keywords element, dom, window */
+export type ElementResolved<E extends ElementOrWindow = HTMLElement> = E extends Window ? HTMLElement : Exclude<E, Window>;
 export type ElementOrString<E extends ElementOrWindow> = E | string;
 export type EventOptions = AddEventListenerOptions | boolean | undefined;
-/** Event listener callback with optional custom detail payload @keywords event, listener, detail, callback */
+/** Event listener accepting an event and an optional custom detail payload @keywords event, listener, detail */
 export type EventListenerDetail<O extends Event, D extends Record<string, any>> = (event: O, detail?: D) => void;
-/** Active event listener or observer tracking entry @keywords event, listener, observer, activity */
+/** Tracks an active event listener or observer registration @keywords event, listener, observer, activity */
 export type EventActivityItem<E extends ElementOrWindow> = {
-  element: E | undefined;
-  type: string;
-  listener?: (event: any | Event) => void;
-  observer?: ResizeObserver;
+    element: E | undefined;
+    type: string;
+    listener?: (event: any | Event) => void;
+    observer?: ResizeObserver;
 };
 export type ImageCoordinator = {
-  x: number;
-  y: number;
+    x: number;
+    y: number;
 };
 
 export type ErrorCenterGroup = string | undefined;
@@ -1649,89 +1819,84 @@ export type FormattersReturn<List extends FormattersListProp, Options extends Fo
 
 export type GeoDate = 'full' | 'datetime' | 'date' | 'year-month' | 'year' | 'month' | 'day' | 'day-month' | 'time' | 'hour-minute' | 'hour' | 'minute' | 'second';
 export type GeoFirstDay = 1 | 6 | 0;
+/** Default first day of the week ('Mo' = Monday). @keywords calendar, first_day, locale */
+export declare const GEO_DEFAULT_FIRST_DAY = "Mo";
 export type GeoHours = '12' | '24';
 export type GeoTimeZoneStyle = 'minute' | 'hour' | 'ISO8601' | 'RFC';
-
-/** Geographic configuration item containing country, language, and locale formatting rules @keywords geo, locale, country, language */
+/** Geographic item configuration for country, language, and regional formats. @keywords geo, country, language, locale, unit */
 export interface GeoItem {
-  country: string;
-  countryAlternative?: string[];
-  language: string;
-  languageAlternative?: string[];
-  firstDay?: string | null;
-  zone?: string | null;
-  phoneCode?: string;
-  phoneWithin?: string;
-  phoneMask?: string | string[];
-  nameFormat?: 'fl' | 'fsl' | 'lf' | 'lsf' | string;
-  unit?: {
-    'millimeter'?: string;
-    'centimeter'?: string;
-    'meter'?: string;
-    'kilometer'?: string;
-    'square-meter'?: string;
-    'hectare'?: string;
-    'gram'?: string;
-    'kilogram'?: string;
-    'tonne'?: string;
-    'milliliter'?: string;
-    'liter'?: string;
-    'celsius'?: string;
-    'kilometer-per-hour'?: string;
-  };
+    country: string;
+    countryAlternative?: string[];
+    language: string;
+    languageAlternative?: string[];
+    firstDay?: string | null;
+    zone?: string | null;
+    phoneCode?: string;
+    phoneWithin?: string;
+    phoneMask?: string | string[];
+    nameFormat?: 'fl' | 'fsl' | 'lf' | 'lsf' | string;
+    unit?: {
+        'millimeter'?: string;
+        'centimeter'?: string;
+        'meter'?: string;
+        'kilometer'?: string;
+        'square-meter'?: string;
+        'hectare'?: string;
+        'gram'?: string;
+        'kilogram'?: string;
+        'tonne'?: string;
+        'milliliter'?: string;
+        'liter'?: string;
+        'celsius'?: string;
+        'kilometer-per-hour'?: string;
+    };
 }
-
-/** Extended geographic item with resolved required locale fields @keywords geo, locale, full */
+/** Complete geographic item with resolved locale and location identifiers. @keywords geo, location, locale, country */
 export interface GeoItemFull extends Omit<GeoItem, 'firstDay'> {
-  standard: string;
-  firstDay: string;
-  location: string;
-  locationCountry: string;
-  locationLanguage: string;
+    standard: string;
+    firstDay: string;
+    location: string;
+    locationCountry: string;
+    locationLanguage: string;
 }
-
-/** Geographic flag and country display metadata @keywords flag, country, language */
+/** Country flag selection and display item. @keywords flag, country, language, option */
 export interface GeoFlagItem {
-  language: string;
-  languageCode: string;
-  country: string;
-  countryCode: string;
-  standard: string;
-  icon?: string;
-  label: string;
-  value: string;
-  phoneCode?: string;
+    language: string;
+    languageCode: string;
+    country: string;
+    countryCode: string;
+    standard: string;
+    icon?: string;
+    label: string;
+    value: string;
+    phoneCode?: string;
 }
-
-/** Geographic flag item with localized native language descriptions @keywords flag, national, localized */
+/** Extended geographic flag item containing localized national language and country names. @keywords flag, national, localization */
 export interface GeoFlagNational extends GeoFlagItem {
-  description: string;
-  nationalLanguage: string;
-  nationalCountry: string;
+    description: string;
+    nationalLanguage: string;
+    nationalCountry: string;
 }
-
-/** Country phone prefix and mask pattern metadata @keywords phone, mask, countryCode */
+/** Phone dialing configuration and mask metadata for a country. @keywords phone, country_code, mask, dialing */
 export interface GeoPhoneValue {
-  phone: number;
-  within: number;
-  mask: string[];
-  value: string;
+    phone: number;
+    within: number;
+    mask: string[];
+    value: string;
 }
-
-/** Prefix tree node for phone code lookup and mask formatting @keywords phone, trie, prefix, mask */
+/** Node in the internal phone prefix tree (Trie) for number lookup. @keywords phone, trie, prefix_tree, lookup */
 export interface GeoPhoneMap {
-  items: GeoPhoneValue[];
-  info: GeoPhoneValue | undefined;
-  value: string | undefined;
-  mask: string[];
-  maskFull: string[];
-  next: Record<string, GeoPhoneMap>;
+    items: GeoPhoneValue[];
+    info: GeoPhoneValue | undefined;
+    value: string | undefined;
+    mask: string[];
+    maskFull: string[];
+    next: Record<string, GeoPhoneMap>;
 }
-
-/** Result of a phone number lookup against the prefix tree @keywords phone, lookup, result */
+/** Result of matching a phone number against the prefix tree. @keywords phone, lookup, result, match */
 export interface GeoPhoneMapInfo {
-  item?: GeoPhoneMap;
-  phone?: string;
+    item?: GeoPhoneMap;
+    phone?: string;
 }
 
 export declare enum MetaTag {
@@ -1964,27 +2129,36 @@ export type SortColumnItem = {
 /** Custom comparator function for sorting items. @keywords sort, comparator, sort-function */
 export type SortFunction<T = Record<string, unknown>> = (a: T, b: T, column?: string, dir?: SortDir) => number;
 
-/** Translation plugin configuration options @keywords i18n, translate, config, options */
+/** Configuration options for the translation plugin. @keywords translate, config, options */
 export type TranslateConfig = {
     url?: string;
     propsName?: string;
     readApi?: boolean;
 };
-/** Translation code or list of translation codes @keywords i18n, key, code */
 export type TranslateCode = string | string[];
-/** Map of translation keys to resolved translated strings @keywords i18n, list, dictionary */
+/** Map of translation codes to their localized string values. @keywords translate, list, mapping */
 export type TranslateList<T extends TranslateCode[]> = {
     [K in T[number] as K extends readonly string[] ? K[0] : K]: string;
 };
-/** Conditional translation result resolving to an object for multiple keys or a string for single key @keywords i18n, translate, resolver */
+/** Resolves return type to a single translated string or a mapped dictionary. @keywords translate, conditional */
 export type TranslateItemOrList<T extends TranslateCode> = T extends string[] ? TranslateList<T> : string;
 export type TranslateDataFileList = Record<string, string>;
-/** Asynchronous loader function for translation data @keywords i18n, loader, async */
 export type TranslateDataFileItem = () => Promise<TranslateDataFileList>;
-/** Mapping of locale identifiers to translation file loaders @keywords i18n, locale, dictionary */
 export type TranslateDataFile = Record<string, TranslateDataFileItem>;
-/** Prefix identifier for global translations @keywords i18n, global, prefix */
+export type TranslatePromiseItem = {
+    id: number;
+    promise: Promise<TranslateDataFileList | undefined>;
+};
+/** Translation batch queued for retrieval by locale and language. @keywords translate, batch, queue */
+export interface TranslateBatch {
+    readonly location: string;
+    readonly language: string;
+    readonly path: string;
+    readonly codes: string[];
+    readonly resolves: (() => void)[];
+}
+/** Prefix for global translation keys. @keywords translate, prefix, global */
 export declare const TRANSLATE_GLOBAL_PREFIX = "global";
-/** Batch loading request timeout in milliseconds @keywords i18n, timeout, batch */
+/** Request debounce timeout in milliseconds for batch translation loading. @keywords translate, timeout, debounce */
 export declare const TRANSLATE_TIME_OUT = 160;
 ```