@legalplace/lplogic 2.3.2 → 2.3.4

package/.gitlab-automator

@@ -1,7 +1,7 @@
-GITLAB_PRIVATE_TOKEN=glpat-2LLXVHzUViBmoVAUPBzy
+GITLAB_PRIVATE_TOKEN=glpat-BOv5W1i6MoAAvHjzkmc5nW86MQp1OjkH.01.0w119catf
 GITLAB_BASE_URL=https://git.legalplace.eu
 GITLAB_API_PROJECT_ID=28
 GITLAB_USER_ID=9
 CURRENT_PROJECT_ID=39
 SLACK_USER_ID=U0B3SNBV3
-CLICKUP_PRIVATE_TOKEN=pk_32519579_FSGO0KOHXZ93NPCODYRPIWHWG12Y4G3A
+CLICKUP_PRIVATE_TOKEN=pk_32519579_K5W4L4KEVXY03A3D2WFA46D07HVGTL5L

package/dist/LpLogic.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var json_logic_js_1 = __importDefault(require("@legalplace/json-logic-js"));
 var reduceParents = function (parents, length) {
     var reducedParents = [];
-    parents.sort(function (a, b) { return b.length - a.length; });
+    var safeParents = parents.filter(function (entry) { return Array.isArray(entry); });
+    safeParents.sort(function (a, b) { return b.length - a.length; });
     var _loop_1 = function (index) {
-        var currentIndexResult = parents.reduce(function (previousValue, currentValue) {
+        var currentIndexResult = safeParents.reduce(function (previousValue, currentValue) {
             if (currentValue.length === 1)
                 return previousValue && currentValue[0];
             if (currentValue[index] === undefined)
@@ -23,7 +24,7 @@ var reduceParents = function (parents, length) {
     return reducedParents;
 };
 var reduceValues = function (values, parents, compareFunction) {
-    if (parents === undefined || parents.length === 0) {
+    if (!Array.isArray(parents) || parents.length === 0) {
         return values.map(function (currentValue) {
             return compareFunction(currentValue, true);
         });
@@ -40,10 +41,25 @@ var parseNumber = function (value) {
         return parseFloat(value.replace(",", "."));
     return value;
 };
+var cleanString = function (value) {
+    var raw = typeof value === "number" ? value.toString() : value.trim();
+    return raw
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/œ/g, "oe")
+        .replace(/Œ/g, "oe")
+        .replace(/æ/g, "ae")
+        .replace(/Æ/g, "ae")
+        .toLowerCase();
+};
 var safeEqual = function (value, comparator) {
     var parsedValue = typeof value === "number" ? value : parseNumber(value);
     var parsedComparator = typeof comparator === "number" ? comparator : parseNumber(comparator);
-    return parsedValue === parsedComparator;
+    if (typeof parsedValue === "number" &&
+        typeof parsedComparator === "number") {
+        return parsedValue === parsedComparator;
+    }
+    return cleanString(value) === cleanString(comparator);
 };
 json_logic_js_1.default.add_operation("=", function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
@@ -129,13 +145,7 @@ json_logic_js_1.default.add_operation("has-many", function (values, comparator,
 });
 var is = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return cleanValue === cleanComparator && parent;
+        return cleanString(value) === cleanString(comparator) && parent;
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
@@ -143,13 +153,7 @@ var is = function (values, comparator, parents) {
 json_logic_js_1.default.add_operation("is", is);
 var not = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return cleanValue !== cleanComparator && parent;
+        return cleanString(value) !== cleanString(comparator) && parent;
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
@@ -158,21 +162,11 @@ json_logic_js_1.default.add_operation("not", not);
 var contains = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
         if (Array.isArray(value)) {
-            return value.some(function (val) {
-                return (typeof val === "string" ? val.trim() : val.toString())
-                    .toLowerCase()
-                    .includes((typeof comparator === "string"
-                    ? comparator.trim()
-                    : comparator.toString()).toLowerCase()) && parent;
-            });
-        }
-        else {
-            var cleanValue = (typeof value === "number" ? value.toString() : value.trim()).toLowerCase();
-            var cleanComparator = (typeof comparator === "number"
-                ? comparator.toString()
-                : comparator.trim()).toLowerCase();
-            return cleanValue.includes(cleanComparator) && parent;
+            return (value.some(function (val) {
+                return cleanString(val).includes(cleanString(comparator));
+            }) && parent);
         }
+        return (cleanString(value).includes(cleanString(comparator)) && parent);
     });
     var filter = reducedValues.filter(function (value) { return value === true; });
     return reducedValues.length === filter.length;
@@ -181,21 +175,9 @@ json_logic_js_1.default.add_operation("contains", contains);
 var doesNotContain = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
         if (Array.isArray(value)) {
-            return value.every(function (val) {
-                return !(typeof val === "string" ? val.trim() : val.toString())
-                    .toLowerCase()
-                    .includes((typeof comparator === "string"
-                    ? comparator.trim()
-                    : comparator.toString()).toLowerCase()) && parent;
-            });
-        }
-        else {
-            var cleanValue = (typeof value === "number" ? value.toString() : value.trim()).toLowerCase();
-            var cleanComparator = (typeof comparator === "number"
-                ? comparator.toString()
-                : comparator.trim()).toLowerCase();
-            return !cleanValue.includes(cleanComparator) && parent;
+            return (value.every(function (val) { return !cleanString(val).includes(cleanString(comparator)); }) && parent);
         }
+        return (!cleanString(value).includes(cleanString(comparator)) && parent);
     });
     var filter = reducedValues.filter(function (value) { return value === true; });
     return reducedValues.length === filter.length;
@@ -219,13 +201,7 @@ json_logic_js_1.default.add_operation("not-empty", function (values, comparator,
 });
 var like = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return (new RegExp("( |^)".concat(cleanComparator, "( |$)"), "i").test(cleanValue) && parent);
+        return (new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent);
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
@@ -233,14 +209,7 @@ var like = function (values, comparator, parents) {
 json_logic_js_1.default.add_operation("like", like);
 var notLike = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return (!new RegExp("( |^)".concat(cleanComparator, "( |$)"), "i").test(cleanValue) &&
-            parent);
+        return (!new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent);
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
@@ -270,5 +239,105 @@ var regexMatch = function (values, comparator, parents) {
     return reducedValues.length === filter.length;
 };
 json_logic_js_1.default.add_operation("regex-match", regexMatch);
+var aggregateAny = function (reducedValues) {
+    return reducedValues.includes(true);
+};
+var aggregateFirst = function (reducedValues) {
+    return reducedValues[0] === true;
+};
+var registerScopedBooleanOp = function (baseName, compareFn) {
+    json_logic_js_1.default.add_operation("".concat(baseName, "-first"), function (values, _comparator, parents) {
+        var reducedValue = reduceValues(values, parents, compareFn);
+        return aggregateFirst(reducedValue);
+    });
+    json_logic_js_1.default.add_operation("".concat(baseName, "-any"), function (values, _comparator, parents) {
+        var reducedValue = reduceValues(values, parents, compareFn);
+        return aggregateAny(reducedValue);
+    });
+};
+registerScopedBooleanOp("selected", function (value, parent) { return value && parent; });
+registerScopedBooleanOp("not-selected", function (value, parent) { return !value && parent; });
+var conditionMet = function (value, parent) {
+    return value === true && parent;
+};
+var conditionNotMet = function (value, parent) {
+    return value !== true && parent;
+};
+json_logic_js_1.default.add_operation("conditions-met", function (values, comparator, parents) {
+    return reduceValues(values, parents, conditionMet).every(function (value) { return value === true; });
+});
+json_logic_js_1.default.add_operation("conditions-not-met", function (values, comparator, parents) {
+    return reduceValues(values, parents, conditionNotMet).every(function (value) { return value === true; });
+});
+registerScopedBooleanOp("conditions-met", conditionMet);
+registerScopedBooleanOp("conditions-not-met", conditionNotMet);
+var registerScopedComparisonOp = function (baseName, compareFn) {
+    json_logic_js_1.default.add_operation("".concat(baseName, "-any"), function (values, comparator, parents) {
+        var reducedValues = reduceValues(values, parents, function (value, parent) {
+            return compareFn(value, comparator, parent);
+        });
+        return aggregateAny(reducedValues);
+    });
+    json_logic_js_1.default.add_operation("".concat(baseName, "-first"), function (values, comparator, parents) {
+        var reducedValues = reduceValues(values, parents, function (value, parent) {
+            return compareFn(value, comparator, parent);
+        });
+        return aggregateFirst(reducedValues);
+    });
+};
+registerScopedComparisonOp("=", function (value, comparator, parent) {
+    return safeEqual(value, comparator) && parent;
+});
+registerScopedComparisonOp("<>", function (value, comparator, parent) {
+    return !safeEqual(value, comparator) && parent;
+});
+registerScopedComparisonOp("==", function (value, comparator, parent) {
+    return parseNumber(value) === parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp(">=", function (value, comparator, parent) {
+    return parseNumber(value) >= parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp("<=", function (value, comparator, parent) {
+    return parseNumber(value) <= parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp(">", function (value, comparator, parent) {
+    return parseNumber(value) > parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp("<", function (value, comparator, parent) {
+    return parseNumber(value) < parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp("is", function (value, comparator, parent) {
+    return cleanString(value) === cleanString(comparator) && parent;
+});
+registerScopedComparisonOp("not", function (value, comparator, parent) {
+    return cleanString(value) !== cleanString(comparator) && parent;
+});
+registerScopedComparisonOp("contains", function (value, comparator, parent) {
+    return cleanString(value).includes(cleanString(comparator)) && parent;
+});
+registerScopedComparisonOp("does-not-contain", function (value, comparator, parent) {
+    return !cleanString(value).includes(cleanString(comparator)) && parent;
+});
+registerScopedComparisonOp("like", function (value, comparator, parent) {
+    return new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent;
+});
+registerScopedComparisonOp("not-like", function (value, comparator, parent) {
+    return !new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent;
+});
+registerScopedComparisonOp("regex-match", function (value, comparator, parent) {
+    if (typeof comparator !== "string")
+        return false;
+    var regex;
+    try {
+        regex = new RegExp(comparator);
+    }
+    catch (error) {
+        return false;
+    }
+    var stringValue = typeof value === "number" ? value.toString() : value;
+    return regex.test(stringValue) && parent;
+});
+registerScopedComparisonOp("empty", function (value, _comparator, parent) { return cleanString(value).length === 0 && parent; });
+registerScopedComparisonOp("not-empty", function (value, _comparator, parent) { return cleanString(value).length > 0 && parent; });
 var LpLogic = json_logic_js_1.default.apply;
 exports.default = LpLogic;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/lplogic",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "LegalPlace LpLogic",
   "main": "dist/index.js",
   "scripts": {

package/tests/LpLogic.test.ts

@@ -129,3 +129,242 @@ test('Testing "not-like" Bye on a value `Hello world`', async () => {
 test('Testing "not-like" World on a value `Hello world`', async () => {
   expect( LpLogic({"not-like":[{"var":"v.1"}, "World"]}, {"v":{"1":["Hello world"]}}) ).toBe(false)
 })
+
+test('Testing "selected-first" on first occurrence only', async () => {
+  expect(LpLogic({"selected-first":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})).toBe(true)
+  expect(LpLogic({"selected-first":[{"var":"o.1"}]}, {"o":{"1":[false, true]}})).toBe(false)
+})
+
+test('Testing "=-any" on multiple values', async () => {
+  expect(LpLogic({"=-any":[{"var":"v.1"}, "a"]}, {"v":{"1":["a", "b"]}})).toBe(true)
+  expect(LpLogic({"=-any":[{"var":"v.1"}, "a"]}, {"v":{"1":["b", "c"]}})).toBe(false)
+})
+
+/**
+ * empty-any / not-empty-any cover occurrence scope "at least one" for emptiness checks.
+ */
+test('Testing "empty-any" on multiple values', async () => {
+  expect(LpLogic({"empty-any":[{"var":"v.1"}]}, {"v":{"1":["", "x"]}})).toBe(true)
+  expect(LpLogic({"empty-any":[{"var":"v.1"}]}, {"v":{"1":["x", "y"]}})).toBe(false)
+})
+
+test('Testing "empty-first" on multiple values', async () => {
+  expect(LpLogic({"empty-first":[{"var":"v.1"}]}, {"v":{"1":["", "x"]}})).toBe(true)
+  expect(LpLogic({"empty-first":[{"var":"v.1"}]}, {"v":{"1":["x", ""]}})).toBe(false)
+})
+
+test('Testing "not-empty-any" on multiple values', async () => {
+  expect(LpLogic({"not-empty-any":[{"var":"v.1"}]}, {"v":{"1":["", "x"]}})).toBe(true)
+  expect(LpLogic({"not-empty-any":[{"var":"v.1"}]}, {"v":{"1":["", ""]}})).toBe(false)
+})
+
+test('Testing "=-first" on multiple values', async () => {
+  expect(LpLogic({"=-first":[{"var":"v.1"}, "a"]}, {"v":{"1":["a", "b"]}})).toBe(true)
+  expect(LpLogic({"=-first":[{"var":"v.1"}, "a"]}, {"v":{"1":["b", "a"]}})).toBe(false)
+})
+
+test('Testing "conditions-met" without parents', async () => {
+  expect(
+    LpLogic({"conditions-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, true]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, false]}}})
+  ).toBe(false)
+})
+
+test('Testing "conditions-met" with parents', async () => {
+  expect(
+    LpLogic(
+      {"conditions-met":[{"var":"c.o.2"}, undefined, [{"var":"o.1"}]]},
+      {"c":{"o":{"2":[true, true]}}, "o":{"1":[true, true]}}
+    )
+  ).toBe(true)
+  expect(
+    LpLogic(
+      {"conditions-met":[{"var":"c.o.2"}, undefined, [{"var":"o.1"}]]},
+      {"c":{"o":{"2":[true, true]}}, "o":{"1":[true, false]}}
+    )
+  ).toBe(false)
+})
+
+test('Testing "conditions-met-first" on first occurrence only', async () => {
+  expect(
+    LpLogic({"conditions-met-first":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, false]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-met-first":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, true]}}})
+  ).toBe(false)
+})
+
+test('Testing "conditions-met-any" on multiple values', async () => {
+  expect(
+    LpLogic({"conditions-met-any":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, true]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-met-any":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, false]}}})
+  ).toBe(false)
+})
+
+test('Testing "conditions-not-met"', async () => {
+  expect(
+    LpLogic({"conditions-not-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, false]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-not-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, false]}}})
+  ).toBe(false)
+})
+
+/**
+ * Regression: when a condition tree containing `undefined` parents is passed
+ * through any JSON serialization (e.g. Redux DevTools), `undefined` becomes
+ * `null` (`JSON.stringify([a, undefined])` → `'[a,null]'`). LpLogic must
+ * treat a `null` parents arg as "no parents" instead of throwing on
+ * `null.length`.
+ */
+test('Testing "conditions-met" with null parents (JSON round-trip safety)', async () => {
+  expect(
+    LpLogic(
+      { "conditions-met": [{ var: "c.o.1" }, null, null] },
+      { "c": { "o": { "1": [true, true] } } }
+    )
+  ).toBe(true)
+  expect(
+    LpLogic(
+      { "conditions-met-first": [{ var: "c.o.1" }, null, null] },
+      { "c": { "o": { "1": [true, false] } } }
+    )
+  ).toBe(true)
+})
+
+test('Testing "selected" with null parents (JSON round-trip safety)', async () => {
+  expect(
+    LpLogic(
+      { "selected": [{ var: "o.1" }, null, null] },
+      { "o": { "1": [true, true] } }
+    )
+  ).toBe(true)
+})
+
+test('Testing "conditions-met" with parents containing missing refs (null entries)', async () => {
+  // `{ var: "o.999" }` resolves to `null` because `o.999` is absent from data.
+  // Parents array is `[null]`; LpLogic must not throw.
+  expect(
+    LpLogic(
+      { "conditions-met": [{ var: "c.o.1" }, undefined, [{ var: "o.999" }]] },
+      { "c": { "o": { "1": [true] } } }
+    )
+  ).toBe(true)
+})
+
+/**
+ * Accent- and case-insensitive text matching (=, contains, like and negations).
+ * Matches the product table: la/lax, la/la ha, la/là, la/La, Léon/Leon.
+ */
+test('Testing "=" case-insensitive for strings', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["La"] } })).toBe(
+    true
+  )
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["LA"] } })).toBe(
+    true
+  )
+})
+
+test('Testing "=" accent-insensitive for strings', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })).toBe(
+    true
+  )
+  expect(
+    LpLogic({ "=": [{ var: "v.1" }, "Léon"] }, { v: { 1: ["Leon"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ "=": [{ var: "v.1" }, "Léon"] }, { v: { 1: ["LEON"] } })
+  ).toBe(true)
+})
+
+test('Testing "=" still false for different words', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })).toBe(
+    false
+  )
+  expect(
+    LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["la ha"] } })
+  ).toBe(false)
+})
+
+test('Testing "=" still numeric for number-like values', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "1.0"] }, { v: { 1: [1] } })).toBe(
+    true
+  )
+  expect(LpLogic({ "=": [{ var: "v.1" }, 1] }, { v: { 1: ["1"] } })).toBe(true)
+})
+
+test('Testing "<>" is inverse of accent/case-insensitive "="', async () => {
+  expect(LpLogic({ "<>": [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })).toBe(
+    false
+  )
+  expect(LpLogic({ "<>": [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })).toBe(
+    true
+  )
+})
+
+test('Testing "contains" accent- and case-insensitive', async () => {
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["la ha"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["La"] } })
+  ).toBe(true)
+})
+
+test('Testing "does-not-contain" is inverse of accent-insensitive contains', async () => {
+  expect(
+    LpLogic(
+      { "does-not-contain": [{ var: "v.1" }, "la"] },
+      { v: { 1: ["là"] } }
+    )
+  ).toBe(false)
+  expect(
+    LpLogic(
+      { "does-not-contain": [{ var: "v.1" }, "la"] },
+      { v: { 1: ["Bye"] } }
+    )
+  ).toBe(true)
+})
+
+test('Testing "like" accent- and case-insensitive word match', async () => {
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })
+  ).toBe(false)
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["la ha"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["La"] } })
+  ).toBe(true)
+})
+
+test('Testing "not-like" is inverse of accent-insensitive like', async () => {
+  expect(
+    LpLogic({ "not-like": [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })
+  ).toBe(false)
+  expect(
+    LpLogic({ "not-like": [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })
+  ).toBe(true)
+})
+
+test('Testing "is" accent-insensitive (legacy equal alias)', async () => {
+  expect(LpLogic({ is: [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })).toBe(
+    true
+  )
+  expect(
+    LpLogic({ is: [{ var: "v.1" }, "Léon"] }, { v: { 1: ["Leon"] } })
+  ).toBe(true)
+})