valgen 5.4.1 → 5.6.0

package/esm/rules/index.js

@@ -1,16 +1,3 @@
-export * from './type-rules/is-any.js';
-export * from './type-rules/is-array.js';
-export * from './type-rules/is-bigint.js';
-export * from './type-rules/is-boolean.js';
-export * from './type-rules/is-date.js';
-export * from './type-rules/is-enum.js';
-export * from './type-rules/is-integer.js';
-export * from './type-rules/is-null.js';
-export * from './type-rules/is-number.js';
-export * from './type-rules/is-object.js';
-export * from './type-rules/is-record.js';
-export * from './type-rules/is-string.js';
-export * from './type-rules/is-tuple.js';
 export * from './format-rules/is-alpha.js';
 export * from './format-rules/is-ascii.js';
 export * from './format-rules/is-base64.js';
@@ -41,6 +28,20 @@ export * from './format-rules/matches.js';
 export * from './logical-rules/is-defined.js';
 export * from './logical-rules/is-empty.js';
 export * from './logical-rules/range.js';
+export * from './type-rules/is-any.js';
+export * from './type-rules/is-array.js';
+export * from './type-rules/is-bigint.js';
+export * from './type-rules/is-boolean.js';
+export * from './type-rules/is-date.js';
+export * from './type-rules/is-enum.js';
+export * from './type-rules/is-integer.js';
+export * from './type-rules/is-null.js';
+export * from './type-rules/is-number.js';
+export * from './type-rules/is-object.js';
+export * from './type-rules/is-record.js';
+export * from './type-rules/is-string.js';
+export * from './type-rules/is-tuple.js';
+export * from './type-rules/is-undefined.js';
 export * from './utility-rules/exists.js';
 export * from './utility-rules/get-length.js';
 export * from './utility-rules/optional.js';

package/esm/rules/logical-rules/is-defined.js

