@briza/illogical 2.2.2 → 2.2.3

package/lib/illogical.cjs

@@ -2293,7 +2293,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: right
+      vals: right,
+      operator: 'in'
     };
   }
 
@@ -2309,7 +2310,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: [right]
+      vals: [right],
+      operator: 'eq'
     };
   }
   return null;
@@ -2341,6 +2343,10 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Inverted index: each distinct setA value → merged setB values across all branches containing it
   const setBValsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref1 operand reconstruction)
+  const ref1OpsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref2 operand reconstruction)
+  const ref2OpsByAValue = new Map();
   for (let b = 1; b <= nBranches; b++) {
     const branch = arr[b];
     if (!Array.isArray(branch)) {
@@ -2396,6 +2402,20 @@ function detectOrAndIn2Pattern(arr, state) {
         setBVals = new Set();
         setBValsByAValue.set(aVal, setBVals);
       }
+      // Track ref1 operator
+      let r1Ops = ref1OpsByAValue.get(aVal);
+      if (r1Ops === undefined) {
+        r1Ops = new Set();
+        ref1OpsByAValue.set(aVal, r1Ops);
+      }
+      r1Ops.add(extA.operator);
+      // Track ref2 operator
+      let r2Ops = ref2OpsByAValue.get(aVal);
+      if (r2Ops === undefined) {
+        r2Ops = new Set();
+        ref2OpsByAValue.set(aVal, r2Ops);
+      }
+      r2Ops.add(extB.operator);
       for (const bVal of extB.vals) {
         setBVals.add(bVal);
       }
@@ -2407,14 +2427,25 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Build entries: one (literal aVal, mergedSetBIdx) per distinct setA value
   const entries = [];
+  // Track operators per entry: [ref1Op, ref2Op]
+  const entryOperators = [];
   for (const [aVal, setBVals] of setBValsByAValue) {
     const mergedSetB = [...setBVals].filter(v => v !== undefined);
-    entries.push([aVal, internConst(mergedSetB, state)]);
+    const constIdx = internConst(mergedSetB, state);
+    entries.push([aVal, constIdx]);
+    // Determine ref1 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r1Ops = ref1OpsByAValue.get(aVal);
+    const ref1Op = r1Ops !== undefined && r1Ops.size === 1 && r1Ops.has('eq') ? 'eq' : 'in';
+    // Determine ref2 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r2Ops = ref2OpsByAValue.get(aVal);
+    const ref2Op = r2Ops !== undefined && r2Ops.size === 1 && r2Ops.has('eq') ? 'eq' : 'in';
+    entryOperators.push([ref1Op, ref2Op]);
   }
   return {
     ref1Raw,
     ref2Raw,
-    entries
+    entries,
+    entryOperators
   };
 }
 
@@ -2472,18 +2503,22 @@ function emitExpression(raw, state) {
       const {
         ref1Raw,
         ref2Raw,
-        entries
+        entries,
+        entryOperators
       } = orAnd2;
       const {
         bytecode
       } = state;
       const ref1Idx = internRef(ref1Raw, state);
       const ref2Idx = internRef(ref2Raw, state);
-      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M v0 setBIdx0 v1 setBIdx1 ... vM-1 setBIdxM-1
+      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M (aVal0 setBIdx0 ref1Op0 ref2Op0) ...
       // M is the number of distinct setA values across all branches (after inverted-index merge).
+      // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
       bytecode.push(OP_OR_AND_IN_CONST_2, ref1Idx, ref2Idx, entries.length);
-      for (const [aVal, mergedSetBIdx] of entries) {
-        bytecode.push(aVal, mergedSetBIdx);
+      for (let j = 0; j < entries.length; j++) {
+        const [aVal, mergedSetBIdx] = entries[j];
+        const [ref1Op, ref2Op] = entryOperators[j];
+        bytecode.push(aVal, mergedSetBIdx, ref1Op === 'in' ? 1 : 0, ref2Op === 'in' ? 1 : 0);
       }
       return;
     }
@@ -3215,20 +3250,21 @@ function interpret(compiled, ctx) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, v0, setBIdx0, v1, setBIdx1, ..., vM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M, (v0, setBIdx0, ref1Op0, ref2Op0), (v1, setBIdx1, ref1Op1, ref2Op1), ...
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in' (unused at runtime, kept for simplifier)
           // constSets[setBIdx] is pre-built at first interpret() call — plain Set.has lookup.
           const ref1Idx = numAt$1(bytecode[++i]);
           const ref2Idx = numAt$1(bytecode[++i]);
           const m = numAt$1(bytecode[++i]);
           const entriesStart = i + 1;
-          i += m * 2;
+          i += m * 4;
           const v1 = resolveCompactRef(refs[ref1Idx], ctx);
           const v2 = resolveCompactRef(refs[ref2Idx], ctx);
           let found = false;
           if (v1 !== undefined && v1 !== null && v2 !== undefined && v2 !== null) {
             for (let j = 0; j < m; j++) {
-              if (bytecode[entriesStart + j * 2] === v1) {
-                found = constSets[numAt$1(bytecode[entriesStart + j * 2 + 1])].has(v2);
+              if (bytecode[entriesStart + j * 4] === v1) {
+                found = constSets[numAt$1(bytecode[entriesStart + j * 4 + 1])].has(v2);
                 break;
               }
             }
@@ -4235,13 +4271,15 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, aVal0, setBIdx0, aVal1, setBIdx1, ..., aValM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M, (aVal0, setBIdx0, ref1Op0, ref2Op0),
+          //   (aVal1, setBIdx1, ref1Op1, ref2Op1), ...
           // aVal_j is a literal value; setBIdx_j is a constIdx for the merged setB.
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
           const ref1Idx = numAt(bytecode[i++]);
           const ref2Idx = numAt(bytecode[i++]);
           const n = numAt(bytecode[i++]);
-          const pairsStart = i;
-          i += n * 2;
+          const quadsStart = i;
+          i += n * 4;
           const rawKey1 = refRawKeys[ref1Idx];
           const rawKey2 = refRawKeys[ref2Idx];
           const v1 = resolveCompactRef(refs[ref1Idx], ctx);
@@ -4250,6 +4288,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           const unknown2 = v2 === undefined && !strictSet?.has(rawKey2) && (!optionalSet || optionalSet.has(rawKey2));
           if (unknown1 || unknown2) {
             // Reconstruct the original complex expression tree
+            // When one ref is known, only include entries where the known ref matches
             const branches = [opNames[OP_OR]];
             const andOp = opNames[OP_AND];
             const eqOp = opNames[OP_EQ];
@@ -4257,12 +4296,71 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
             const r1 = refKeys[ref1Idx];
             const r2 = refKeys[ref2Idx];
             for (let j = 0; j < n; j++) {
-              const aVal = literalAt(bytecode[pairsStart + j * 2]);
-              const setB = compiled.consts[numAt(bytecode[pairsStart + j * 2 + 1])];
-              const setInput = setB;
-              branches.push([andOp, [eqOp, r1, aVal], [inOp, r2, setInput]]);
+              const aVal = literalAt(bytecode[quadsStart + j * 4]);
+              const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
+              const ref1OpByte = numAt(bytecode[quadsStart + j * 4 + 2]);
+              const ref2OpByte = numAt(bytecode[quadsStart + j * 4 + 3]);
+              // Use the original operators for both operands
+              const op1 = ref1OpByte === 1 ? inOp : eqOp;
+              const op2 = ref2OpByte === 1 ? inOp : eqOp;
+              // When reconstructing == with a scalar, use the scalar value
+              // When reconstructing IN with a scalar, wrap it in an array
+              const r1Val = op1 === eqOp ? aVal : [aVal];
+              let r2Val = setB;
+              if (op2 === eqOp && Array.isArray(setB) && setB.length === 1) {
+                r2Val = setB[0];
+              }
+              // Skip entries where the known ref doesn't match
+              if (!unknown1 && v1 !== undefined && v1 !== null) {
+                // ref1 is known — only include matching entries
+                // For ==, check exact match; for IN, check if value is in set
+                let matches = false;
+                if (op1 === eqOp) {
+                  matches = v1 === aVal;
+                } else {
+                  matches = Array.isArray(v1) ? v1.includes(aVal) : v1 === aVal;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              if (!unknown2 && v2 !== undefined && v2 !== null) {
+                // ref2 is known — only include matching entries
+                let matches = false;
+                if (op2 === eqOp) {
+                  matches = v2 === r2Val;
+                } else {
+                  // setB is always an array here (it's a compiled const)
+                  matches = Array.isArray(v2) ? setB.some(item => item === v2) : v2 === r2Val;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              // Build the AND branch, omitting known refs that already matched
+              const branchOperands = [];
+              if (unknown1) {
+                branchOperands.push([op1, r1, r1Val]);
+              }
+              if (unknown2) {
+                branchOperands.push([op2, r2, r2Val]);
+              }
+              if (branchOperands.length === 1) {
+                branches.push(branchOperands[0]);
+              } else {
+                branches.push([andOp, ...branchOperands]);
+              }
+            }
+            // Handle edge cases: no matches → false, single match → unwrap OR
+            if (branches.length === 1) {
+              // No entries matched
+              stack[++stackTop] = false;
+            } else if (branches.length === 2) {
+              // Only one entry matched — unwrap the OR
+              stack[++stackTop] = branches[1];
+            } else {
+              stack[++stackTop] = makeResidual(branches);
             }
-            stack[++stackTop] = makeResidual(branches);
             break;
           }
 
@@ -4270,8 +4368,8 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           let found = false;
           if (v1 !== null && v1 !== undefined && v2 !== null && v2 !== undefined) {
             for (let j = 0; j < n; j++) {
-              if (bytecode[pairsStart + j * 2] === v1) {
-                const setB = compiled.consts[numAt(bytecode[pairsStart + j * 2 + 1])];
+              if (bytecode[quadsStart + j * 4] === v1) {
+                const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
                 let s = overlapSetCache.get(setB);
                 if (s === undefined) {
                   s = new Set(setB);

package/lib/illogical.esm.js

@@ -2289,7 +2289,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: right
+      vals: right,
+      operator: 'in'
     };
   }
 
@@ -2305,7 +2306,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: [right]
+      vals: [right],
+      operator: 'eq'
     };
   }
   return null;
@@ -2337,6 +2339,10 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Inverted index: each distinct setA value → merged setB values across all branches containing it
   const setBValsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref1 operand reconstruction)
+  const ref1OpsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref2 operand reconstruction)
+  const ref2OpsByAValue = new Map();
   for (let b = 1; b <= nBranches; b++) {
     const branch = arr[b];
     if (!Array.isArray(branch)) {
@@ -2392,6 +2398,20 @@ function detectOrAndIn2Pattern(arr, state) {
         setBVals = new Set();
         setBValsByAValue.set(aVal, setBVals);
       }
+      // Track ref1 operator
+      let r1Ops = ref1OpsByAValue.get(aVal);
+      if (r1Ops === undefined) {
+        r1Ops = new Set();
+        ref1OpsByAValue.set(aVal, r1Ops);
+      }
+      r1Ops.add(extA.operator);
+      // Track ref2 operator
+      let r2Ops = ref2OpsByAValue.get(aVal);
+      if (r2Ops === undefined) {
+        r2Ops = new Set();
+        ref2OpsByAValue.set(aVal, r2Ops);
+      }
+      r2Ops.add(extB.operator);
       for (const bVal of extB.vals) {
         setBVals.add(bVal);
       }
@@ -2403,14 +2423,25 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Build entries: one (literal aVal, mergedSetBIdx) per distinct setA value
   const entries = [];
+  // Track operators per entry: [ref1Op, ref2Op]
+  const entryOperators = [];
   for (const [aVal, setBVals] of setBValsByAValue) {
     const mergedSetB = [...setBVals].filter(v => v !== undefined);
-    entries.push([aVal, internConst(mergedSetB, state)]);
+    const constIdx = internConst(mergedSetB, state);
+    entries.push([aVal, constIdx]);
+    // Determine ref1 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r1Ops = ref1OpsByAValue.get(aVal);
+    const ref1Op = r1Ops !== undefined && r1Ops.size === 1 && r1Ops.has('eq') ? 'eq' : 'in';
+    // Determine ref2 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r2Ops = ref2OpsByAValue.get(aVal);
+    const ref2Op = r2Ops !== undefined && r2Ops.size === 1 && r2Ops.has('eq') ? 'eq' : 'in';
+    entryOperators.push([ref1Op, ref2Op]);
   }
   return {
     ref1Raw,
     ref2Raw,
-    entries
+    entries,
+    entryOperators
   };
 }
 
@@ -2468,18 +2499,22 @@ function emitExpression(raw, state) {
       const {
         ref1Raw,
         ref2Raw,
-        entries
+        entries,
+        entryOperators
       } = orAnd2;
       const {
         bytecode
       } = state;
       const ref1Idx = internRef(ref1Raw, state);
       const ref2Idx = internRef(ref2Raw, state);
-      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M v0 setBIdx0 v1 setBIdx1 ... vM-1 setBIdxM-1
+      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M (aVal0 setBIdx0 ref1Op0 ref2Op0) ...
       // M is the number of distinct setA values across all branches (after inverted-index merge).
+      // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
       bytecode.push(OP_OR_AND_IN_CONST_2, ref1Idx, ref2Idx, entries.length);
-      for (const [aVal, mergedSetBIdx] of entries) {
-        bytecode.push(aVal, mergedSetBIdx);
+      for (let j = 0; j < entries.length; j++) {
+        const [aVal, mergedSetBIdx] = entries[j];
+        const [ref1Op, ref2Op] = entryOperators[j];
+        bytecode.push(aVal, mergedSetBIdx, ref1Op === 'in' ? 1 : 0, ref2Op === 'in' ? 1 : 0);
       }
       return;
     }
@@ -3211,20 +3246,21 @@ function interpret(compiled, ctx) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, v0, setBIdx0, v1, setBIdx1, ..., vM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M, (v0, setBIdx0, ref1Op0, ref2Op0), (v1, setBIdx1, ref1Op1, ref2Op1), ...
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in' (unused at runtime, kept for simplifier)
           // constSets[setBIdx] is pre-built at first interpret() call — plain Set.has lookup.
           const ref1Idx = numAt$1(bytecode[++i]);
           const ref2Idx = numAt$1(bytecode[++i]);
           const m = numAt$1(bytecode[++i]);
           const entriesStart = i + 1;
-          i += m * 2;
+          i += m * 4;
           const v1 = resolveCompactRef(refs[ref1Idx], ctx);
           const v2 = resolveCompactRef(refs[ref2Idx], ctx);
           let found = false;
           if (v1 !== undefined && v1 !== null && v2 !== undefined && v2 !== null) {
             for (let j = 0; j < m; j++) {
-              if (bytecode[entriesStart + j * 2] === v1) {
-                found = constSets[numAt$1(bytecode[entriesStart + j * 2 + 1])].has(v2);
+              if (bytecode[entriesStart + j * 4] === v1) {
+                found = constSets[numAt$1(bytecode[entriesStart + j * 4 + 1])].has(v2);
                 break;
               }
             }
@@ -4231,13 +4267,15 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, aVal0, setBIdx0, aVal1, setBIdx1, ..., aValM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M, (aVal0, setBIdx0, ref1Op0, ref2Op0),
+          //   (aVal1, setBIdx1, ref1Op1, ref2Op1), ...
           // aVal_j is a literal value; setBIdx_j is a constIdx for the merged setB.
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
           const ref1Idx = numAt(bytecode[i++]);
           const ref2Idx = numAt(bytecode[i++]);
           const n = numAt(bytecode[i++]);
-          const pairsStart = i;
-          i += n * 2;
+          const quadsStart = i;
+          i += n * 4;
           const rawKey1 = refRawKeys[ref1Idx];
           const rawKey2 = refRawKeys[ref2Idx];
           const v1 = resolveCompactRef(refs[ref1Idx], ctx);
@@ -4246,6 +4284,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           const unknown2 = v2 === undefined && !strictSet?.has(rawKey2) && (!optionalSet || optionalSet.has(rawKey2));
           if (unknown1 || unknown2) {
             // Reconstruct the original complex expression tree
+            // When one ref is known, only include entries where the known ref matches
             const branches = [opNames[OP_OR]];
             const andOp = opNames[OP_AND];
             const eqOp = opNames[OP_EQ];
@@ -4253,12 +4292,71 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
             const r1 = refKeys[ref1Idx];
             const r2 = refKeys[ref2Idx];
             for (let j = 0; j < n; j++) {
-              const aVal = literalAt(bytecode[pairsStart + j * 2]);
-              const setB = compiled.consts[numAt(bytecode[pairsStart + j * 2 + 1])];
-              const setInput = setB;
-              branches.push([andOp, [eqOp, r1, aVal], [inOp, r2, setInput]]);
+              const aVal = literalAt(bytecode[quadsStart + j * 4]);
+              const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
+              const ref1OpByte = numAt(bytecode[quadsStart + j * 4 + 2]);
+              const ref2OpByte = numAt(bytecode[quadsStart + j * 4 + 3]);
+              // Use the original operators for both operands
+              const op1 = ref1OpByte === 1 ? inOp : eqOp;
+              const op2 = ref2OpByte === 1 ? inOp : eqOp;
+              // When reconstructing == with a scalar, use the scalar value
+              // When reconstructing IN with a scalar, wrap it in an array
+              const r1Val = op1 === eqOp ? aVal : [aVal];
+              let r2Val = setB;
+              if (op2 === eqOp && Array.isArray(setB) && setB.length === 1) {
+                r2Val = setB[0];
+              }
+              // Skip entries where the known ref doesn't match
+              if (!unknown1 && v1 !== undefined && v1 !== null) {
+                // ref1 is known — only include matching entries
+                // For ==, check exact match; for IN, check if value is in set
+                let matches = false;
+                if (op1 === eqOp) {
+                  matches = v1 === aVal;
+                } else {
+                  matches = Array.isArray(v1) ? v1.includes(aVal) : v1 === aVal;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              if (!unknown2 && v2 !== undefined && v2 !== null) {
+                // ref2 is known — only include matching entries
+                let matches = false;
+                if (op2 === eqOp) {
+                  matches = v2 === r2Val;
+                } else {
+                  // setB is always an array here (it's a compiled const)
+                  matches = Array.isArray(v2) ? setB.some(item => item === v2) : v2 === r2Val;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              // Build the AND branch, omitting known refs that already matched
+              const branchOperands = [];
+              if (unknown1) {
+                branchOperands.push([op1, r1, r1Val]);
+              }
+              if (unknown2) {
+                branchOperands.push([op2, r2, r2Val]);
+              }
+              if (branchOperands.length === 1) {
+                branches.push(branchOperands[0]);
+              } else {
+                branches.push([andOp, ...branchOperands]);
+              }
+            }
+            // Handle edge cases: no matches → false, single match → unwrap OR
+            if (branches.length === 1) {
+              // No entries matched
+              stack[++stackTop] = false;
+            } else if (branches.length === 2) {
+              // Only one entry matched — unwrap the OR
+              stack[++stackTop] = branches[1];
+            } else {
+              stack[++stackTop] = makeResidual(branches);
             }
-            stack[++stackTop] = makeResidual(branches);
             break;
           }
 
@@ -4266,8 +4364,8 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           let found = false;
           if (v1 !== null && v1 !== undefined && v2 !== null && v2 !== undefined) {
             for (let j = 0; j < n; j++) {
-              if (bytecode[pairsStart + j * 2] === v1) {
-                const setB = compiled.consts[numAt(bytecode[pairsStart + j * 2 + 1])];
+              if (bytecode[quadsStart + j * 4] === v1) {
+                const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
                 let s = overlapSetCache.get(setB);
                 if (s === undefined) {
                   s = new Set(setB);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "A micro conditional javascript engine used to parse the raw logical and comparison expressions, evaluate the expression in the given data context, and provide access to a text form of the given expressions.",
   "type": "module",
   "main": "./lib/illogical.cjs",

package/readme.md

@@ -13,11 +13,13 @@
   <strong>illogical</strong> is a JSON DSL (domain-specific language) for expressing and evaluating business rules in the insurance industry. Underwriters use illogical to model business rules for their question sets, enabling distributors to render great user experiences.
   </p>
 
-  [![build status](https://github.com/briza-insurance/illogical/actions/workflows/test.yml/badge.svg)](https://github.com/briza-insurance/illogical/actions?branch=master)
-  [![npm version](https://badge.fury.io/js/@briza%2Fillogical.svg?icon=si%3Anpm)](https://badge.fury.io/js/@briza%2Fillogical)
-  [![install size](https://packagephobia.com/badge?p=@briza/illogical)](https://packagephobia.com/result?p=@briza/illogical)
-  ![zero dependencies](https://img.shields.io/badge/0-dependencies-green)
-  ![npm downloads](https://img.shields.io/npm/dm/%40briza%2Fillogical)
+[![build status](https://github.com/briza-insurance/illogical/actions/workflows/test.yml/badge.svg)](https://github.com/briza-insurance/illogical/actions?branch=master)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/briza-insurance/illogical/badge)](https://scorecard.dev/viewer/?uri=github.com/briza-insurance/illogical)
+[![npm version](https://badge.fury.io/js/@briza%2Fillogical.svg?icon=si%3Anpm)](https://badge.fury.io/js/@briza%2Fillogical)
+[![install size](https://packagephobia.com/badge?p=@briza/illogical)](https://packagephobia.com/result?p=@briza/illogical)
+![zero dependencies](https://img.shields.io/badge/0-dependencies-green)
+![npm downloads](https://img.shields.io/npm/dm/%40briza%2Fillogical)
+
 </div>
 
 ---