@atlaskit/adf-utils 18.0.2 → 18.0.3

package/dist/es2019/validator/validator.js

@@ -1,17 +1,18 @@
 import * as specs from './specs';
 import { copy, isBoolean, isDefined, isInteger, isNumber, isPlainObject, isString, makeArray } from './utils';
 import { validatorFnMap } from './rules';
-
 function mapMarksItems(spec, fn = x => x) {
   if (spec.props && spec.props.marks) {
     const {
       items,
       ...rest
     } = spec.props.marks;
-    return { ...spec,
-      props: { ...spec.props,
-        marks: { ...rest,
-
+    return {
+      ...spec,
+      props: {
+        ...spec.props,
+        marks: {
+          ...rest,
           /**
            * `Text & MarksObject<Mark-1>` produces `items: ['mark-1']`
            * `Text & MarksObject<Mark-1 | Mark-2>` produces `items: [['mark-1', 'mark-2']]`
@@ -24,33 +25,31 @@ function mapMarksItems(spec, fn = x => x) {
     return spec;
   }
 }
-
 const partitionObject = (obj, predicate) => Object.keys(obj).reduce((acc, key) => {
   acc[predicate(key, obj[key], obj) ? 0 : 1].push(key);
   return acc;
 }, [[], []]);
+
 /**
  * Normalizes the structure of files imported form './specs'.
  * We denormalised the spec to save bundle size.
  */
-
-
 function createSpec(nodes, marks) {
   return Object.keys(specs).reduce((newSpecs, k) => {
-    const spec = { ...specs[k]
+    const spec = {
+      ...specs[k]
     };
-
     if (spec.props) {
-      spec.props = { ...spec.props
+      spec.props = {
+        ...spec.props
       };
-
       if (spec.props.content) {
         // 'tableCell_content' => { type: 'array', items: [ ... ] }
         if (isString(spec.props.content)) {
           spec.props.content = specs[spec.props.content];
-        } // ['inline', 'emoji']
-
+        }
 
+        // ['inline', 'emoji']
         if (Array.isArray(spec.props.content)) {
           /**
            * Flatten
@@ -66,15 +65,20 @@ function createSpec(nodes, marks) {
             items: (spec.props.content || []).map(arr => arr.items)
           };
         } else {
-          spec.props.content = { ...spec.props.content
+          spec.props.content = {
+            ...spec.props.content
           };
         }
+        spec.props.content.items = spec.props.content.items
 
-        spec.props.content.items = spec.props.content.items // ['inline'] => [['emoji', 'hr', ...]]
+        // ['inline'] => [['emoji', 'hr', ...]]
         // ['media'] => [['media']]
-        .map(item => isString(item) ? Array.isArray(specs[item]) ? specs[item] : [item] : item) // [['emoji', 'hr', 'inline_code']] => [['emoji', 'hr', ['text', { marks: {} }]]]
-        .map(item => item.map(subItem => Array.isArray(specs[subItem]) ? specs[subItem] : isString(subItem) ? subItem : // Now `NoMark` produces `items: []`, should be fixed in generator
-        ['text', subItem]) // Remove unsupported nodes & marks
+        .map(item => isString(item) ? Array.isArray(specs[item]) ? specs[item] : [item] : item)
+        // [['emoji', 'hr', 'inline_code']] => [['emoji', 'hr', ['text', { marks: {} }]]]
+        .map(item => item.map(subItem => Array.isArray(specs[subItem]) ? specs[subItem] : isString(subItem) ? subItem :
+        // Now `NoMark` produces `items: []`, should be fixed in generator
+        ['text', subItem])
+        // Remove unsupported nodes & marks
         // Filter nodes
         .filter(subItem => {
           if (nodes) {
@@ -82,21 +86,17 @@ function createSpec(nodes, marks) {
             // ['mediaSingle', { props: { content: { items: [ 'media', 'caption' ] } }}]
             if (Array.isArray(subItem)) {
               var _subItem$, _subItem$$props, _subItem$$props$conte;
-
               const isMainNodeSupported = nodes.indexOf(subItem[0]) > -1;
-
               if (isMainNodeSupported && (_subItem$ = subItem[1]) !== null && _subItem$ !== void 0 && (_subItem$$props = _subItem$.props) !== null && _subItem$$props !== void 0 && (_subItem$$props$conte = _subItem$$props.content) !== null && _subItem$$props$conte !== void 0 && _subItem$$props$conte.items) {
                 return subItem[1].props.content.items.every(item => nodes.indexOf(item) > -1);
               }
-
               return isMainNodeSupported;
             }
-
             return nodes.indexOf(subItem) > -1;
           }
-
           return true;
-        }) // Filter marks
+        })
+        // Filter marks
         .map(subItem => Array.isArray(subItem) && marks ?
         /**
          * TODO: Probably try something like immer, but it's 3.3kb gzipped.
@@ -105,83 +105,62 @@ function createSpec(nodes, marks) {
         [subItem[0], mapMarksItems(subItem[1])] : subItem));
       }
     }
-
     newSpecs[k] = spec;
     return newSpecs;
   }, {});
 }
-
 function getOptionsForType(type, list) {
   if (!list) {
     return {};
   }
-
   for (let i = 0, len = list.length; i < len; i++) {
     const spec = list[i];
     let name = spec;
     let options = {};
-
     if (Array.isArray(spec)) {
       [name, options] = spec;
     }
-
     if (name === type) {
       return options;
     }
   }
-
   return false;
 }
-
 export function validateAttrs(spec, value) {
   // extension_node parameters has no type
   if (!isDefined(spec.type)) {
     return !!spec.optional;
   }
-
   if (!isDefined(value)) {
     return !!spec.optional;
   }
-
   switch (spec.type) {
     case 'boolean':
       return isBoolean(value);
-
     case 'number':
       return isNumber(value) && (isDefined(spec.minimum) ? spec.minimum <= value : true) && (isDefined(spec.maximum) ? spec.maximum >= value : true);
-
     case 'integer':
       return isInteger(value) && (isDefined(spec.minimum) ? spec.minimum <= value : true) && (isDefined(spec.maximum) ? spec.maximum >= value : true);
-
     case 'string':
       const validatorFnPassed = rule => typeof value === 'string' && isDefined(validatorFnMap[rule]) && validatorFnMap[rule](value);
-
       return isString(value) && (isDefined(spec.minLength) ? spec.minLength <= value.length : true) && (isDefined(spec.validatorFn) ? validatorFnPassed(spec.validatorFn) : true) && (spec.pattern ? new RegExp(spec.pattern).test(value) : true);
-
     case 'object':
       return isPlainObject(value);
-
     case 'array':
       const types = spec.items;
       const lastTypeIndex = types.length - 1;
-
       if (Array.isArray(value)) {
         // We are doing this to support tuple which can be defined as [number, string]
         // NOTE: Not validating tuples strictly
         return value.every((x, i) => validateAttrs(types[Math.min(i, lastTypeIndex)], x));
       }
-
       return false;
-
     case 'enum':
       return isString(value) && spec.values.indexOf(value) > -1;
   }
-
   return false;
 }
-
 const errorMessageFor = (type, message) => `${type}: ${message}.`;
-
 const getUnsupportedOptions = spec => {
   if (spec && spec.props && spec.props.content) {
     const {
@@ -193,31 +172,28 @@ const getUnsupportedOptions = spec => {
       allowUnsupportedInline
     };
   }
-
   return {};
 };
-
 const invalidChildContent = (child, errorCallback, parentSpec) => {
   const message = errorMessageFor(child.type, 'invalid content');
-
   if (!errorCallback) {
     throw new Error(message);
   } else {
-    return errorCallback({ ...child
+    return errorCallback({
+      ...child
     }, {
       code: 'INVALID_CONTENT',
       message
     }, getUnsupportedOptions(parentSpec));
   }
 };
-
 const unsupportedMarkContent = (errorCode, mark, errorCallback, errorMessage) => {
   const message = errorMessage || errorMessageFor(mark.type, 'unsupported mark');
-
   if (!errorCallback) {
     throw new Error(message);
   } else {
-    return errorCallback({ ...mark
+    return errorCallback({
+      ...mark
     }, {
       code: errorCode,
       message,
@@ -229,7 +205,6 @@ const unsupportedMarkContent = (errorCode, mark, errorCallback, errorMessage) =>
     });
   }
 };
-
 const unsupportedNodeAttributesContent = (entity, errorCode, invalidAttributes, message, errorCallback) => {
   if (!errorCallback) {
     throw new Error(message);
@@ -248,14 +223,12 @@ const unsupportedNodeAttributesContent = (entity, errorCode, invalidAttributes,
     });
   }
 };
-
 export function validator(nodes, marks, options) {
   const validatorSpecs = createSpec(nodes, marks);
   const {
     mode = 'strict',
     allowPrivateAttributes = false
   } = options || {};
-
   const validate = (entity, errorCallback, allowed, parentSpec) => {
     const validationResult = validateNode(entity, errorCallback, allowed, parentSpec);
     return {
@@ -263,17 +236,15 @@ export function validator(nodes, marks, options) {
       valid: validationResult.valid
     };
   };
-
   const validateNode = (entity, errorCallback, allowed, parentSpec, isMark = false) => {
     const {
       type
     } = entity;
-    let newEntity = { ...entity
+    let newEntity = {
+      ...entity
     };
-
     const err = (code, msg, meta) => {
       const message = errorMessageFor(type, msg);
-
       if (errorCallback) {
         return {
           valid: false,
@@ -287,42 +258,32 @@ export function validator(nodes, marks, options) {
         throw new Error(message);
       }
     };
-
     if (type) {
       const typeOptions = getOptionsForType(type, allowed);
-
       if (typeOptions === false) {
         return isMark ? {
           valid: false
         } : err('INVALID_TYPE', 'type not allowed here');
       }
-
       const spec = validatorSpecs[type];
-
       if (!spec) {
         return err('INVALID_TYPE', `${type}: No validation spec found for type!`);
       }
-
       const specBasedValidationResult = specBasedValidationFor(spec, typeOptions, entity, err, newEntity, type, errorCallback, isMark);
-
       if (specBasedValidationResult.hasValidated && specBasedValidationResult.result) {
         return specBasedValidationResult.result;
       }
     } else {
       return err('INVALID_TYPE', 'ProseMirror Node/Mark should contain a `type`');
     }
-
     return {
       valid: true,
       entity: newEntity
     };
   };
-
   return validate;
-
   function marksValidationFor(validator, entity, errorCallback, newEntity, err) {
     let validationResult;
-
     if (validator.props && validator.props.marks) {
       const marksSet = allowedMarksFor(validator);
       const marksValidationResult = marksAfterValidation(entity, errorCallback, marksSet, validator);
@@ -334,37 +295,35 @@ export function validator(nodes, marks, options) {
     } else {
       validationResult = marksForEntitySpecNotSupportingMarks(entity, newEntity, errorCallback, err);
     }
-
     return validationResult;
   }
-
   function validatorFor(spec, typeOptions) {
-    return { ...spec,
+    return {
+      ...spec,
       ...typeOptions,
       // options with props can override props of spec
       ...(spec.props ? {
-        props: { ...spec.props,
+        props: {
+          ...spec.props,
           ...(typeOptions['props'] || {})
         }
       } : {})
     };
   }
-
   function marksAfterValidation(entity, errorCallback, marksSet, validator) {
     return entity.marks ? entity.marks.map(mark => {
       const isAKnownMark = marks ? marks.indexOf(mark.type) > -1 : true;
-
       if (mode === 'strict' && isAKnownMark) {
         const finalResult = validateNode(mark, errorCallback, marksSet, validator, true);
         const finalMark = finalResult.entity;
-
         if (finalMark) {
           return {
             valid: true,
             originalMark: mark,
             newMark: finalMark
           };
-        } // this checks for mark level attribute errors
+        }
+        // this checks for mark level attribute errors
         // and propagates error code and message
         else if (finalResult.marksValidationOutput && finalResult.marksValidationOutput.length) {
           return {
@@ -389,7 +348,6 @@ export function validator(nodes, marks, options) {
       }
     }) : [];
   }
-
   function allowedMarksFor(validator) {
     const {
       items
@@ -397,20 +355,16 @@ export function validator(nodes, marks, options) {
     const marksSet = items.length ? Array.isArray(items[0]) ? items[0] : items : [];
     return marksSet;
   }
-
   function marksForEntitySpecNotSupportingMarks(prevEntity, newEntity, errorCallback, err) {
     const errorCode = 'REDUNDANT_MARKS';
     const currentMarks = prevEntity.marks || [];
     const newMarks = currentMarks.map(mark => {
       const isUnsupportedNodeAttributeMark = mark.type === 'unsupportedNodeAttribute';
-
       if (isUnsupportedNodeAttributeMark) {
         return mark;
       }
-
       return unsupportedMarkContent(errorCode, mark, errorCallback);
     });
-
     if (newMarks.length) {
       newEntity.marks = newMarks;
       return {
@@ -423,50 +377,41 @@ export function validator(nodes, marks, options) {
       });
     }
   }
-
   function requiredPropertyValidationFor(validatorSpec, prevEntity, err) {
     let result = {
       valid: true,
       entity: prevEntity
     };
-
     if (validatorSpec.required) {
       if (!validatorSpec.required.every(prop => isDefined(prevEntity[prop]))) {
         result = err('MISSING_PROPERTIES', 'required prop missing');
       }
     }
-
     return result;
   }
-
   function textPropertyValidationFor(validatorSpec, prevEntity, err) {
     let result = {
       valid: true,
       entity: prevEntity
     };
-
     if (validatorSpec.props.text) {
       if (isDefined(prevEntity.text) && !validateAttrs(validatorSpec.props.text, prevEntity.text)) {
         result = err('INVALID_TEXT', `'text' validation failed`);
       }
     }
-
     return result;
   }
-
   function contentLengthValidationFor(validatorSpec, prevEntity, err) {
     let result = {
       valid: true,
       entity: prevEntity
     };
-
     if (validatorSpec.props.content && prevEntity.content) {
       const {
         minItems,
         maxItems
       } = validatorSpec.props.content;
       const length = prevEntity.content.length;
-
       if (isDefined(minItems) && minItems > length) {
         result = err('INVALID_CONTENT_LENGTH', `'content' should have more than ${minItems} child`, {
           length,
@@ -481,14 +426,11 @@ export function validator(nodes, marks, options) {
         });
       }
     }
-
     return result;
   }
-
   function invalidAttributesFor(validatorSpec, prevEntity) {
     let invalidAttrs = [];
     let validatorAttrs = {};
-
     if (validatorSpec.props && validatorSpec.props.attrs) {
       const attrOptions = makeArray(validatorSpec.props.attrs);
       /**
@@ -496,64 +438,51 @@ export function validator(nodes, marks, options) {
        * attrs: [{ props: { url: { type: 'string' } } }, { props: { data: {} } }],
        * Gotcha: It will always report the last failure.
        */
-
       for (let i = 0, length = attrOptions.length; i < length; ++i) {
         const attrOption = attrOptions[i];
-
         if (attrOption && attrOption.props) {
           [, invalidAttrs] = partitionObject(attrOption.props, (k, v) => {
             return validateAttrs(v, prevEntity.attrs[k]);
           });
         }
-
         validatorAttrs = attrOption;
-
         if (!invalidAttrs.length) {
           break;
         }
       }
     }
-
     return {
       invalidAttrs,
       validatorAttrs
     };
   }
-
   function attributesValidationFor(validatorSpec, prevEntity, newEntity, isMark, errorCallback) {
     const validatorSpecAllowsAttributes = validatorSpec.props && validatorSpec.props.attrs;
-
     if (prevEntity.attrs) {
       if (!validatorSpecAllowsAttributes) {
         if (isMark) {
           return handleNoAttibutesAllowedInSpecForMark(prevEntity, prevEntity.attrs);
         }
-
         const attrs = Object.keys(prevEntity.attrs);
         return handleUnsupportedNodeAttributes(prevEntity, newEntity, [], attrs, errorCallback);
       }
-
       const {
         hasUnsupportedAttrs,
         redundantAttrs,
         invalidAttrs
       } = validateAttributes(validatorSpec, prevEntity, prevEntity.attrs);
-
       if (hasUnsupportedAttrs) {
         if (isMark) {
           return handleUnsupportedMarkAttributes(prevEntity, invalidAttrs, redundantAttrs);
         }
-
         return handleUnsupportedNodeAttributes(prevEntity, newEntity, invalidAttrs, redundantAttrs, errorCallback);
       }
     }
-
     return {
       valid: true,
       entity: prevEntity
     };
   }
-
   function validateAttributes(validatorSpec, prevEntity, attributes) {
     const invalidAttributesResult = invalidAttributesFor(validatorSpec, prevEntity);
     const {
@@ -570,7 +499,6 @@ export function validator(nodes, marks, options) {
       redundantAttrs
     };
   }
-
   function handleUnsupportedNodeAttributes(prevEntity, newEntity, invalidAttrs, redundantAttrs, errorCallback) {
     const attr = invalidAttrs.concat(redundantAttrs);
     let result = {
@@ -586,18 +514,15 @@ export function validator(nodes, marks, options) {
     };
     return result;
   }
-
   function handleUnsupportedMarkAttributes(prevEntity, invalidAttrs, redundantAttrs) {
     let errorCode = 'INVALID_ATTRIBUTES';
     let message = errorMessageFor(prevEntity.type, `'attrs' validation failed`);
     const hasRedundantAttrs = redundantAttrs.length;
     const hasBothInvalidAndRedundantAttrs = hasRedundantAttrs && invalidAttrs.length;
-
     if (!hasBothInvalidAndRedundantAttrs && hasRedundantAttrs) {
       errorCode = 'REDUNDANT_ATTRIBUTES';
       message = errorMessageFor('redundant attributes found', redundantAttrs.join(', '));
     }
-
     const markValidationResult = {
       valid: true,
       originalMark: prevEntity,
@@ -609,7 +534,6 @@ export function validator(nodes, marks, options) {
       marksValidationOutput: [markValidationResult]
     };
   }
-
   function handleNoAttibutesAllowedInSpecForMark(prevEntity, attributes) {
     const message = errorMessageFor('redundant attributes found', Object.keys(attributes).join(', '));
     const errorCode = 'REDUNDANT_ATTRIBUTES';
@@ -624,22 +548,18 @@ export function validator(nodes, marks, options) {
       marksValidationOutput: [markValidationResult]
     };
   }
-
   function wrapUnSupportedNodeAttributes(prevEntity, newEntity, invalidAttrs, errorCode, message, errorCallback) {
     let invalidValues = {};
-
     for (let invalidAttr in invalidAttrs) {
       invalidValues[invalidAttrs[invalidAttr]] = prevEntity.attrs && prevEntity.attrs[invalidAttrs[invalidAttr]];
-
       if (newEntity.attrs) {
         delete newEntity.attrs[invalidAttrs[invalidAttr]];
       }
     }
-
     const unsupportedNodeAttributeValues = unsupportedNodeAttributesContent(prevEntity, errorCode, invalidValues, message, errorCallback);
-    const finalEntity = { ...newEntity
+    const finalEntity = {
+      ...newEntity
     };
-
     if (finalEntity.marks) {
       unsupportedNodeAttributeValues && finalEntity.marks.push(unsupportedNodeAttributeValues);
       return finalEntity.marks;
@@ -647,14 +567,12 @@ export function validator(nodes, marks, options) {
       return [unsupportedNodeAttributeValues];
     }
   }
-
   function extraPropsValidationFor(validatorSpec, prevEntity, err, newEntity, type) {
     let result = {
       valid: true,
       entity: prevEntity
     };
     const [requiredProps, redundantProps] = partitionObject(prevEntity, k => isDefined(validatorSpec.props[k]));
-
     if (redundantProps.length) {
       if (mode === 'loose') {
         newEntity = {
@@ -669,34 +587,29 @@ export function validator(nodes, marks, options) {
         }
       }
     }
-
     return result;
   }
-
   function specBasedValidationFor(spec, typeOptions, prevEntity, err, newEntity, type, errorCallback, isMark) {
     let specBasedValidationResult = {
       hasValidated: false
     };
     const validatorSpec = validatorFor(spec, typeOptions);
-
     if (!validatorSpec) {
       return specBasedValidationResult;
-    } // Required Props
-    // For array format where `required` is an array
-
+    }
 
+    // Required Props
+    // For array format where `required` is an array
     const requiredPropertyValidatonResult = requiredPropertyValidationFor(validatorSpec, prevEntity, err);
-
     if (!requiredPropertyValidatonResult.valid) {
       return {
         hasValidated: true,
         result: requiredPropertyValidatonResult
       };
     }
-
     if (!validatorSpec.props) {
-      const props = Object.keys(prevEntity); // If there's no validator.props then there shouldn't be any key except `type`
-
+      const props = Object.keys(prevEntity);
+      // If there's no validator.props then there shouldn't be any key except `type`
       if (props.length > 1) {
         return {
           hasValidated: true,
@@ -705,34 +618,29 @@ export function validator(nodes, marks, options) {
           })
         };
       }
-
       return specBasedValidationResult;
-    } // Check text
-
+    }
 
+    // Check text
     const textPropertyValidationResult = textPropertyValidationFor(validatorSpec, prevEntity, err);
-
     if (!textPropertyValidationResult.valid) {
       return {
         hasValidated: true,
         result: textPropertyValidationResult
       };
-    } // Content Length
-
-
+    }
+    // Content Length
     const contentLengthValidationResult = contentLengthValidationFor(validatorSpec, prevEntity, err);
-
     if (!contentLengthValidationResult.valid) {
       return {
         hasValidated: true,
         result: contentLengthValidationResult
       };
-    } // Required Props
-    // For object format based on `optional` property
-
+    }
 
+    // Required Props
+    // For object format based on `optional` property
     const [, missingProps] = partitionObject(validatorSpec.props, (k, v) => v.optional || isDefined(prevEntity[k]));
-
     if (missingProps.length) {
       return {
         hasValidated: true,
@@ -741,45 +649,37 @@ export function validator(nodes, marks, options) {
         })
       };
     }
-
     const attributesValidationResult = attributesValidationFor(validatorSpec, prevEntity, newEntity, isMark, errorCallback);
-
     if (!attributesValidationResult.valid) {
       return {
         hasValidated: true,
         result: attributesValidationResult
       };
     }
-
     if (isMark && attributesValidationResult.valid) {
       return {
         hasValidated: true,
         result: attributesValidationResult
       };
     }
-
     const extraPropsValidationResult = extraPropsValidationFor(validatorSpec, prevEntity, err, newEntity, type);
-
     if (!extraPropsValidationResult.valid) {
       return {
         hasValidated: true,
         result: extraPropsValidationResult
       };
-    } // Children
-
+    }
 
+    // Children
     if (validatorSpec.props.content) {
       const contentValidatorSpec = validatorSpec.props.content;
-
       if (prevEntity.content) {
         const validateChildNode = (child, index) => {
           if (child === undefined) {
             return child;
           }
-
           const validateChildMarks = (childEntity, marksValidationOutput, errorCallback, isLastValidationSpec, isParentTupleLike = false) => {
             let marksAreValid = true;
-
             if (childEntity && childEntity.marks && marksValidationOutput) {
               const validMarks = marksValidationOutput.filter(mark => mark.valid);
               const finalMarks = marksValidationOutput.map(mr => {
@@ -789,11 +689,9 @@ export function validator(nodes, marks, options) {
                   if (validMarks.length || isLastValidationSpec || isParentTupleLike || mr.errorCode === 'INVALID_TYPE' || mr.errorCode === 'INVALID_CONTENT' || mr.errorCode === 'REDUNDANT_ATTRIBUTES' || mr.errorCode === 'INVALID_ATTRIBUTES') {
                     return unsupportedMarkContent(mr.errorCode, mr.originalMark, errorCallback, mr.message);
                   }
-
                   return;
                 }
               }).filter(Boolean);
-
               if (finalMarks.length) {
                 childEntity.marks = finalMarks;
               } else {
@@ -801,15 +699,12 @@ export function validator(nodes, marks, options) {
                 marksAreValid = false;
               }
             }
-
             return {
               valid: marksAreValid,
               entity: childEntity
             };
           };
-
           const hasMultipleCombinationOfContentAllowed = !!contentValidatorSpec.isTupleLike;
-
           if (hasMultipleCombinationOfContentAllowed) {
             const {
               entity: newChildEntity,
@@ -819,33 +714,29 @@ export function validator(nodes, marks, options) {
               entity
             } = validateChildMarks(newChildEntity, marksValidationOutput, errorCallback, false, true);
             return entity;
-          } // Only go inside valid branch
-
+          }
 
-          const allowedSpecsForEntity = contentValidatorSpec.items.filter(item => Array.isArray(item) ? item.some( // [p, hr, ...] or [p, [text, {}], ...]
+          // Only go inside valid branch
+          const allowedSpecsForEntity = contentValidatorSpec.items.filter(item => Array.isArray(item) ? item.some(
+          // [p, hr, ...] or [p, [text, {}], ...]
           spec => (Array.isArray(spec) ? spec[0] : spec) === child.type) : true);
-
           if (allowedSpecsForEntity.length) {
             if (allowedSpecsForEntity.length > 1) {
               throw new Error('Consider using Tuple instead!');
             }
-
             const maybeArray = makeArray(allowedSpecsForEntity[0]);
             const allowedSpecsForChild = maybeArray.filter(item => (Array.isArray(item) ? item[0] : item) === child.type);
-
             if (allowedSpecsForChild.length === 0) {
               return invalidChildContent(child, errorCallback, validatorSpec);
             }
+
             /**
              * When there's multiple possible branches try all of them.
              * If all of them fails, throw the first one.
              * e.g.- [['text', { marks: ['a'] }], ['text', { marks: ['b'] }]]
              */
-
-
             let firstError;
             let firstChild;
-
             for (let i = 0, len = allowedSpecsForChild.length; i < len; i++) {
               try {
                 const allowedValueForCurrentSpec = [allowedSpecsForChild[i]];
@@ -854,7 +745,6 @@ export function validator(nodes, marks, options) {
                   entity: newChildEntity,
                   marksValidationOutput
                 } = validateNode(child, errorCallback, allowedValueForCurrentSpec, validatorSpec);
-
                 if (valid) {
                   const isLastValidationSpec = i === allowedSpecsForChild.length - 1;
                   const {
@@ -862,7 +752,6 @@ export function validator(nodes, marks, options) {
                     entity
                   } = validateChildMarks(newChildEntity, marksValidationOutput, errorCallback, isLastValidationSpec);
                   const unsupportedMarks = entity && entity.marks && entity.marks.filter(mark => mark.type === 'unsupportedMark') || [];
-
                   if (marksAreValid && !unsupportedMarks.length) {
                     return entity;
                   } else {
@@ -875,7 +764,6 @@ export function validator(nodes, marks, options) {
                 firstError = firstError || error;
               }
             }
-
             if (!errorCallback) {
               throw firstError;
             } else {
@@ -885,7 +773,6 @@ export function validator(nodes, marks, options) {
             return invalidChildContent(child, errorCallback, validatorSpec);
           }
         };
-
         newEntity.content = prevEntity.content.map(validateChildNode).filter(Boolean);
       } else if (!contentValidatorSpec.optional) {
         return {
@@ -893,16 +780,15 @@ export function validator(nodes, marks, options) {
           result: err('MISSING_PROPERTIES', 'missing `content` prop')
         };
       }
-    } // Marks
-
+    }
 
+    // Marks
     if (prevEntity.marks) {
       return {
         hasValidated: true,
         result: marksValidationFor(validatorSpec, prevEntity, errorCallback, newEntity, err)
       };
     }
-
     return specBasedValidationResult;
   }
 }