@@ -4,22 +4,9 @@ import { validator } from '../../core/index.js';
  * @validator isDefined
  */
 export function isDefined(options) {
-    return validator('is-defined', function (input, context, _this) {
+    return validator('is-defined', (input, context, _this) => {
         if (input !== undefined)
             return input;
         context.fail(_this, `Is not defined`, input);
     }, options);
 }
-/**
- * Validates if value is "undefined"
- * @validator isUndefined
- */
-export function isUndefined(options) {
-    return validator('isUndefined', function (input, context, _this) {
-        if (options?.coerce || context.coerce)
-            return undefined;
-        if (input === undefined)
-            return;
-        context.fail(_this, `{{label}} mustn\'t be defined`, input);
-    }, options);
-}

package/esm/rules/logical-rules/is-empty.js

@@ -4,7 +4,7 @@ import { validator } from '../../core/index.js';
  * @validator isEmpty
  */
 export function isEmpty(options) {
-    return validator('isEmpty', function (input, context, _this) {
+    return validator('isEmpty', (input, context, _this) => {
         if (input == null)
             return input;
         if (typeof input === 'string') {
@@ -40,7 +40,7 @@ export function isEmpty(options) {
  * @validator isNotEmpty
  */
 export function isNotEmpty(options) {
-    return validator('isNotEmpty', function (input, context, _this) {
+    return validator('isNotEmpty', (input, context, _this) => {
         if (input != null) {
             if (typeof input === 'string') {
                 if (input)

package/esm/rules/logical-rules/range.js

@@ -1,4 +1,4 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 import { getLength } from '../utility-rules/get-length.js';
 import { allOf, pipe } from '../utility-rules/pipe.js';
 /**
@@ -6,85 +6,116 @@ import { allOf, pipe } from '../utility-rules/pipe.js';
  * @validator range
  */
 export function range(minValue, maxValue, options) {
-    return validator('range', function (input, context, _this) {
+    return validator('range', (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input >= minValue &&
-            input <= maxValue)
+            input <= maxValue) {
             return input;
+        }
         if (minValue instanceof Date &&
             maxValue instanceof Date &&
             input instanceof Date &&
             input >= minValue &&
-            input <= maxValue)
+            input <= maxValue) {
             return input;
+        }
         if (typeof minValue === 'string' &&
             typeof maxValue === 'string' &&
             typeof input === 'string' &&
             input >= minValue &&
-            input <= maxValue)
+            input <= maxValue) {
             return input;
+        }
         context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
     }, options);
 }
 export function isGt(minValue, options) {
-    return validator('isGt', function (input, context, _this) {
+    return validator('isGt', (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
-            input > minValue)
+            input > minValue) {
             return input;
-        if (minValue instanceof Date && input instanceof Date && input > minValue)
+        }
+        if (minValue instanceof Date &&
+            input instanceof Date &&
+            input > minValue) {
             return input;
+        }
         if (typeof minValue === 'string' &&
             typeof input === 'string' &&
-            (input > minValue || (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
+            (input > minValue ||
+                (options?.caseInsensitive &&
+                    input.toLowerCase() > minValue.toLowerCase()))) {
             return input;
+        }
         context.fail(_this, `{{label}} must be greater than ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
 export function isGte(minValue, options) {
-    return validator('isGte', function (input, context, _this) {
+    return validator('isGte', (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
-            input >= minValue)
+            input >= minValue) {
             return input;
-        if (minValue instanceof Date && input instanceof Date && input >= minValue)
+        }
+        if (minValue instanceof Date &&
+            input instanceof Date &&
+            input >= minValue) {
             return input;
+        }
         if (typeof minValue === 'string' &&
             typeof input === 'string' &&
-            (input >= minValue || (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
+            (input >= minValue ||
+                (options?.caseInsensitive &&
+                    input.toLowerCase() >= minValue.toLowerCase()))) {
             return input;
+        }
         context.fail(_this, `{{label}} must be greater than or equal to ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
 export function isLt(maxValue, options) {
-    return validator('isLt', function (input, context, _this) {
+    return validator('isLt', (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
-            input < maxValue)
+            input < maxValue) {
             return input;
-        if (maxValue instanceof Date && input instanceof Date && input < maxValue)
+        }
+        if (maxValue instanceof Date &&
+            input instanceof Date &&
+            input < maxValue) {
             return input;
+        }
         if (typeof maxValue === 'string' &&
             typeof input === 'string' &&
-            (input < maxValue || (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
+            (input < maxValue ||
+                (options?.caseInsensitive &&
+                    input.toLowerCase() < maxValue.toLowerCase()))) {
             return input;
+        }
         context.fail(_this, `{{label}} must be lover than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }
 export function isLte(maxValue, options) {
-    return validator('isLte', function (input, context, _this) {
+    return validator('isLte', (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
-            input <= maxValue)
+            input <= maxValue) {
             return input;
-        if (maxValue instanceof Date && input instanceof Date && input <= maxValue)
+        }
+        if (maxValue instanceof Date &&
+            input instanceof Date &&
+            input <= maxValue) {
             return input;
+        }
         if (typeof maxValue === 'string' &&
             typeof input === 'string' &&
-            (input <= maxValue || (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
+            (input <= maxValue ||
+                (options?.caseInsensitive &&
+                    input.toLowerCase() <= maxValue.toLowerCase()))) {
             return input;
+        }
         context.fail(_this, `{{label}} must be lover than or equal to ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }

package/esm/rules/type-rules/is-any.js

@@ -3,6 +3,4 @@ import { validator } from '../../core/index.js';
  * Does nothing, just returns original input value.
  * @validator isAny
  */
-export const isAny = () => validator('is-any', function (input) {
-    return input;
-});
+export const isAny = () => validator('is-any', (input) => input);

package/esm/rules/type-rules/is-array.js

@@ -1,11 +1,11 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "array" and applies validation for each item.
  * Converts input value to array if coerce option is set to 'true'.
  * @validator isArray
  */
 export function isArray(itemValidator, options) {
-    return validator('isArray', function (input, context, _this) {
+    return validator('isArray', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))
@@ -26,7 +26,9 @@ export function isArray(itemValidator, options) {
             v = output[i];
             itemContext.scope = output;
             // itemContext.location = location + '[' + i + ']';
-            itemContext.location = context.location ? context.location + `[${i}]` : `<Array>[${i}]`;
+            itemContext.location = context.location
+                ? context.location + `[${i}]`
+                : `<Array>[${i}]`;
             itemContext.index = i;
             v = itemValidator(v, itemContext);
             out.push(v);

package/esm/rules/type-rules/is-bigint.js

@@ -5,12 +5,14 @@ import { validator } from '../../core/index.js';
  * @validator isNumber
  */
 export function isBigint(options) {
-    return validator('isBigint', function (input, context, _this) {
+    return validator('isBigint', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         if (typeof input === 'bigint')
             return input;
-        if ((typeof input === 'number' && !isNaN(input)) || (typeof input === 'string' && coerce))
+        if ((typeof input === 'number' && !isNaN(input)) ||
+            (typeof input === 'string' && coerce)) {
             return BigInt(input);
+        }
         const t = typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid BigInt value`, input);
     }, options);

package/esm/rules/type-rules/is-boolean.js

@@ -1,4 +1,4 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 const TRUE_PATTERN = /^true|t|1|yes|y$/i;
 const FALSE_PATTERN = /^false|f|0|no|n$/i;
 /**
@@ -7,7 +7,7 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  * @validator isBoolean
  */
 export function isBoolean(options) {
-    return validator('isBoolean', function (input, context, _this) {
+    return validator('isBoolean', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'boolean' && coerce) {

package/esm/rules/type-rules/is-date.js

@@ -11,7 +11,7 @@ const DATE_PATTERN =
  */
 export function isDate(options) {
     const precision = options?.precision;
-    return validator('isDate', function (input, context, _this) {
+    return validator('isDate', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let d;
         if (input instanceof Date)
@@ -36,7 +36,9 @@ export function isDate(options) {
                 d.setHours(0, 0, 0, 0);
             return d;
         }
-        context.fail(_this, `"{{value}}" is not a valid date value`, input, { ...options });
+        context.fail(_this, `"{{value}}" is not a valid date value`, input, {
+            ...options,
+        });
     }, options);
 }
 /**
@@ -47,7 +49,7 @@ export function isDate(options) {
 export function isDateString(options) {
     const precision = options?.precision;
     const trim = options?.trim;
-    return validator('isDateString', function (input, context, _this) {
+    return validator('isDateString', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         if (typeof input === 'string') {
             const m = DATE_PATTERN.exec(input);
@@ -83,8 +85,12 @@ export function isDateString(options) {
             }
         }
         else if (input instanceof Date) {
-            return trim === 'date' ? formatISO(input, { representation: 'date' }) : formatISO(input).substring(0, 19);
+            return trim === 'date'
+                ? formatISO(input, { representation: 'date' })
+                : formatISO(input).substring(0, 19);
         }
-        context.fail(_this, `"{{value}}" is not a valid date string`, input, { ...options });
+        context.fail(_this, `"{{value}}" is not a valid date string`, input, {
+            ...options,
+        });
     }, options);
 }

package/esm/rules/type-rules/is-enum.js

@@ -1,4 +1,4 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Validates if given value is one of enum values.
  * @validator isEnum
@@ -14,9 +14,13 @@ export function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return validator('isEnum', function (input, context, _this) {
-        if (input != null && valObj[typeof input === 'string' && caseInSensitive ? input.toUpperCase() : input])
+    return validator('isEnum', (input, context, _this) => {
+        if (input != null &&
+            valObj[typeof input === 'string' && caseInSensitive
+                ? input.toUpperCase()
+                : input]) {
             return input;
+        }
         context.fail(_this, `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`, input, {
             enum: enumName,
         });

package/esm/rules/type-rules/is-integer.js

@@ -1,11 +1,11 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "integer".
  * Converts input value to integer number if coerce option is set to 'true'.
  * @validator isInteger
  */
 export function isInteger(options) {
-    return validator('isInteger', function (input, context, _this) {
+    return validator('isInteger', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {
@@ -17,9 +17,16 @@ export function isInteger(options) {
                     input = output;
             }
         }
-        if (typeof output === 'number' && !isNaN(output) && Number.isInteger(output))
+        if (typeof output === 'number' &&
+            !isNaN(output) &&
+            Number.isInteger(output)) {
             return output;
-        const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
+        }
+        const t = typeof input === 'bigint'
+            ? 'BigInt '
+            : typeof input === 'string'
+                ? 'String '
+                : '';
         context.fail(_this, `${t}"{{value}}" is not a valid integer value`, input);
     }, options);
 }

package/esm/rules/type-rules/is-null.js

@@ -4,26 +4,45 @@ import { validator } from '../../core/index.js';
  * @validator isNull
  */
 export function isNull(options) {
-    return validator('isNull', function (input, context, _this) {
+    return validator('isNull', (input, context, _this) => {
         if (input === null)
             return input;
-        const coerce = options?.coerce || context.coerce;
-        if (coerce)
-            return null;
-        context.fail(_this, `"{{value}}" is not null`, input);
+        context.fail(_this, `{{label}} is not null`, input);
+    }, options);
+}
+/**
+ * Validates if value is not "null".
+ * @validator isNotNull
+ */
+export function isNotNull(options) {
+    return validator('isNotNull', (input, context, _this) => {
+        if (input !== null)
+            return input;
+        context.fail(_this, `{{label}} is null`, input);
     }, options);
 }
 /**
  * Validates if value is "null" or "undefined".
- * @validator isNull
+ * @validator isNullish
  */
 export function isNullish(options) {
-    return validator('isNullish', function (input, context, _this) {
+    return validator('isNullish', (input, context, _this) => {
         if (input == null)
             return input;
-        const coerce = options?.coerce || context.coerce;
-        if (coerce)
-            return null;
-        context.fail(_this, `"{{value}}" is not nullish`, input);
+        context.fail(_this, `{{label}} is not nullish`, input);
+    }, options);
+}
+/**
+ * Validates if value is not "null" nor "undefined".
+ * @validator isNotNullish
+ */
+export function isNotNullish(options) {
+    return validator('isNotNullish', (input, context, _this) => {
+        if (input != null)
+            return input;
+        if (input === null)
+            context.fail(_this, `{{label}} is null`, input);
+        else
+            context.fail(_this, `{{label}} is undefined`, input);
     }, options);
 }

package/esm/rules/type-rules/is-number.js

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isNumber
  */
 export function isNumber(options) {
-    return validator('isNumber', function (input, context, _this) {
+    return validator('isNumber', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {
@@ -19,7 +19,11 @@ export function isNumber(options) {
         }
         if (typeof output === 'number' && !isNaN(output))
             return output;
-        const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
+        const t = typeof input === 'bigint'
+            ? 'BigInt '
+            : typeof input === 'string'
+                ? 'String '
+                : '';
         context.fail(_this, `${t}"{{value}}" is not a valid number value`, input);
     }, options);
 }

package/esm/rules/type-rules/is-object.js

@@ -19,8 +19,9 @@ export function isObject(schema, options) {
         const n = schema[k];
         const key = caseInSensitive ? k.toLowerCase() : k;
         if (Array.isArray(n)) {
-            if (!isValidator(n[0]))
+            if (!isValidator(n[0])) {
                 throw new TypeError(`Invalid tuple definition in validation schema (${k})`);
+            }
             propertyRules[key] = n[0];
             propertyOptions[key] = { as: k, ...n[1] };
         }
@@ -28,18 +29,20 @@ export function isObject(schema, options) {
             propertyRules[key] = n;
             propertyOptions[key] = { as: k };
         }
-        else
+        else {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
+        }
     }
-    const _rule = validator('isObject', function (input, context, _this) {
+    const _rule = validator('isObject', (input, context, _this) => {
         let output = input;
-        if (ctor && ctor[preValidation])
+        if (ctor && ctor[preValidation]) {
             output = ctor[preValidation](output, context, _this);
+        }
         const coerce = options?.coerce || context.coerce;
         if (typeof output === 'string' && coerce)
             output = JSON.parse(output);
         if (!(output && typeof output === 'object')) {
-            context.fail(_this, `{{label}} must be an object`, input);
+            context.fail(_this, `"{{value}}" is not an object`, input);
             return;
         }
         const keys = [...Object.keys(output), ...schemaKeys];
@@ -54,8 +57,9 @@ export function isObject(schema, options) {
             Object.setPrototypeOf(out, ctor.prototype);
         if (detectCircular) {
             context.circMap = context.circMap || new Map();
-            if (context.circMap.has(output))
+            if (context.circMap.has(output)) {
                 return context.circMap.get(output);
+            }
             context.circMap.set(output, out);
         }
         if (context.root == null)
@@ -67,7 +71,9 @@ export function isObject(schema, options) {
             inputKey = keys[i];
             schemaKey = caseInSensitive ? inputKey.toLowerCase() : inputKey;
             v = output[inputKey];
-            _propRule = propertyRules[schemaKey] || (isValidator(additionalFields) ? additionalFields : undefined);
+            _propRule =
+                propertyRules[schemaKey] ||
+                    (isValidator(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
@@ -77,18 +83,21 @@ export function isObject(schema, options) {
                 subCtx.context = ctorName;
                 subCtx.location = location + (location ? '.' : '') + schemaKey;
                 subCtx.property = schemaKey;
-                if (propertyOptions[schemaKey]?.label)
+                if (propertyOptions[schemaKey]?.label) {
                     subCtx.label = propertyOptions[schemaKey]?.label;
+                }
                 v = _propRule(v, subCtx);
             }
             else if (v !== undefined) {
                 if (!additionalFields)
                     continue;
-                if (additionalFields === 'error')
+                if (additionalFields === 'error') {
                     context.fail(_propRule, `${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`, v);
+                }
             }
-            if (v !== undefined)
+            if (v !== undefined) {
                 out[propertyOptions[schemaKey]?.as || schemaKey] = v;
+            }
         }
         if (context.errors.length)
             return undefined;

package/esm/rules/type-rules/is-record.js

@@ -1,11 +1,11 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Validates record object according to given "key" and "value" rules
  * Converts properties according to rules if coerce option is set to 'true'.
  * @validator isRecord
  */
 export function isRecord(keyRule, valueRule, options) {
-    return validator('isRecord', function (input, context, _this) {
+    return validator('isRecord', (input, context, _this) => {
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
             return;

package/esm/rules/type-rules/is-string.js

@@ -1,11 +1,11 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "string".
  * Converts input value to string if coerce option is set to 'true'.
  * @validator isString
  */
 export function isString(options) {
-    return validator('isString', function (input, context, _this) {
+    return validator('isString', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'string' && coerce) {
@@ -24,14 +24,14 @@ export function isString(options) {
     }, options);
 }
 export function stringReplace(searchValue, replacer) {
-    return validator('stringReplace', function (input) {
+    return validator('stringReplace', (input) => {
         if (input == null)
             return input;
         return String(input).replace(searchValue, replacer);
     });
 }
 export function stringSplit(splitter, limit) {
-    return validator('stringSplit', function (input) {
+    return validator('stringSplit', (input) => {
         if (input == null)
             return input;
         return String(input).split(splitter, limit);
@@ -42,7 +42,7 @@ export function stringSplit(splitter, limit) {
  * @validator trim
  */
 export function trim() {
-    return validator('trim', function (input) {
+    return validator('trim', (input) => {
         if (input == null)
             return input;
         return String(input).trim();
@@ -54,7 +54,7 @@ export function trim() {
  * @validator trimEnd
  */
 export const trimEnd = () => trimEndRule;
-const trimEndRule = validator('trimEnd', function (input) {
+const trimEndRule = validator('trimEnd', (input) => {
     if (input == null)
         return input;
     return String(input).trimEnd();
@@ -65,7 +65,7 @@ const trimEndRule = validator('trimEnd', function (input) {
  * @validator trimStart
  */
 export const trimStart = () => trimStartRule;
-const trimStartRule = validator('trimStart', function (input) {
+const trimStartRule = validator('trimStart', (input) => {
     if (input == null)
         return input;
     return String(input).trimStart();

package/esm/rules/type-rules/is-tuple.js

@@ -1,6 +1,6 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 export function isTuple(items, options) {
-    return validator('isTuple', function (input, context, _this) {
+    return validator('isTuple', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))
@@ -20,10 +20,13 @@ export function isTuple(items, options) {
         for (i = 0; i < l && i < nl; i++) {
             itemRule = items[i];
             itemContext.scope = output;
-            itemContext.label = context.label ? context.label + `[${i}]` : undefined;
+            itemContext.label = context.label
+                ? context.label + `[${i}]`
+                : undefined;
             itemContext.index = i;
             itemContext.location = location + '[' + i + ']';
-            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
+            itemContext.label =
+                (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
             v = itemRule(output[i], itemContext);
             out.push(v);
         }