osl-base-extended 0.1.18 → 0.1.19

package/fesm2022/osl-base-extended.mjs

@@ -2478,6 +2478,1551 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+// ─── Array Utilities ────────────────────────────────────────────────────────
+/** Splits an array into chunks of the given size. */
+function chunk(array, size) {
+    if (size <= 0)
+        return [];
+    const result = [];
+    for (let i = 0; i < array.length; i += size) {
+        result.push(array.slice(i, i + size));
+    }
+    return result;
+}
+/** Removes duplicate primitive values. */
+function unique(array) {
+    return [...new Set(array)];
+}
+/** Removes duplicates by object key. */
+function uniqueBy(array, key) {
+    const seen = new Set();
+    return array.filter(item => {
+        const val = item[key];
+        if (seen.has(val))
+            return false;
+        seen.add(val);
+        return true;
+    });
+}
+/** Flattens one level of nesting. */
+function flatten(array) {
+    return array.flat();
+}
+/** Deeply flattens a nested array. */
+function flattenDeep(array) {
+    return array.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : [...acc, val], []);
+}
+/** Groups array elements by a key. */
+function groupBy(array, key) {
+    return array.reduce((acc, item) => {
+        const group = String(item[key]);
+        acc[group] = acc[group] ?? [];
+        acc[group].push(item);
+        return acc;
+    }, {});
+}
+/** Sorts array by key ascending or descending. */
+function sortBy(array, key, direction = 'asc') {
+    return [...array].sort((a, b) => {
+        const aVal = a[key];
+        const bVal = b[key];
+        if (aVal < bVal)
+            return direction === 'asc' ? -1 : 1;
+        if (aVal > bVal)
+            return direction === 'asc' ? 1 : -1;
+        return 0;
+    });
+}
+/** Filters array where key matches value (strict equality). */
+function filterBy(array, key, value) {
+    return array.filter(item => item[key] === value);
+}
+/** Sums values at the given numeric key. */
+function sumBy(array, key) {
+    return array.reduce((acc, item) => acc + Number(item[key]), 0);
+}
+/** Returns the item with the minimum value at key. */
+function minBy(array, key) {
+    if (!array.length)
+        return undefined;
+    return array.reduce((min, item) => (item[key] < min[key] ? item : min));
+}
+/** Returns the item with the maximum value at key. */
+function maxBy(array, key) {
+    if (!array.length)
+        return undefined;
+    return array.reduce((max, item) => (item[key] > max[key] ? item : max));
+}
+/** Computes the average of an array of numbers. */
+function average$1(numbers) {
+    if (!numbers.length)
+        return 0;
+    return numbers.reduce((a, b) => a + b, 0) / numbers.length;
+}
+/** Returns true if the array is null, undefined, or has no elements. */
+function isEmpty$2(array) {
+    return !array || array.length === 0;
+}
+/** Returns the last element. */
+function last(array) {
+    return array[array.length - 1];
+}
+/** Returns the first element. */
+function first(array) {
+    return array[0];
+}
+/** Returns a slice of the array for the given page (1-based). */
+function paginate(array, page, pageSize) {
+    const start = (page - 1) * pageSize;
+    return array.slice(start, start + pageSize);
+}
+/** Moves an element from one index to another (immutable). */
+function move(array, fromIndex, toIndex) {
+    const result = [...array];
+    const [item] = result.splice(fromIndex, 1);
+    result.splice(toIndex, 0, item);
+    return result;
+}
+/** Adds the item if absent, removes it if present. */
+function toggle(array, item) {
+    return array.includes(item) ? array.filter(i => i !== item) : [...array, item];
+}
+/** Returns elements present in both arrays. */
+function intersection(a, b) {
+    const setB = new Set(b);
+    return a.filter(item => setB.has(item));
+}
+/** Returns elements in `a` not present in `b`. */
+function difference(a, b) {
+    const setB = new Set(b);
+    return a.filter(item => !setB.has(item));
+}
+/** Converts an array to a lookup map keyed by the given property. */
+function toMap(array, key) {
+    return array.reduce((acc, item) => {
+        acc[String(item[key])] = item;
+        return acc;
+    }, {});
+}
+/** Removes falsy values (null, undefined, 0, '', false). */
+function compact(array) {
+    return array.filter(Boolean);
+}
+/** Returns a new randomly shuffled copy. */
+function shuffle(array) {
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}
+function sample(array, count) {
+    if (count === undefined)
+        return array[Math.floor(Math.random() * array.length)];
+    return shuffle(array).slice(0, count);
+}
+/** Counts occurrences of each value at the given key. */
+function countBy(array, key) {
+    return array.reduce((acc, item) => {
+        const group = String(item[key]);
+        acc[group] = (acc[group] ?? 0) + 1;
+        return acc;
+    }, {});
+}
+/** Returns the union of two arrays (unique values from both). */
+function union(a, b) {
+    return unique([...a, ...b]);
+}
+/** Zips multiple arrays into an array of tuples. */
+function zip(...arrays) {
+    const length = Math.max(...arrays.map(a => a.length));
+    return Array.from({ length }, (_, i) => arrays.map(a => a[i]));
+}
+/** Returns true if predicate holds for all elements. */
+function every(array, predicate) {
+    return array.every(predicate);
+}
+/** Returns true if predicate holds for at least one element. */
+function some(array, predicate) {
+    return array.some(predicate);
+}
+/** Partitions an array into two groups based on predicate. */
+function partition(array, predicate) {
+    const pass = [];
+    const fail = [];
+    for (const item of array) {
+        (predicate(item) ? pass : fail).push(item);
+    }
+    return [pass, fail];
+}
+
+var array_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    average: average$1,
+    chunk: chunk,
+    compact: compact,
+    countBy: countBy,
+    difference: difference,
+    every: every,
+    filterBy: filterBy,
+    first: first,
+    flatten: flatten,
+    flattenDeep: flattenDeep,
+    groupBy: groupBy,
+    intersection: intersection,
+    isEmpty: isEmpty$2,
+    last: last,
+    maxBy: maxBy,
+    minBy: minBy,
+    move: move,
+    paginate: paginate,
+    partition: partition,
+    sample: sample,
+    shuffle: shuffle,
+    some: some,
+    sortBy: sortBy,
+    sumBy: sumBy,
+    toMap: toMap,
+    toggle: toggle,
+    union: union,
+    unique: unique,
+    uniqueBy: uniqueBy,
+    zip: zip
+});
+
+// ─── Date Utilities ───────────────────────────────────────────────────────────
+const MONTH_NAMES_SHORT = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const MONTH_NAMES_FULL = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const DAY_NAMES_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const DAY_NAMES_FULL = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+function pad(n) {
+    return String(n).padStart(2, '0');
+}
+/** Returns the current date and time. */
+function now() {
+    return new Date();
+}
+/** Returns today's date with time set to midnight. */
+function today() {
+    return startOfDay(new Date());
+}
+/** Returns true if the value is a valid Date object. */
+function isValidDate$1(value) {
+    return value instanceof Date && !isNaN(value.getTime());
+}
+/**
+ * Formats a Date using a pattern string.
+ * Tokens: YYYY, YY, MM, M, DD, D, HH, H, mm, m, ss, s,
+ *         MMM (short month), MMMM (full month),
+ *         ddd (short day), dddd (full day).
+ */
+function formatDate(date, pattern) {
+    const d = new Date(date);
+    if (!isValidDate$1(d))
+        return '';
+    const year = d.getFullYear();
+    const month = d.getMonth();
+    const day = d.getDate();
+    const hours = d.getHours();
+    const mins = d.getMinutes();
+    const secs = d.getSeconds();
+    const dayOfWeek = d.getDay();
+    return pattern
+        .replace('YYYY', String(year))
+        .replace('YY', String(year).slice(-2))
+        .replace('MMMM', MONTH_NAMES_FULL[month])
+        .replace('MMM', MONTH_NAMES_SHORT[month])
+        .replace('MM', pad(month + 1))
+        .replace('M', String(month + 1))
+        .replace('dddd', DAY_NAMES_FULL[dayOfWeek])
+        .replace('ddd', DAY_NAMES_SHORT[dayOfWeek])
+        .replace('DD', pad(day))
+        .replace('D', String(day))
+        .replace('HH', pad(hours))
+        .replace('H', String(hours))
+        .replace('mm', pad(mins))
+        .replace('m', String(mins))
+        .replace('ss', pad(secs))
+        .replace('s', String(secs));
+}
+/** Returns date as `YYYY-MM-DD`. */
+function toDateOnly(date) {
+    return formatDate(date, 'YYYY-MM-DD');
+}
+/** Returns the ISO 8601 string for a date. */
+function toISOString(date) {
+    return date.toISOString();
+}
+/** Returns a new date with `days` added. */
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+/** Returns a new date with `months` added. */
+function addMonths(date, months) {
+    const result = new Date(date);
+    result.setMonth(result.getMonth() + months);
+    return result;
+}
+/** Returns a new date with `years` added. */
+function addYears(date, years) {
+    const result = new Date(date);
+    result.setFullYear(result.getFullYear() + years);
+    return result;
+}
+/** Returns a new date with `hours` added. */
+function addHours(date, hours) {
+    return new Date(date.getTime() + hours * 3_600_000);
+}
+/** Returns a new date with `minutes` added. */
+function addMinutes(date, minutes) {
+    return new Date(date.getTime() + minutes * 60_000);
+}
+/** Returns a new date with `days` subtracted. */
+function subtractDays(date, days) {
+    return addDays(date, -days);
+}
+/** Returns a new date with `months` subtracted. */
+function subtractMonths(date, months) {
+    return addMonths(date, -months);
+}
+/** Returns a new date with `years` subtracted. */
+function subtractYears(date, years) {
+    return addYears(date, -years);
+}
+/** Returns the absolute difference in whole days between two dates. */
+function diffInDays(date1, date2) {
+    return Math.abs(Math.floor((date1.getTime() - date2.getTime()) / 86_400_000));
+}
+/** Returns the absolute difference in whole months between two dates. */
+function diffInMonths(date1, date2) {
+    return Math.abs((date1.getFullYear() - date2.getFullYear()) * 12 +
+        (date1.getMonth() - date2.getMonth()));
+}
+/** Returns the absolute difference in whole years between two dates. */
+function diffInYears(date1, date2) {
+    return Math.abs(date1.getFullYear() - date2.getFullYear());
+}
+/** Returns the difference in minutes between two dates (date1 - date2). */
+function diffInMinutes(date1, date2) {
+    return Math.floor((date1.getTime() - date2.getTime()) / 60_000);
+}
+/** Returns true if date1 is strictly before date2. */
+function isBefore(date1, date2) {
+    return date1.getTime() < date2.getTime();
+}
+/** Returns true if date1 is strictly after date2. */
+function isAfter(date1, date2) {
+    return date1.getTime() > date2.getTime();
+}
+/** Returns true if both dates fall on the same calendar day. */
+function isSameDay(date1, date2) {
+    return (date1.getFullYear() === date2.getFullYear() &&
+        date1.getMonth() === date2.getMonth() &&
+        date1.getDate() === date2.getDate());
+}
+/** Returns true if the date falls on a Saturday or Sunday. */
+function isWeekend(date) {
+    return date.getDay() === 0 || date.getDay() === 6;
+}
+/** Returns true if the date is today. */
+function isToday(date) {
+    return isSameDay(date, new Date());
+}
+/** Returns true if the date falls in the past (before now). */
+function isPast(date) {
+    return date.getTime() < Date.now();
+}
+/** Returns true if the date falls in the future (after now). */
+function isFuture(date) {
+    return date.getTime() > Date.now();
+}
+/** Returns the date with time set to 00:00:00.000. */
+function startOfDay(date) {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    return result;
+}
+/** Returns the date with time set to 23:59:59.999. */
+function endOfDay(date) {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+}
+/** Returns the first day of the month (time 00:00:00.000). */
+function startOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+/** Returns the last day of the month (time 23:59:59.999). */
+function endOfMonth(date) {
+    const result = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+    result.setHours(23, 59, 59, 999);
+    return result;
+}
+/** Returns the first day of the year (Jan 1, 00:00:00.000). */
+function startOfYear(date) {
+    return new Date(date.getFullYear(), 0, 1);
+}
+/** Returns the last day of the year (Dec 31, 23:59:59.999). */
+function endOfYear(date) {
+    const result = new Date(date.getFullYear(), 11, 31);
+    result.setHours(23, 59, 59, 999);
+    return result;
+}
+/** Calculates the age in years from a birth date. */
+function getAge(birthDate) {
+    const n = new Date();
+    let age = n.getFullYear() - birthDate.getFullYear();
+    const monthDiff = n.getMonth() - birthDate.getMonth();
+    if (monthDiff < 0 || (monthDiff === 0 && n.getDate() < birthDate.getDate()))
+        age--;
+    return age;
+}
+/** Returns the number of days in a given month (0-based month). */
+function daysInMonth(year, month) {
+    return new Date(year, month + 1, 0).getDate();
+}
+/** Returns true if the given year is a leap year. */
+function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+/**
+ * Returns a human-friendly relative time string.
+ * @example timeAgo(new Date(Date.now() - 3600_000)) → '1 hour ago'
+ */
+function timeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    const abs = Math.abs(seconds);
+    const future = seconds < 0;
+    const intervals = [
+        [31_536_000, 'year'],
+        [2_592_000, 'month'],
+        [604_800, 'week'],
+        [86_400, 'day'],
+        [3_600, 'hour'],
+        [60, 'minute'],
+        [1, 'second'],
+    ];
+    for (const [secs, label] of intervals) {
+        const count = Math.floor(abs / secs);
+        if (count >= 1) {
+            const unit = count === 1 ? label : `${label}s`;
+            return future ? `in ${count} ${unit}` : `${count} ${unit} ago`;
+        }
+    }
+    return 'just now';
+}
+/** Returns the ISO week number (1–53) for the given date. */
+function getWeekNumber(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil((((d.getTime() - yearStart.getTime()) / 86_400_000) + 1) / 7);
+}
+/** Returns the next weekday (Mon–Fri) after the given date. */
+function nextWorkday(date) {
+    const result = addDays(date, 1);
+    while (isWeekend(result)) {
+        result.setDate(result.getDate() + 1);
+    }
+    return result;
+}
+/** Returns true if a date falls within the range [start, end] (inclusive). */
+function inRange$2(date, start, end) {
+    return date >= start && date <= end;
+}
+/** Parses a `YYYY-MM-DD` string and returns a local-midnight Date or null. */
+function parseDate(dateStr) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr);
+    if (!match)
+        return null;
+    const [, y, mo, d] = match.map(Number);
+    const result = new Date(y, mo - 1, d);
+    return isValidDate$1(result) ? result : null;
+}
+
+var date_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    addDays: addDays,
+    addHours: addHours,
+    addMinutes: addMinutes,
+    addMonths: addMonths,
+    addYears: addYears,
+    daysInMonth: daysInMonth,
+    diffInDays: diffInDays,
+    diffInMinutes: diffInMinutes,
+    diffInMonths: diffInMonths,
+    diffInYears: diffInYears,
+    endOfDay: endOfDay,
+    endOfMonth: endOfMonth,
+    endOfYear: endOfYear,
+    formatDate: formatDate,
+    getAge: getAge,
+    getWeekNumber: getWeekNumber,
+    inRange: inRange$2,
+    isAfter: isAfter,
+    isBefore: isBefore,
+    isFuture: isFuture,
+    isLeapYear: isLeapYear,
+    isPast: isPast,
+    isSameDay: isSameDay,
+    isToday: isToday,
+    isValidDate: isValidDate$1,
+    isWeekend: isWeekend,
+    nextWorkday: nextWorkday,
+    now: now,
+    parseDate: parseDate,
+    startOfDay: startOfDay,
+    startOfMonth: startOfMonth,
+    startOfYear: startOfYear,
+    subtractDays: subtractDays,
+    subtractMonths: subtractMonths,
+    subtractYears: subtractYears,
+    timeAgo: timeAgo,
+    toDateOnly: toDateOnly,
+    toISOString: toISOString,
+    today: today
+});
+
+// ─── Number Utilities ────────────────────────────────────────────────────────
+/** Rounds to the given number of decimal places (default 0). */
+function round(num, decimals = 0) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(num * factor) / factor;
+}
+/** Floors to the given number of decimal places (default 0). */
+function floor(num, decimals = 0) {
+    const factor = Math.pow(10, decimals);
+    return Math.floor(num * factor) / factor;
+}
+/** Ceils to the given number of decimal places (default 0). */
+function ceil(num, decimals = 0) {
+    const factor = Math.pow(10, decimals);
+    return Math.ceil(num * factor) / factor;
+}
+/** Clamps a number within [min, max]. */
+function clamp(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+/**
+ * Formats a number as currency using Intl.NumberFormat.
+ * @example formatCurrency(1234.5, 'USD', 'en-US') → '$1,234.50'
+ */
+function formatCurrency(num, currency = 'USD', locale = 'en-US') {
+    return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(num);
+}
+/**
+ * Formats a number with grouping separators and fixed decimal places.
+ * @example formatNumber(1234567.89, 2, 'en-US') → '1,234,567.89'
+ */
+function formatNumber(num, decimals = 2, locale = 'en-US') {
+    return new Intl.NumberFormat(locale, {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals,
+    }).format(num);
+}
+/**
+ * Calculates what percentage `value` is of `total`.
+ * @example percentage(25, 200) → 12.5
+ */
+function percentage(value, total, decimals = 2) {
+    if (total === 0)
+        return 0;
+    return round((value / total) * 100, decimals);
+}
+/** Returns true if `num` is a prime number. */
+function isPrime(num) {
+    if (num < 2)
+        return false;
+    if (num === 2)
+        return true;
+    if (num % 2 === 0)
+        return false;
+    for (let i = 3; i <= Math.sqrt(num); i += 2) {
+        if (num % i === 0)
+            return false;
+    }
+    return true;
+}
+/** Returns true if the number is even. */
+function isEven(num) {
+    return num % 2 === 0;
+}
+/** Returns true if the number is odd. */
+function isOdd(num) {
+    return num % 2 !== 0;
+}
+/** Returns a random floating-point number in [min, max). */
+function random(min, max) {
+    return Math.random() * (max - min) + min;
+}
+/** Returns a random integer in [min, max] (inclusive). */
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/** Returns the sum of an array of numbers. */
+function sum(numbers) {
+    return numbers.reduce((acc, n) => acc + n, 0);
+}
+/** Returns the average of an array of numbers. */
+function average(numbers) {
+    if (!numbers.length)
+        return 0;
+    return sum(numbers) / numbers.length;
+}
+/** Returns the minimum value in an array. */
+function min(numbers) {
+    return Math.min(...numbers);
+}
+/** Returns the maximum value in an array. */
+function max(numbers) {
+    return Math.max(...numbers);
+}
+/**
+ * Returns the ordinal string for a number.
+ * @example toOrdinal(3) → '3rd'
+ */
+function toOrdinal(num) {
+    const abs = Math.abs(num);
+    const suffix = abs % 100 >= 11 && abs % 100 <= 13 ? 'th' :
+        abs % 10 === 1 ? 'st' :
+            abs % 10 === 2 ? 'nd' :
+                abs % 10 === 3 ? 'rd' : 'th';
+    return `${num}${suffix}`;
+}
+/**
+ * Abbreviates large numbers with K / M / B / T suffixes.
+ * @example abbreviate(1500000) → '1.5M'
+ */
+function abbreviate(num, decimals = 1) {
+    const tiers = [
+        [1e12, 'T'],
+        [1e9, 'B'],
+        [1e6, 'M'],
+        [1e3, 'K'],
+    ];
+    const abs = Math.abs(num);
+    for (const [threshold, suffix] of tiers) {
+        if (abs >= threshold) {
+            return `${round(num / threshold, decimals)}${suffix}`;
+        }
+    }
+    return String(num);
+}
+/** Returns true if `num` is within [min, max] (inclusive). */
+function inRange$1(num, min, max) {
+    return num >= min && num <= max;
+}
+/** Parses a string to float; returns null if not a valid number. */
+function safeParseFloat(str) {
+    const n = parseFloat(str);
+    return isNaN(n) ? null : n;
+}
+/** Parses a string to integer; returns null if not a valid number. */
+function safeParseInt(str, radix = 10) {
+    const n = parseInt(str, radix);
+    return isNaN(n) ? null : n;
+}
+/** Returns the greatest common divisor of two integers. */
+function gcd(a, b) {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while (b) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+/** Returns the least common multiple of two integers. */
+function lcm(a, b) {
+    return Math.abs(a * b) / gcd(a, b);
+}
+/** Returns the Nth Fibonacci number (0-indexed). */
+function fibonacci(n) {
+    if (n <= 1)
+        return n;
+    let a = 0, b = 1;
+    for (let i = 2; i <= n; i++) {
+        [a, b] = [b, a + b];
+    }
+    return b;
+}
+/** Returns true if the value is a finite number (not NaN, not ±Infinity). */
+function isFiniteNumber(value) {
+    return typeof value === 'number' && isFinite(value);
+}
+/** Returns true if the value is NaN. */
+function isNaNValue(value) {
+    return typeof value === 'number' && isNaN(value);
+}
+/** Returns true if the number is positive (> 0). */
+function isPositive$1(num) {
+    return num > 0;
+}
+/** Returns true if the number is negative (< 0). */
+function isNegative$1(num) {
+    return num < 0;
+}
+/** Converts degrees to radians. */
+function toRadians(degrees) {
+    return degrees * (Math.PI / 180);
+}
+/** Converts radians to degrees. */
+function toDegrees(radians) {
+    return radians * (180 / Math.PI);
+}
+/** Linearly interpolates between `start` and `end` by factor `t` (0–1). */
+function lerp(start, end, t) {
+    return start + (end - start) * clamp(t, 0, 1);
+}
+
+var number_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    abbreviate: abbreviate,
+    average: average,
+    ceil: ceil,
+    clamp: clamp,
+    fibonacci: fibonacci,
+    floor: floor,
+    formatCurrency: formatCurrency,
+    formatNumber: formatNumber,
+    gcd: gcd,
+    inRange: inRange$1,
+    isEven: isEven,
+    isFiniteNumber: isFiniteNumber,
+    isNaNValue: isNaNValue,
+    isNegative: isNegative$1,
+    isOdd: isOdd,
+    isPositive: isPositive$1,
+    isPrime: isPrime,
+    lcm: lcm,
+    lerp: lerp,
+    max: max,
+    min: min,
+    percentage: percentage,
+    random: random,
+    randomInt: randomInt,
+    round: round,
+    safeParseFloat: safeParseFloat,
+    safeParseInt: safeParseInt,
+    sum: sum,
+    toDegrees: toDegrees,
+    toOrdinal: toOrdinal,
+    toRadians: toRadians
+});
+
+// ─── Object Utilities ────────────────────────────────────────────────────────
+/** Returns a deep clone of the value using structured clone. */
+function deepClone(obj) {
+    return structuredClone(obj);
+}
+/** Deep-merges one or more source objects into target (immutable). */
+function deepMerge(target, ...sources) {
+    const result = deepClone(target);
+    for (const source of sources) {
+        for (const key in source) {
+            const srcVal = source[key];
+            const tgtVal = result[key];
+            if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+                result[key] = deepMerge(tgtVal, srcVal);
+            }
+            else if (srcVal !== undefined) {
+                result[key] = deepClone(srcVal);
+            }
+        }
+    }
+    return result;
+}
+/** Returns true if `value` is a plain (non-null) object literal. */
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+/** Creates a new object containing only the specified keys. */
+function pick(obj, keys) {
+    return keys.reduce((acc, key) => {
+        if (key in obj)
+            acc[key] = obj[key];
+        return acc;
+    }, {});
+}
+/** Creates a new object excluding the specified keys. */
+function omit(obj, keys) {
+    const keySet = new Set(keys);
+    return Object.fromEntries(Object.entries(obj).filter(([k]) => !keySet.has(k)));
+}
+/** Returns true if the object has no own enumerable properties. */
+function isEmpty$1(obj) {
+    if (obj == null)
+        return true;
+    return Object.keys(obj).length === 0;
+}
+/** Deep equality check. */
+function isEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return a === b;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => isEqual(v, b[i]));
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        return keysA.every(k => isEqual(a[k], b[k]));
+    }
+    return false;
+}
+/**
+ * Flattens a nested object to a single depth using `delimiter` as key separator.
+ * @example flattenObject({ a: { b: 1 } }) → { 'a.b': 1 }
+ */
+function flattenObject(obj, delimiter = '.', prefix = '') {
+    const result = {};
+    for (const key in obj) {
+        const fullKey = prefix ? `${prefix}${delimiter}${key}` : key;
+        const value = obj[key];
+        if (isPlainObject(value)) {
+            Object.assign(result, flattenObject(value, delimiter, fullKey));
+        }
+        else {
+            result[fullKey] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Converts a flat object with delimiter-separated keys back to a nested object.
+ * @example unflattenObject({ 'a.b': 1 }) → { a: { b: 1 } }
+ */
+function unflattenObject(obj, delimiter = '.') {
+    const result = {};
+    for (const flatKey in obj) {
+        const parts = flatKey.split(delimiter);
+        let current = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!isPlainObject(current[part]))
+                current[part] = {};
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = obj[flatKey];
+    }
+    return result;
+}
+/** Serializes an object to a URL query string (excludes null/undefined values). */
+function toQueryString(obj) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(obj)) {
+        if (value != null)
+            params.append(key, String(value));
+    }
+    return params.toString();
+}
+/** Parses a URL query string into a key-value map. */
+function fromQueryString(queryString) {
+    const params = new URLSearchParams(queryString.startsWith('?') ? queryString.slice(1) : queryString);
+    const result = {};
+    params.forEach((value, key) => { result[key] = value; });
+    return result;
+}
+/**
+ * Gets a deeply nested value by dot-path string.
+ * @example getPath({ a: { b: 2 } }, 'a.b') → 2
+ */
+function getPath(obj, path, defaultValue) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (current == null || typeof current !== 'object')
+            return defaultValue;
+        current = current[key];
+    }
+    return current ?? defaultValue;
+}
+/**
+ * Sets a deeply nested value by dot-path string (mutates the object).
+ * @example setPath(obj, 'a.b', 42)
+ */
+function setPath(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!isPlainObject(current[key]))
+            current[key] = {};
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+}
+/** Returns true if a dot-path resolves to a defined value. */
+function hasPath(obj, path) {
+    return getPath(obj, path) !== undefined;
+}
+/** Applies a mapping function to every value in an object. */
+function mapValues(obj, fn) {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v, k)]));
+}
+/** Returns a new object containing only entries where the predicate returns true. */
+function filterValues(obj, fn) {
+    return Object.fromEntries(Object.entries(obj).filter(([k, v]) => fn(v, k)));
+}
+/** Swaps keys and values in an object (both must be strings). */
+function invertObject(obj) {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [v, k]));
+}
+/** Returns a new object with keys sorted alphabetically. */
+function sortByKey(obj) {
+    return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+/**
+ * Returns the keys of obj2 whose values differ from obj1 (shallow comparison).
+ * Useful for detecting changed form fields.
+ */
+function diff(obj1, obj2) {
+    const result = {};
+    for (const key in obj2) {
+        if (obj1[key] !== obj2[key]) {
+            result[key] = obj2[key];
+        }
+    }
+    return result;
+}
+/** Returns the number of own enumerable keys. */
+function size(obj) {
+    return Object.keys(obj).length;
+}
+/** Returns true if `obj` has the given own enumerable key. */
+function hasKey(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+var object_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    deepClone: deepClone,
+    deepMerge: deepMerge,
+    diff: diff,
+    filterValues: filterValues,
+    flattenObject: flattenObject,
+    fromQueryString: fromQueryString,
+    getPath: getPath,
+    hasKey: hasKey,
+    hasPath: hasPath,
+    invertObject: invertObject,
+    isEmpty: isEmpty$1,
+    isEqual: isEqual,
+    isPlainObject: isPlainObject,
+    mapValues: mapValues,
+    omit: omit,
+    pick: pick,
+    setPath: setPath,
+    size: size,
+    sortByKey: sortByKey,
+    toQueryString: toQueryString,
+    unflattenObject: unflattenObject
+});
+
+// ─── Storage Utilities ───────────────────────────────────────────────────────
+// Values are JSON-serialized before storage and deserialized on retrieval.
+// ── Local Storage ────────────────────────────────────────────────────────────
+/** Serializes `value` and writes it to localStorage. */
+function setLocal(key, value) {
+    try {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        /* quota exceeded or private browsing — silently ignore */
+    }
+}
+/** Reads and deserializes a value from localStorage. Returns null if absent or invalid. */
+function getLocal(key) {
+    try {
+        const item = localStorage.getItem(key);
+        return item !== null ? JSON.parse(item) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Removes a key from localStorage. */
+function removeLocal(key) {
+    localStorage.removeItem(key);
+}
+/** Clears all entries from localStorage. */
+function clearLocal() {
+    localStorage.clear();
+}
+/** Returns true if the key exists in localStorage. */
+function hasLocal(key) {
+    return localStorage.getItem(key) !== null;
+}
+/** Returns all keys currently in localStorage. */
+function localKeys() {
+    return Object.keys(localStorage);
+}
+// ── Session Storage ───────────────────────────────────────────────────────────
+/** Serializes `value` and writes it to sessionStorage. */
+function setSession(key, value) {
+    try {
+        sessionStorage.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        /* quota exceeded — silently ignore */
+    }
+}
+/** Reads and deserializes a value from sessionStorage. Returns null if absent or invalid. */
+function getSession(key) {
+    try {
+        const item = sessionStorage.getItem(key);
+        return item !== null ? JSON.parse(item) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Removes a key from sessionStorage. */
+function removeSession(key) {
+    sessionStorage.removeItem(key);
+}
+/** Clears all entries from sessionStorage. */
+function clearSession() {
+    sessionStorage.clear();
+}
+/** Returns true if the key exists in sessionStorage. */
+function hasSession(key) {
+    return sessionStorage.getItem(key) !== null;
+}
+/** Returns all keys currently in sessionStorage. */
+function sessionKeys() {
+    return Object.keys(sessionStorage);
+}
+// ── Cookies ──────────────────────────────────────────────────────────────────
+/**
+ * Sets a cookie.
+ * @param days - Expiry in days. Omit or pass 0 for a session cookie.
+ * @param path - Cookie path (default '/').
+ */
+function setCookie(name, value, days, path = '/') {
+    let expires = '';
+    if (days) {
+        const date = new Date();
+        date.setTime(date.getTime() + days * 86_400_000);
+        expires = `; expires=${date.toUTCString()}`;
+    }
+    document.cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}${expires}; path=${path}; SameSite=Lax`;
+}
+/** Returns the decoded cookie value, or null if not found. */
+function getCookie(name) {
+    const key = `${encodeURIComponent(name)}=`;
+    for (const part of document.cookie.split(';')) {
+        const trimmed = part.trimStart();
+        if (trimmed.startsWith(key)) {
+            return decodeURIComponent(trimmed.slice(key.length));
+        }
+    }
+    return null;
+}
+/** Removes a cookie by setting its expiry to the past. */
+function removeCookie(name, path = '/') {
+    document.cookie = `${encodeURIComponent(name)}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${path}`;
+}
+/** Returns all current cookies as a key-value map (both decoded). */
+function getAllCookies() {
+    return document.cookie
+        .split(';')
+        .reduce((acc, part) => {
+        const [k, ...rest] = part.trim().split('=');
+        if (k)
+            acc[decodeURIComponent(k)] = decodeURIComponent(rest.join('='));
+        return acc;
+    }, {});
+}
+/** Returns true if the cookie exists. */
+function hasCookie(name) {
+    return getCookie(name) !== null;
+}
+
+var storage_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    clearLocal: clearLocal,
+    clearSession: clearSession,
+    getAllCookies: getAllCookies,
+    getCookie: getCookie,
+    getLocal: getLocal,
+    getSession: getSession,
+    hasCookie: hasCookie,
+    hasLocal: hasLocal,
+    hasSession: hasSession,
+    localKeys: localKeys,
+    removeCookie: removeCookie,
+    removeLocal: removeLocal,
+    removeSession: removeSession,
+    sessionKeys: sessionKeys,
+    setCookie: setCookie,
+    setLocal: setLocal,
+    setSession: setSession
+});
+
+// ─── String Utilities ────────────────────────────────────────────────────────
+/** Returns true if the value is null, undefined, or an empty string. */
+function isEmpty(str) {
+    return str == null || str.length === 0;
+}
+/** Returns true if the value is null, undefined, empty, or whitespace only. */
+function isBlank(str) {
+    return str == null || str.trim().length === 0;
+}
+/** Capitalizes the first letter; lowercases the rest. */
+function capitalize(str) {
+    if (!str)
+        return '';
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+/** Converts each word's first letter to uppercase. */
+function titleCase(str) {
+    return str.replace(/\w\S*/g, word => capitalize(word));
+}
+/** Converts a string to camelCase. */
+function camelCase(str) {
+    return str
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase())
+        .replace(/^[A-Z]/, c => c.toLowerCase());
+}
+/** Converts a string to PascalCase. */
+function pascalCase(str) {
+    const cc = camelCase(str);
+    return cc.charAt(0).toUpperCase() + cc.slice(1);
+}
+/** Converts a string to snake_case. */
+function snakeCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .replace(/[\s\-]+/g, '_')
+        .toLowerCase();
+}
+/** Converts a string to kebab-case. */
+function kebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+/** Truncates a string to the given length, appending a suffix if cut. */
+function truncate(str, length, suffix = '...') {
+    if (str.length <= length)
+        return str;
+    return str.slice(0, length - suffix.length) + suffix;
+}
+/** Removes all HTML tags from a string. */
+function stripHtml(str) {
+    return str.replace(/<[^>]*>/g, '');
+}
+/** Escapes HTML special characters. */
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+/** Unescapes HTML entities back to characters. */
+function unescapeHtml(str) {
+    return str
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#039;/g, "'");
+}
+/** Converts a string to a URL-friendly slug. */
+function toSlug(str) {
+    return str
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-z0-9\s-]/g, '')
+        .trim()
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/** Counts the number of words in a string. */
+function countWords(str) {
+    return str.trim().split(/\s+/).filter(Boolean).length;
+}
+/** Extracts initials from a name (up to `maxLetters`). */
+function initials(name, maxLetters = 2) {
+    return name
+        .split(/\s+/)
+        .slice(0, maxLetters)
+        .map(w => w.charAt(0).toUpperCase())
+        .join('');
+}
+/** Case-insensitive containment check. */
+function contains(str, search) {
+    return str.toLowerCase().includes(search.toLowerCase());
+}
+/**
+ * Replaces `{{key}}` placeholders in a template with values from the map.
+ * @example format('Hello {{name}}', { name: 'World' }) → 'Hello World'
+ */
+function format(template, values) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => key in values ? String(values[key]) : `{{${key}}}`);
+}
+/** Repeats a string `times` times. */
+function repeat(str, times) {
+    return str.repeat(Math.max(0, times));
+}
+/** Reverses the characters of a string. */
+function reverseString(str) {
+    return [...str].reverse().join('');
+}
+/** Counts non-overlapping occurrences of `search` in `str`. */
+function countOccurrences(str, search) {
+    if (!search)
+        return 0;
+    return str.split(search).length - 1;
+}
+/** Removes characters not in `[a-zA-Z0-9]` plus anything in `preserve`. */
+function removeSpecialChars(str, preserve = '') {
+    const escaped = preserve.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    return str.replace(new RegExp(`[^a-zA-Z0-9${escaped}]`, 'g'), '');
+}
+/**
+ * Masks part of a string, keeping `visibleChars` visible at the end.
+ * @example mask('4111111111111234', 4) → '************1234'
+ */
+function mask(str, visibleChars = 4, maskChar = '*') {
+    if (str.length <= visibleChars)
+        return str;
+    return maskChar.repeat(str.length - visibleChars) + str.slice(-visibleChars);
+}
+/** Parses common truthy strings ("true", "yes", "1", "on") to boolean. */
+function toBoolean(str) {
+    return ['true', 'yes', '1', 'on'].includes(str.trim().toLowerCase());
+}
+/** Pads the start of a string. */
+function padStart(str, length, padChar = ' ') {
+    return str.padStart(length, padChar);
+}
+/** Pads the end of a string. */
+function padEnd(str, length, padChar = ' ') {
+    return str.padEnd(length, padChar);
+}
+/** Generates a random alphanumeric string of the given length. */
+function randomString(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+}
+/** Removes all whitespace from a string. */
+function removeWhitespace(str) {
+    return str.replace(/\s+/g, '');
+}
+/** Checks if a string is a palindrome (case- and space-insensitive). */
+function isPalindrome(str) {
+    const normalized = str.toLowerCase().replace(/\s+/g, '');
+    return normalized === [...normalized].reverse().join('');
+}
+/** Wraps a string at `width` characters, splitting on spaces where possible. */
+function wordWrap(str, width) {
+    const words = str.split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if ((current + (current ? ' ' : '') + word).length <= width) {
+            current += (current ? ' ' : '') + word;
+        }
+        else {
+            if (current)
+                lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.join('\n');
+}
+
+var string_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    camelCase: camelCase,
+    capitalize: capitalize,
+    contains: contains,
+    countOccurrences: countOccurrences,
+    countWords: countWords,
+    escapeHtml: escapeHtml,
+    format: format,
+    initials: initials,
+    isBlank: isBlank,
+    isEmpty: isEmpty,
+    isPalindrome: isPalindrome,
+    kebabCase: kebabCase,
+    mask: mask,
+    padEnd: padEnd,
+    padStart: padStart,
+    pascalCase: pascalCase,
+    randomString: randomString,
+    removeSpecialChars: removeSpecialChars,
+    removeWhitespace: removeWhitespace,
+    repeat: repeat,
+    reverseString: reverseString,
+    snakeCase: snakeCase,
+    stripHtml: stripHtml,
+    titleCase: titleCase,
+    toBoolean: toBoolean,
+    toSlug: toSlug,
+    truncate: truncate,
+    unescapeHtml: unescapeHtml,
+    wordWrap: wordWrap
+});
+
+// ─── Validation Utilities ────────────────────────────────────────────────────
+/** Returns true if value is not null, undefined, empty string, or whitespace. */
+function isRequired(value) {
+    if (value == null)
+        return false;
+    if (typeof value === 'string')
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+/** RFC 5322-compliant email validation. */
+function isEmail(value) {
+    return /^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$/.test(value.trim());
+}
+/** Returns true if the string is a valid HTTP/HTTPS URL. */
+function isUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns true if the string looks like a phone number.
+ * Accepts formats: +1-800-555-5555, (800) 555 5555, 08001234567, etc.
+ */
+function isPhone(value) {
+    return /^\+?[\d\s\-().]{7,20}$/.test(value.trim());
+}
+/**
+ * Luhn algorithm — validates credit card numbers.
+ * Works for Visa, MasterCard, Amex, Discover, etc.
+ */
+function isCreditCard(value) {
+    const digits = value.replace(/\D/g, '');
+    if (digits.length < 13 || digits.length > 19)
+        return false;
+    let sum = 0;
+    let isEven = false;
+    for (let i = digits.length - 1; i >= 0; i--) {
+        let digit = parseInt(digits[i], 10);
+        if (isEven) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+        isEven = !isEven;
+    }
+    return sum % 10 === 0;
+}
+/**
+ * Validates postal / ZIP codes.
+ * Supports: US (12345 / 12345-6789), UK (SW1A 1AA), CA (K1A 0B1),
+ * DE/FR/AU/IN (5-digit numeric).
+ */
+function isPostalCode(value, countryCode = 'US') {
+    const patterns = {
+        US: /^\d{5}(-\d{4})?$/,
+        UK: /^[A-Z]{1,2}\d[A-Z\d]?\s?\d[A-Z]{2}$/i,
+        CA: /^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i,
+        DE: /^\d{5}$/,
+        FR: /^\d{5}$/,
+        AU: /^\d{4}$/,
+        IN: /^\d{6}$/,
+    };
+    const pattern = patterns[countryCode.toUpperCase()] ?? /^\d{4,10}$/;
+    return pattern.test(value.trim());
+}
+/** Returns true if the string contains only ASCII letters. */
+function isAlpha(value) {
+    return /^[a-zA-Z]+$/.test(value);
+}
+/** Returns true if the string contains only ASCII letters and digits. */
+function isAlphanumeric(value) {
+    return /^[a-zA-Z0-9]+$/.test(value);
+}
+/** Returns true if the string contains only digits (no decimal points). */
+function isNumeric(value) {
+    return /^\d+$/.test(value.trim());
+}
+/** Returns true if the string represents a valid decimal number. */
+function isDecimal(value) {
+    return /^-?\d+(\.\d+)?$/.test(value.trim());
+}
+/** Returns true if `value` is a positive number (> 0). */
+function isPositive(value) {
+    return value > 0;
+}
+/** Returns true if `value` is a negative number (< 0). */
+function isNegative(value) {
+    return value < 0;
+}
+/** Returns true if the string length is at least `min`. */
+function minLength(value, min) {
+    return value.length >= min;
+}
+/** Returns true if the string length does not exceed `max`. */
+function maxLength(value, max) {
+    return value.length <= max;
+}
+/** Returns true if the string length is within [min, max] (inclusive). */
+function lengthBetween(value, min, max) {
+    return value.length >= min && value.length <= max;
+}
+/** Returns true if `value` is at least `min`. */
+function minValue(value, min) {
+    return value >= min;
+}
+/** Returns true if `value` does not exceed `max`. */
+function maxValue(value, max) {
+    return value <= max;
+}
+/** Returns true if `value` is within [min, max] (inclusive). */
+function inRange(value, min, max) {
+    return value >= min && value <= max;
+}
+/** Returns true if the value is a valid Date or a parseable date string. */
+function isValidDate(value) {
+    if (value == null)
+        return false;
+    const d = new Date(value);
+    return !isNaN(d.getTime());
+}
+/** Returns true if the string is a valid dotted-decimal IPv4 address. */
+function isIPv4(value) {
+    return /^(\d{1,3}\.){3}\d{1,3}$/.test(value) &&
+        value.split('.').every(octet => parseInt(octet, 10) <= 255);
+}
+/** Returns true if the string is a valid IPv6 address. */
+function isIPv6(value) {
+    return /^([\da-f]{1,4}:){7}[\da-f]{1,4}$/i.test(value) ||
+        /^([\da-f]{1,4}:)*::([\da-f]{1,4}:)*[\da-f]{1,4}$/i.test(value) ||
+        value === '::';
+}
+/** Returns true if the string matches the given pattern (string or RegExp). */
+function matchesPattern(value, pattern) {
+    const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+    return regex.test(value);
+}
+/** Returns true if the string is a valid MAC address (with : or - separator). */
+function isMACAddress(value) {
+    return /^([0-9A-Fa-f]{2}[:\-]){5}[0-9A-Fa-f]{2}$/.test(value);
+}
+/** Returns true if the string is a valid CSS hex color (#RGB or #RRGGBB). */
+function isHexColor(value) {
+    return /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(value);
+}
+/**
+ * Returns true if the password meets the given strength requirements.
+ * Default: min 8 chars, at least one uppercase, lowercase, number, and special character.
+ */
+function isStrongPassword(value, options = {}) {
+    const { minLength = 8, requireUppercase = true, requireLowercase = true, requireNumber = true, requireSpecial = true, } = options;
+    if (value.length < minLength)
+        return false;
+    if (requireUppercase && !/[A-Z]/.test(value))
+        return false;
+    if (requireLowercase && !/[a-z]/.test(value))
+        return false;
+    if (requireNumber && !/\d/.test(value))
+        return false;
+    if (requireSpecial && !/[^a-zA-Z0-9]/.test(value))
+        return false;
+    return true;
+}
+/** Returns a password strength score: 0 (very weak) – 5 (very strong). */
+function passwordStrength(value) {
+    let score = 0;
+    if (value.length >= 8)
+        score++;
+    if (value.length >= 12)
+        score++;
+    if (/[A-Z]/.test(value))
+        score++;
+    if (/\d/.test(value))
+        score++;
+    if (/[^a-zA-Z0-9]/.test(value))
+        score++;
+    return score;
+}
+/** Returns true if the two values are strictly equal (useful for confirm-password fields). */
+function isMatch(a, b) {
+    return a === b;
+}
+/** Returns true if the string is a valid JSON string. */
+function isJSON(value) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Returns true if the string contains only printable ASCII characters. */
+function isASCII(value) {
+    return /^[\x20-\x7E]*$/.test(value);
+}
+/** Returns true if the number is a whole integer (no fractional part). */
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+
+var validation_util = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    inRange: inRange,
+    isASCII: isASCII,
+    isAlpha: isAlpha,
+    isAlphanumeric: isAlphanumeric,
+    isCreditCard: isCreditCard,
+    isDecimal: isDecimal,
+    isEmail: isEmail,
+    isHexColor: isHexColor,
+    isIPv4: isIPv4,
+    isIPv6: isIPv6,
+    isInteger: isInteger,
+    isJSON: isJSON,
+    isMACAddress: isMACAddress,
+    isMatch: isMatch,
+    isNegative: isNegative,
+    isNumeric: isNumeric,
+    isPhone: isPhone,
+    isPositive: isPositive,
+    isPostalCode: isPostalCode,
+    isRequired: isRequired,
+    isStrongPassword: isStrongPassword,
+    isUrl: isUrl,
+    isValidDate: isValidDate,
+    lengthBetween: lengthBetween,
+    matchesPattern: matchesPattern,
+    maxLength: maxLength,
+    maxValue: maxValue,
+    minLength: minLength,
+    minValue: minValue,
+    passwordStrength: passwordStrength
+});
+
 /*
  * Public API Surface of osl-base-extended
  */
@@ -2486,5 +4031,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { DeleteConfirmation, DeleteConfirmationData, Dialog, DialogWrapper, DynamicForm, FormStructureModule, Httpbase, OslAutocomplete, OslAutocompleteLister, OslBaseExtended, OslButton, OslCheckbox, OslDatepicker, OslFileUpload, OslFormGrid, OslGrid, OslRadio, OslSearchbar, OslSelect, OslSetup, OslSkeletonDirective, OslSkeletonModule, OslSkeletonThemeService, OslSlideToggle, Oslinput, Osltextarea, baseComponent };
+export { array_util as ArrayUtil, date_util as DateUtil, DeleteConfirmation, DeleteConfirmationData, Dialog, DialogWrapper, DynamicForm, FormStructureModule, Httpbase, number_util as NumberUtil, object_util as ObjectUtil, OslAutocomplete, OslAutocompleteLister, OslBaseExtended, OslButton, OslCheckbox, OslDatepicker, OslFileUpload, OslFormGrid, OslGrid, OslRadio, OslSearchbar, OslSelect, OslSetup, OslSkeletonDirective, OslSkeletonModule, OslSkeletonThemeService, OslSlideToggle, Oslinput, Osltextarea, storage_util as StorageUtil, string_util as StringUtil, validation_util as ValidationUtil, baseComponent };
 //# sourceMappingURL=osl-base-extended.mjs.map