@fluixi/utils 1.0.0-alpha.53

package/dist/lib/object/utils.js

@@ -0,0 +1,444 @@
+/**
+ * Checks if a value is an object (not array, function, date, etc.)
+ *
+ * This function determines if a value is a plain JavaScript object by excluding
+ * arrays, functions, and built-in object types like Date, RegExp, Map, etc.
+ *
+ * @param value - The value to check
+ * @returns `true` if value is a plain object; `false` otherwise
+ *
+ * @example
+ * ```ts
+ * isObject({});              // true
+ * isObject({ key: 'value' }); // true
+ *
+ * isObject([]);              // false
+ * isObject(null);            // false
+ * isObject(undefined);       // false
+ * isObject(new Date());      // false
+ * isObject(() => {});        // false
+ * isObject(new Map());       // false
+ * ```
+ *
+ * @category Type Checking
+ * @see isPlainObject - For stricter object type checking
+ */
+export const isObject = (value) => {
+    if (value == null)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    if (typeof value === 'function')
+        return false;
+    if (value instanceof Date)
+        return false;
+    if (value instanceof RegExp)
+        return false;
+    if (value instanceof Map)
+        return false;
+    if (value instanceof Set)
+        return false;
+    if (value instanceof Error)
+        return false;
+    return typeof value === 'object';
+};
+/**
+ * Checks if a value is a plain object (only Object.prototype or null in prototype chain)
+ *
+ * Unlike {@link isObject}, this function performs a stricter check to ensure the value
+ * is a "plain" object - created via object literal `{}` or `Object.create(null)`.
+ * This excludes objects created with custom constructors.
+ *
+ * @template T - The expected object type
+ * @param v - The value to check
+ * @returns `true` if value is a plain object; `false` otherwise
+ *
+ * @example
+ * ```ts
+ * isPlainObject({});                   // true
+ * isPlainObject(Object.create(null));  // true
+ *
+ * class Custom {}
+ * isPlainObject(new Custom());         // false
+ * isPlainObject([]);                   // false
+ * isPlainObject(null);                 // false
+ * ```
+ *
+ * @category Type Checking
+ */
+export function isPlainObject(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Checks if a value is a class constructor
+ *
+ * This function determines if a value is a class constructor by checking
+ * if it's a function and if its string representation starts with the "class" keyword.
+ *
+ * @param obj - The value to check
+ * @returns `true` if value is a class constructor; `false` otherwise
+ *
+ * @example
+ * ```ts
+ * class Example {}
+ * isClass(Example);           // true
+ *
+ * function regularFn() {}
+ * isClass(regularFn);         // false
+ *
+ * const arrowFn = () => {};
+ * isClass(arrowFn);           // false
+ * ```
+ *
+ * @category Type Checking
+ */
+export function isClass(obj) {
+    return (typeof obj === 'function' &&
+        /^class\s/.test(Function.prototype.toString.call(obj)));
+}
+/**
+ * Checks if a value is an empty object
+ *
+ * This function determines if a value is an object with no enumerable properties.
+ * It first checks if the value is an object using {@link isObject} and then
+ * checks if it has any enumerable properties.
+ *
+ * @param value - The value to check
+ * @returns `true` if value is an object with no properties; `false` otherwise
+ *
+ * @example
+ * ```ts
+ * isEmptyObject({});               // true
+ * isEmptyObject(Object.create(null)); // true
+ *
+ * isEmptyObject({a: 1});           // false
+ * isEmptyObject(null);             // false
+ * isEmptyObject([]);               // false (arrays are not objects in this context)
+ * ```
+ *
+ * @category Type Checking
+ * @see isObject - Used internally for type checking
+ */
+export const isEmptyObject = (value) => {
+    if (!isObject(value))
+        return false;
+    return Object.keys(value).length === 0;
+};
+/**
+ * Traverses an object structure based on selector segments
+ *
+ * This advanced utility function traverses a data structure (object or array) based on
+ * a series of selector segments. It preserves the structure of the original data while
+ * navigating through it. The function supports various selector types including property access,
+ * array indexing, wildcards, slices, unions, filters, and recursive descent.
+ *
+ * @param current - The current object/array being traversed
+ * @param segments - An array of selector segments that define the traversal path
+ * @param depth - The current traversal depth (for recursion limits)
+ * @param maxDepth - The maximum depth to traverse (prevents infinite recursion)
+ * @returns The traversed structure or undefined if no match found
+ *
+ * @example
+ * ```ts
+ * // Access nested property with a simple path
+ * const data = { users: [{ name: 'Alice', age: 30 }] };
+ * const segments = [
+ *   { type: 'property', value: 'users' },
+ *   { type: 'index', value: 0 },
+ *   { type: 'property', value: 'name' }
+ * ];
+ * traverseStructure(data, segments, 0, 10); // { users: [{ name: 'Alice' }] }
+ * ```
+ *
+ * @internal
+ * @category Object Traversal
+ */
+export const traverseStructure = (current, segments, depth, maxDepth) => {
+    // console.log('traversing', current)
+    // console.log('traversing segments', segments)
+    if (depth > maxDepth)
+        return undefined;
+    if (segments.length === 0)
+        return current;
+    const segment = segments[0];
+    const remaining = segments.slice(1);
+    // Handle descendant selector
+    if (segment.type === 'descendant') {
+        // Collect all matching paths in structure
+        const result = traverseStructure(current, remaining, depth + 1, maxDepth);
+        if (result !== undefined) {
+            return result;
+        }
+        // Recursively search in all properties
+        if (current && typeof current === 'object') {
+            if (Array.isArray(current)) {
+                const arrResult = [];
+                for (let i = 0; i < current.length; i++) {
+                    const itemResult = traverseStructure(current[i], segments, depth + 1, maxDepth);
+                    if (itemResult !== undefined) {
+                        arrResult[i] = itemResult;
+                    }
+                }
+                return arrResult.length > 0 ? arrResult : undefined;
+            }
+            else {
+                const objResult = {};
+                for (const key in current) {
+                    if (current.hasOwnProperty(key)) {
+                        const itemResult = traverseStructure(current[key], segments, depth + 1, maxDepth);
+                        if (itemResult !== undefined) {
+                            objResult[key] = itemResult;
+                        }
+                    }
+                }
+                return Object.keys(objResult).length > 0 ? objResult : undefined;
+            }
+        }
+        return undefined;
+    }
+    // console.log('is wildcard', segment)
+    // Handle different segment types
+    switch (segment.type) {
+        case 'property':
+            if (isObject(current) &&
+                segment.value &&
+                String(segment.value) in current) {
+                const next = current[String(segment.value)];
+                const result = traverseStructure(next, remaining, depth + 1, maxDepth);
+                if (result !== undefined) {
+                    return { [String(segment.value)]: result };
+                }
+            }
+            break;
+        case 'index':
+            if (Array.isArray(current)) {
+                const index = segment.value;
+                if (index >= 0 && index < current.length) {
+                    const result = traverseStructure(current[index], remaining, depth + 1, maxDepth);
+                    // console.log('res', result)
+                    if (result !== undefined) {
+                        const arr = new Array(current.length).filter((a) => a !== undefined);
+                        arr[index] = result;
+                        return arr;
+                    }
+                }
+            }
+            else if (current && typeof current === 'object') {
+                const key = String(segment.value);
+                if (key in current) {
+                    const result = traverseStructure(current[key], remaining, depth + 1, maxDepth);
+                    if (result !== undefined) {
+                        return { [key]: result };
+                    }
+                }
+            }
+            break;
+        case 'wildcard':
+            if (current && typeof current === 'object') {
+                if (Array.isArray(current)) {
+                    const arrResult = [];
+                    let hasResults = false;
+                    for (let i = 0; i < current.length; i++) {
+                        const result = traverseStructure(current[i], remaining, depth + 1, maxDepth);
+                        if (result !== undefined) {
+                            arrResult[i] = result;
+                            hasResults = true;
+                        }
+                    }
+                    return hasResults ? arrResult : undefined;
+                }
+                else {
+                    const objResult = {};
+                    let hasResults = false;
+                    for (const key in current) {
+                        if (current.hasOwnProperty(key)) {
+                            const result = traverseStructure(current[key], remaining, depth + 1, maxDepth);
+                            if (result !== undefined) {
+                                objResult[key] = result;
+                                hasResults = true;
+                            }
+                        }
+                    }
+                    return hasResults ? objResult : undefined;
+                }
+            }
+            break;
+        case 'slice':
+            if (Array.isArray(current)) {
+                const [start, end] = segment.value;
+                const actualStart = Math.max(0, start);
+                const actualEnd = Math.min(current.length, end === Infinity ? current.length : end);
+                const arrResult = [];
+                let hasResults = false;
+                for (let i = actualStart; i < actualEnd; i++) {
+                    const result = traverseStructure(current[i], remaining, depth + 1, maxDepth);
+                    if (result !== undefined) {
+                        arrResult[i] = result;
+                        hasResults = true;
+                    }
+                }
+                return hasResults ? arrResult : undefined;
+            }
+            break;
+        case 'union':
+            if (Array.isArray(current)) {
+                const indices = segment.value;
+                const arrResult = [];
+                let hasResults = false;
+                for (const index of indices) {
+                    if (index >= 0 && index < current.length) {
+                        const result = traverseStructure(current[index], remaining, depth + 1, maxDepth);
+                        if (result !== undefined) {
+                            arrResult[index] = result;
+                            hasResults = true;
+                        }
+                    }
+                }
+                return hasResults ? arrResult : undefined;
+            }
+            break;
+        case 'filter':
+            if (Array.isArray(current)) {
+                const filterFn = segment.value;
+                const arrResult = [];
+                let hasResults = false;
+                for (let i = 0; i < current.length; i++) {
+                    if (filterFn(current[i])) {
+                        const result = traverseStructure(current[i], remaining, depth + 1, maxDepth);
+                        if (result !== undefined) {
+                            arrResult[i] = result;
+                            hasResults = true;
+                        }
+                    }
+                }
+                return hasResults ? arrResult : undefined;
+            }
+            break;
+    }
+    return undefined;
+};
+/**
+ * Converts a value to a JSON string with improved handling of special cases
+ *
+ * This function converts a JavaScript value to a JSON string, similar to `JSON.stringify`,
+ * but with improved handling of circular references and special character escaping.
+ *
+ * @param value - The value to convert to a JSON string
+ * @param space - The number of spaces to use for indentation (0 for no formatting)
+ * @returns The JSON string representation of the value or undefined for unsupported types
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * toJSONString({ name: 'Alice', age: 30 });
+ * // '{"name":"Alice","age":30}'
+ *
+ * // With formatting
+ * toJSONString({ name: 'Alice', age: 30 }, 2);
+ * // '{
+ * //   "name": "Alice",
+ * //   "age": 30
+ * // }'
+ *
+ * // Handles circular references safely
+ * const circular = { self: null };
+ * circular.self = circular;
+ * toJSONString(circular); // throws TypeError (circular structure)
+ * ```
+ *
+ * @throws {TypeError} When encountering circular references
+ * @category Serialization
+ */
+export function toJSONString(value, space = 0) {
+    const seen = new WeakSet();
+    const gap = (n) => (space ? ' '.repeat(n) : '');
+    const nl = (n) => (space ? `\n${' '.repeat(n)}` : '');
+    const esc = (s) => s.replace(/[\u0000-\u001F"\\]/g, (c) => {
+        switch (c) {
+            case '"':
+                return '\\"';
+            case '\\':
+                return '\\\\';
+            case '\b':
+                return '\\b';
+            case '\f':
+                return '\\f';
+            case '\n':
+                return '\\n';
+            case '\r':
+                return '\\r';
+            case '\t':
+                return '\\t';
+            default:
+                const code = c.charCodeAt(0).toString(16).padStart(4, '0');
+                return `\\u${code}`;
+        }
+    });
+    const ser = (v, indent) => {
+        if (v === null)
+            return 'null';
+        const t = typeof v;
+        if (t === 'number')
+            return Number.isFinite(v) ? String(v) : 'null';
+        if (t === 'boolean')
+            return v ? 'true' : 'false';
+        if (t === 'string') {
+            // if(v.startsWith('icons.')){
+            //     return v
+            // }else{
+            //     return `"${esc(v)}"`
+            // }
+        }
+        if (t === 'bigint')
+            return `"${String(v)}"`;
+        if (t === 'function' || t === 'undefined' || t === 'symbol')
+            return undefined;
+        if (Array.isArray(v)) {
+            if (seen.has(v))
+                throw new TypeError('Converting circular structure to JSON');
+            seen.add(v);
+            const next = indent + space;
+            const parts = v.map((x) => {
+                const s = ser(x, next);
+                return s === undefined ? 'null' : s;
+            });
+            seen.delete(v);
+            if (!space)
+                return `[${parts.join(',')}]`;
+            return `[${nl(next)}${parts.join(`,${nl(next)}`)}${nl(indent)}]`;
+        }
+        if (t === 'object') {
+            if (seen.has(v))
+                throw new TypeError('Converting circular structure to JSON');
+            seen.add(v);
+            const keys = Object.keys(v);
+            const next = indent + space;
+            const parts = [];
+            // const valueOrEsc = (str: string)=>{
+            //     if(str.startsWith('icon.')){
+            //         return str
+            //     }
+            //     return
+            // }
+            for (const k of keys) {
+                const s = ser(v[k], next);
+                if (s !== undefined) {
+                    if (!space)
+                        parts.push(`"${esc(k)}":${s}`);
+                    else
+                        parts.push(`${gap(next)}"${esc(k)}": ${s}`);
+                }
+            }
+            seen.delete(v);
+            if (!space)
+                return `{${parts.join(',')}}`;
+            return `{\n${parts.join(',\n')}\n${gap(indent)}}`;
+        }
+        return undefined;
+    };
+    const out = ser(value, 0);
+    return out === undefined ? undefined : out;
+}

package/dist/lib/object/utils.mjs

@@ -0,0 +1,6 @@
+var A=e=>e==null||Array.isArray(e)||typeof e=="function"||e instanceof Date||e instanceof RegExp||e instanceof Map||e instanceof Set||e instanceof Error?!1:typeof e=="object";function S(e){if(typeof e!="object"||e===null)return!1;let f=Object.getPrototypeOf(e);return f===Object.prototype||f===null}function k(e){return typeof e=="function"&&/^class\s/.test(Function.prototype.toString.call(e))}var O=e=>A(e)?Object.keys(e).length===0:!1,c=(e,f,i,a)=>{if(i>a)return;if(f.length===0)return e;let u=f[0],l=f.slice(1);if(u.type==="descendant"){let s=c(e,l,i+1,a);if(s!==void 0)return s;if(e&&typeof e=="object")if(Array.isArray(e)){let t=[];for(let n=0;n<e.length;n++){let r=c(e[n],f,i+1,a);r!==void 0&&(t[n]=r)}return t.length>0?t:void 0}else{let t={};for(let n in e)if(e.hasOwnProperty(n)){let r=c(e[n],f,i+1,a);r!==void 0&&(t[n]=r)}return Object.keys(t).length>0?t:void 0}return}switch(u.type){case"property":if(A(e)&&u.value&&String(u.value)in e){let s=e[String(u.value)],t=c(s,l,i+1,a);if(t!==void 0)return{[String(u.value)]:t}}break;case"index":if(Array.isArray(e)){let s=u.value;if(s>=0&&s<e.length){let t=c(e[s],l,i+1,a);if(t!==void 0){let n=new Array(e.length).filter(r=>r!==void 0);return n[s]=t,n}}}else if(e&&typeof e=="object"){let s=String(u.value);if(s in e){let t=c(e[s],l,i+1,a);if(t!==void 0)return{[s]:t}}}break;case"wildcard":if(e&&typeof e=="object")if(Array.isArray(e)){let s=[],t=!1;for(let n=0;n<e.length;n++){let r=c(e[n],l,i+1,a);r!==void 0&&(s[n]=r,t=!0)}return t?s:void 0}else{let s={},t=!1;for(let n in e)if(e.hasOwnProperty(n)){let r=c(e[n],l,i+1,a);r!==void 0&&(s[n]=r,t=!0)}return t?s:void 0}break;case"slice":if(Array.isArray(e)){let[s,t]=u.value,n=Math.max(0,s),r=Math.min(e.length,t===1/0?e.length:t),o=[],b=!1;for(let d=n;d<r;d++){let y=c(e[d],l,i+1,a);y!==void 0&&(o[d]=y,b=!0)}return b?o:void 0}break;case"union":if(Array.isArray(e)){let s=u.value,t=[],n=!1;for(let r of s)if(r>=0&&r<e.length){let o=c(e[r],l,i+1,a);o!==void 0&&(t[r]=o,n=!0)}return n?t:void 0}break;case"filter":if(Array.isArray(e)){let s=u.value,t=[],n=!1;for(let r=0;r<e.length;r++)if(s(e[r])){let o=c(e[r],l,i+1,a);o!==void 0&&(t[r]=o,n=!0)}return n?t:void 0}break}};function R(e,f=0){let i=new WeakSet,a=n=>f?" ".repeat(n):"",u=n=>f?`
+${" ".repeat(n)}`:"",l=n=>n.replace(/[\u0000-\u001F"\\]/g,r=>{switch(r){case'"':return'\\"';case"\\":return"\\\\";case"\b":return"\\b";case"\f":return"\\f";case`
+`:return"\\n";case"\r":return"\\r";case"	":return"\\t";default:return`\\u${r.charCodeAt(0).toString(16).padStart(4,"0")}`}}),s=(n,r)=>{if(n===null)return"null";let o=typeof n;if(o==="number")return Number.isFinite(n)?String(n):"null";if(o==="boolean")return n?"true":"false";if(o==="bigint")return`"${String(n)}"`;if(!(o==="function"||o==="undefined"||o==="symbol")){if(Array.isArray(n)){if(i.has(n))throw new TypeError("Converting circular structure to JSON");i.add(n);let b=r+f,d=n.map(y=>{let g=s(y,b);return g===void 0?"null":g});return i.delete(n),f?`[${u(b)}${d.join(`,${u(b)}`)}${u(r)}]`:`[${d.join(",")}]`}if(o==="object"){if(i.has(n))throw new TypeError("Converting circular structure to JSON");i.add(n);let b=Object.keys(n),d=r+f,y=[];for(let g of b){let j=s(n[g],d);j!==void 0&&(f?y.push(`${a(d)}"${l(g)}": ${j}`):y.push(`"${l(g)}":${j}`))}return i.delete(n),f?`{
+${y.join(`,
+`)}
+${a(r)}}`:`{${y.join(",")}}`}}},t=s(e,0);return t===void 0?void 0:t}export{k as isClass,O as isEmptyObject,A as isObject,S as isPlainObject,R as toJSONString,c as traverseStructure};

package/dist/lib/primitive/boolean/boolean.cjs

@@ -0,0 +1 @@
+"use strict";var i=Object.defineProperty;var $=Object.getOwnPropertyDescriptor;var M=Object.getOwnPropertyNames;var q=Object.prototype.hasOwnProperty;var F=(r,e)=>{for(var n in e)i(r,n,{get:e[n],enumerable:!0})},K=(r,e,n,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of M(e))!q.call(r,o)&&o!==n&&i(r,o,{get:()=>e[o],enumerable:!(a=$(e,o))||a.enumerable});return r};var J=r=>K(i({},"__esModule",{value:!0}),r);var W={};F(W,{all:()=>l,any:()=>c,checkConditions:()=>A,compare:()=>b,compareBoolean:()=>R,countFalsy:()=>B,countTruthy:()=>p,createPipeline:()=>E,createToggle:()=>C,debounceBoolean:()=>j,default:()=>U,isBoolean:()=>w,isBooleanArray:()=>L,isBooleanLike:()=>f,isBooleanLikeArray:()=>O,memoizeBoolean:()=>S,nand:()=>g,none:()=>y,nor:()=>k,not:()=>h,randomBoolean:()=>N,safeToBoolean:()=>m,toBoolean:()=>u,validateBooleanConstraint:()=>T,xnor:()=>x,xor:()=>d});module.exports=J(W);var w=r=>r===!0||r===!1,f=r=>{if(r===!0||r===!1||r===0||r===1)return!0;if(typeof r=="string"){let e=r.toLowerCase().trim();return e==="true"||e==="false"||e==="0"||e==="1"}return!1},u=(r,e="strict",n=!1)=>{if(r===null&&e==="strict")throw new Error(`Cannot convert ${r} to boolean with strict strategy`);if(typeof r=="boolean")return r;switch(e){case"strict":return P(r);case"truthy":return!!r;case"falsy":return V(r);case"string":return z(r);case"number":return I(r);default:return!!r}},P=r=>{let e=typeof r=="string"?r.trim().toLowerCase():r;if(e===1||e==="1")return!0;if(e===0||e==="0")return!1;if(typeof e=="string"){let n=e.trim().toLowerCase();if(n==="true")return!0;if(n==="false")return!1;throw new Error(`Cannot convert string "${e}" to boolean with strict strategy`)}if(e===!0)return!0;if(e===!1)return!1;throw new Error(`Cannot convert ${typeof e} to boolean with strict strategy`)},V=r=>{if(typeof r=="string"){let e=r.trim().toLowerCase();return!(e===""||e==="0"||e==="false"||e==="null"||e==="undefined"||e==="nan")}return typeof r=="number"?!(r===0||isNaN(r)):!!r},z=r=>{if(typeof r!="string")throw new Error(`String strategy requires string input, got ${typeof r}`);let e=r.trim().toLowerCase();if(["true","yes","y","on","1","enabled","enable","active"].includes(e))return!0;if(["false","no","n","off","0","disabled","disable","inactive"].includes(e))return!1;if(!isNaN(Number(e)))return Number(e)!==0;throw new Error(`Cannot convert string "${r}" to boolean`)},I=r=>{if(typeof r!="number")throw new Error(`Number strategy requires number input, got ${typeof r}`);return isNaN(r)||r===0?!1:r===1?!0:r!==0},m=(r,e)=>{try{return u(r,"strict")}catch{return e!==void 0?e:!1}},l=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(!e)return!1;return!0},c=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(e)return!0;return!1},y=r=>!c(r),h=r=>!r,d=r=>{if(!Array.isArray(r))return!1;let e=0;for(let n of r)if(n&&(e++,e>1))return!1;return e===1},g=r=>!l(r),k=r=>y(r),x=r=>{if(!Array.isArray(r)||r.length===0)return!0;let e=!!r[0];for(let n=1;n<r.length;n++)if(!!r[n]!==e)return!1;return!0},p=r=>{if(!Array.isArray(r))return 0;let e=0;for(let n of r)n&&e++;return e},B=r=>Array.isArray(r)?r.length-p(r):0,C=(r=!1)=>{let e=r;return()=>(e=!e,e)},b=(r,e,n="===")=>{switch(n){case"==":return r==e;case"===":return r===e;case"!=":return r!=e;case"!==":return r!==e;case">":return r>e;case"<":return r<e;case">=":return r>=e;case"<=":return r<=e;default:throw new Error(`Unsupported operator: ${n}`)}},A=(r,e)=>{for(let n of e)if(!b(r,n.value,n.operator))return!1;return!0},T=(r,e)=>{switch(e){case"required":return r===!0;case"optional":return r===!0||r===!1;case"true":return r===!0;case"false":return r===!1;case"truthy":return!!r;case"falsy":return!r;default:return!1}},N=(r=.5)=>{if(r<0||r>1)throw new Error("Probability must be between 0 and 1");return r===0?!1:Math.random()<=r},j=(r,e)=>{let n,a;return(...o)=>(n&&clearTimeout(n),n=setTimeout(()=>{a=r(...o)},e),a)},S=r=>{let e=new WeakMap;return((...n)=>{let a=null,o="";for(let t=0;t<n.length;t++)if(n[t]!==null&&typeof n[t]=="object"){a=n[t];break}if(o=JSON.stringify(n),a){let t=e.get(a);if(t||(t=new Map,e.set(a,t)),t.has(o))return t.get(o);let s=r(...n);return t.set(o,s),s}else{let t=e.get(Object.prototype)||new Map;if(e.has(Object.prototype)||e.set(Object.prototype,t),t.has(o))return t.get(o);let s=r(...n);return t.set(o,s),s}})},E=r=>e=>{for(let n of r)if(!n(e))return!1;return!0},L=r=>Array.isArray(r)&&r.every(e=>e===!0||e===!1),O=r=>Array.isArray(r)&&r.every(e=>f(e)),R=(r,e)=>{let n=u(r),a=u(e);return n!==a},U={isBoolean:w,isBooleanLike:f,toBoolean:u,safeToBoolean:m,all:l,any:c,none:y,not:h,xor:d,nand:g,nor:k,xnor:x,countTruthy:p,countFalsy:B,createToggle:C,compare:b,checkConditions:A,validateBooleanConstraint:T,randomBoolean:N,debounceBoolean:j,memoizeBoolean:S,createPipeline:E,isBooleanArray:L,isBooleanLikeArray:O};