@atlaskit/adf-utils 18.0.2 → 18.0.4

package/dist/esm/validator/validator.js

@@ -2,25 +2,19 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 var _excluded = ["items"];
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 import * as specs from './specs';
 import { copy, isBoolean, isDefined, isInteger, isNumber, isPlainObject, isString, makeArray } from './utils';
 import { validatorFnMap } from './rules';
-
 function mapMarksItems(spec) {
   var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
     return x;
   };
-
   if (spec.props && spec.props.marks) {
     var _ref = spec.props.marks,
-        items = _ref.items,
-        rest = _objectWithoutProperties(_ref, _excluded);
-
+      items = _ref.items,
+      rest = _objectWithoutProperties(_ref, _excluded);
     return _objectSpread(_objectSpread({}, spec), {}, {
       props: _objectSpread(_objectSpread({}, spec.props), {}, {
         marks: _objectSpread(_objectSpread({}, rest), {}, {
@@ -36,33 +30,29 @@ function mapMarksItems(spec) {
     return spec;
   }
 }
-
 var partitionObject = function partitionObject(obj, predicate) {
   return Object.keys(obj).reduce(function (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(function (newSpecs, k) {
     var spec = _objectSpread({}, specs[k]);
-
     if (spec.props) {
       spec.props = _objectSpread({}, 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
@@ -82,17 +72,21 @@ function createSpec(nodes, marks) {
         } else {
           spec.props.content = _objectSpread({}, 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(function (item) {
           return isString(item) ? Array.isArray(specs[item]) ? specs[item] : [item] : item;
-        }) // [['emoji', 'hr', 'inline_code']] => [['emoji', 'hr', ['text', { marks: {} }]]]
+        })
+        // [['emoji', 'hr', 'inline_code']] => [['emoji', 'hr', ['text', { marks: {} }]]]
         .map(function (item) {
           return item.map(function (subItem) {
-            return Array.isArray(specs[subItem]) ? specs[subItem] : isString(subItem) ? subItem : // Now `NoMark` produces `items: []`, should be fixed in generator
+            return Array.isArray(specs[subItem]) ? specs[subItem] : isString(subItem) ? subItem :
+            // Now `NoMark` produces `items: []`, should be fixed in generator
             ['text', subItem];
-          }) // Remove unsupported nodes & marks
+          })
+          // Remove unsupported nodes & marks
           // Filter nodes
           .filter(function (subItem) {
             if (nodes) {
@@ -100,23 +94,19 @@ function createSpec(nodes, marks) {
               // ['mediaSingle', { props: { content: { items: [ 'media', 'caption' ] } }}]
               if (Array.isArray(subItem)) {
                 var _subItem$, _subItem$$props, _subItem$$props$conte;
-
                 var 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(function (item) {
                     return nodes.indexOf(item) > -1;
                   });
                 }
-
                 return isMainNodeSupported;
               }
-
               return nodes.indexOf(subItem) > -1;
             }
-
             return true;
-          }) // Filter marks
+          })
+          // Filter marks
           .map(function (subItem) {
             return Array.isArray(subItem) && marks ?
             /**
@@ -128,71 +118,54 @@ function createSpec(nodes, marks) {
         });
       }
     }
-
     newSpecs[k] = spec;
     return newSpecs;
   }, {});
 }
-
 function getOptionsForType(type, list) {
   if (!list) {
     return {};
   }
-
   for (var i = 0, len = list.length; i < len; i++) {
     var spec = list[i];
     var _name = spec;
     var options = {};
-
     if (Array.isArray(spec)) {
       var _spec = _slicedToArray(spec, 2);
-
       _name = _spec[0];
       options = _spec[1];
     }
-
     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':
       var validatorFnPassed = function validatorFnPassed(rule) {
         return 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':
       var types = spec.items;
       var 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
@@ -200,37 +173,29 @@ export function validateAttrs(spec, value) {
           return validateAttrs(types[Math.min(i, lastTypeIndex)], x);
         });
       }
-
       return false;
-
     case 'enum':
       return isString(value) && spec.values.indexOf(value) > -1;
   }
-
   return false;
 }
-
 var errorMessageFor = function errorMessageFor(type, message) {
   return "".concat(type, ": ").concat(message, ".");
 };
-
 var getUnsupportedOptions = function getUnsupportedOptions(spec) {
   if (spec && spec.props && spec.props.content) {
     var _spec$props$content = spec.props.content,
-        allowUnsupportedBlock = _spec$props$content.allowUnsupportedBlock,
-        allowUnsupportedInline = _spec$props$content.allowUnsupportedInline;
+      allowUnsupportedBlock = _spec$props$content.allowUnsupportedBlock,
+      allowUnsupportedInline = _spec$props$content.allowUnsupportedInline;
     return {
       allowUnsupportedBlock: allowUnsupportedBlock,
       allowUnsupportedInline: allowUnsupportedInline
     };
   }
-
   return {};
 };
-
 var invalidChildContent = function invalidChildContent(child, errorCallback, parentSpec) {
   var message = errorMessageFor(child.type, 'invalid content');
-
   if (!errorCallback) {
     throw new Error(message);
   } else {
@@ -240,10 +205,8 @@ var invalidChildContent = function invalidChildContent(child, errorCallback, par
     }, getUnsupportedOptions(parentSpec));
   }
 };
-
 var unsupportedMarkContent = function unsupportedMarkContent(errorCode, mark, errorCallback, errorMessage) {
   var message = errorMessage || errorMessageFor(mark.type, 'unsupported mark');
-
   if (!errorCallback) {
     throw new Error(message);
   } else {
@@ -258,7 +221,6 @@ var unsupportedMarkContent = function unsupportedMarkContent(errorCode, mark, er
     });
   }
 };
-
 var unsupportedNodeAttributesContent = function unsupportedNodeAttributesContent(entity, errorCode, invalidAttributes, message, errorCallback) {
   if (!errorCallback) {
     throw new Error(message);
@@ -277,16 +239,13 @@ var unsupportedNodeAttributesContent = function unsupportedNodeAttributesContent
     });
   }
 };
-
 export function validator(nodes, marks, options) {
   var validatorSpecs = createSpec(nodes, marks);
-
   var _ref2 = options || {},
-      _ref2$mode = _ref2.mode,
-      mode = _ref2$mode === void 0 ? 'strict' : _ref2$mode,
-      _ref2$allowPrivateAtt = _ref2.allowPrivateAttributes,
-      allowPrivateAttributes = _ref2$allowPrivateAtt === void 0 ? false : _ref2$allowPrivateAtt;
-
+    _ref2$mode = _ref2.mode,
+    mode = _ref2$mode === void 0 ? 'strict' : _ref2$mode,
+    _ref2$allowPrivateAtt = _ref2.allowPrivateAttributes,
+    allowPrivateAttributes = _ref2$allowPrivateAtt === void 0 ? false : _ref2$allowPrivateAtt;
   var validate = function validate(entity, errorCallback, allowed, parentSpec) {
     var validationResult = validateNode(entity, errorCallback, allowed, parentSpec);
     return {
@@ -294,16 +253,12 @@ export function validator(nodes, marks, options) {
       valid: validationResult.valid
     };
   };
-
   var validateNode = function validateNode(entity, errorCallback, allowed, parentSpec) {
     var isMark = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
     var type = entity.type;
-
     var newEntity = _objectSpread({}, entity);
-
     var err = function err(code, msg, meta) {
       var message = errorMessageFor(type, msg);
-
       if (errorCallback) {
         return {
           valid: false,
@@ -317,42 +272,32 @@ export function validator(nodes, marks, options) {
         throw new Error(message);
       }
     };
-
     if (type) {
       var typeOptions = getOptionsForType(type, allowed);
-
       if (typeOptions === false) {
         return isMark ? {
           valid: false
         } : err('INVALID_TYPE', 'type not allowed here');
       }
-
       var spec = validatorSpecs[type];
-
       if (!spec) {
         return err('INVALID_TYPE', "".concat(type, ": No validation spec found for type!"));
       }
-
       var 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) {
     var validationResult;
-
     if (validator.props && validator.props.marks) {
       var marksSet = allowedMarksFor(validator);
       var marksValidationResult = marksAfterValidation(entity, errorCallback, marksSet, validator);
@@ -364,31 +309,27 @@ export function validator(nodes, marks, options) {
     } else {
       validationResult = marksForEntitySpecNotSupportingMarks(entity, newEntity, errorCallback, err);
     }
-
     return validationResult;
   }
-
   function validatorFor(spec, typeOptions) {
     return _objectSpread(_objectSpread(_objectSpread({}, spec), typeOptions), spec.props ? {
       props: _objectSpread(_objectSpread({}, spec.props), typeOptions['props'] || {})
     } : {});
   }
-
   function marksAfterValidation(entity, errorCallback, marksSet, validator) {
     return entity.marks ? entity.marks.map(function (mark) {
       var isAKnownMark = marks ? marks.indexOf(mark.type) > -1 : true;
-
       if (mode === 'strict' && isAKnownMark) {
         var finalResult = validateNode(mark, errorCallback, marksSet, validator, true);
         var 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 {
@@ -413,27 +354,22 @@ export function validator(nodes, marks, options) {
       }
     }) : [];
   }
-
   function allowedMarksFor(validator) {
     var _ref3 = validator.props.marks,
-        items = _ref3.items;
+      items = _ref3.items;
     var marksSet = items.length ? Array.isArray(items[0]) ? items[0] : items : [];
     return marksSet;
   }
-
   function marksForEntitySpecNotSupportingMarks(prevEntity, newEntity, errorCallback, err) {
     var errorCode = 'REDUNDANT_MARKS';
     var currentMarks = prevEntity.marks || [];
     var newMarks = currentMarks.map(function (mark) {
       var isUnsupportedNodeAttributeMark = mark.type === 'unsupportedNodeAttribute';
-
       if (isUnsupportedNodeAttributeMark) {
         return mark;
       }
-
       return unsupportedMarkContent(errorCode, mark, errorCallback);
     });
-
     if (newMarks.length) {
       newEntity.marks = newMarks;
       return {
@@ -446,13 +382,11 @@ export function validator(nodes, marks, options) {
       });
     }
   }
-
   function requiredPropertyValidationFor(validatorSpec, prevEntity, err) {
     var result = {
       valid: true,
       entity: prevEntity
     };
-
     if (validatorSpec.required) {
       if (!validatorSpec.required.every(function (prop) {
         return isDefined(prevEntity[prop]);
@@ -460,37 +394,30 @@ export function validator(nodes, marks, options) {
         result = err('MISSING_PROPERTIES', 'required prop missing');
       }
     }
-
     return result;
   }
-
   function textPropertyValidationFor(validatorSpec, prevEntity, err) {
     var 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) {
     var result = {
       valid: true,
       entity: prevEntity
     };
-
     if (validatorSpec.props.content && prevEntity.content) {
       var _content = validatorSpec.props.content,
-          minItems = _content.minItems,
-          maxItems = _content.maxItems;
+        minItems = _content.minItems,
+        maxItems = _content.maxItems;
       var length = prevEntity.content.length;
-
       if (isDefined(minItems) && minItems > length) {
         result = err('INVALID_CONTENT_LENGTH', "'content' should have more than ".concat(minItems, " child"), {
           length: length,
@@ -505,14 +432,11 @@ export function validator(nodes, marks, options) {
         });
       }
     }
-
     return result;
   }
-
   function invalidAttributesFor(validatorSpec, prevEntity) {
     var invalidAttrs = [];
     var validatorAttrs = {};
-
     if (validatorSpec.props && validatorSpec.props.attrs) {
       var attrOptions = makeArray(validatorSpec.props.attrs);
       /**
@@ -520,67 +444,52 @@ export function validator(nodes, marks, options) {
        * attrs: [{ props: { url: { type: 'string' } } }, { props: { data: {} } }],
        * Gotcha: It will always report the last failure.
        */
-
       for (var i = 0, length = attrOptions.length; i < length; ++i) {
         var attrOption = attrOptions[i];
-
         if (attrOption && attrOption.props) {
           var _partitionObject = partitionObject(attrOption.props, function (k, v) {
             return validateAttrs(v, prevEntity.attrs[k]);
           });
-
           var _partitionObject2 = _slicedToArray(_partitionObject, 2);
-
           invalidAttrs = _partitionObject2[1];
         }
-
         validatorAttrs = attrOption;
-
         if (!invalidAttrs.length) {
           break;
         }
       }
     }
-
     return {
       invalidAttrs: invalidAttrs,
       validatorAttrs: validatorAttrs
     };
   }
-
   function attributesValidationFor(validatorSpec, prevEntity, newEntity, isMark, errorCallback) {
     var validatorSpecAllowsAttributes = validatorSpec.props && validatorSpec.props.attrs;
-
     if (prevEntity.attrs) {
       if (!validatorSpecAllowsAttributes) {
         if (isMark) {
           return handleNoAttibutesAllowedInSpecForMark(prevEntity, prevEntity.attrs);
         }
-
         var attrs = Object.keys(prevEntity.attrs);
         return handleUnsupportedNodeAttributes(prevEntity, newEntity, [], attrs, errorCallback);
       }
-
       var _validateAttributes = validateAttributes(validatorSpec, prevEntity, prevEntity.attrs),
-          hasUnsupportedAttrs = _validateAttributes.hasUnsupportedAttrs,
-          redundantAttrs = _validateAttributes.redundantAttrs,
-          invalidAttrs = _validateAttributes.invalidAttrs;
-
+        hasUnsupportedAttrs = _validateAttributes.hasUnsupportedAttrs,
+        redundantAttrs = _validateAttributes.redundantAttrs,
+        invalidAttrs = _validateAttributes.invalidAttrs;
       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) {
     var invalidAttributesResult = invalidAttributesFor(validatorSpec, prevEntity);
     var invalidAttrs = invalidAttributesResult.invalidAttrs;
@@ -599,7 +508,6 @@ export function validator(nodes, marks, options) {
       redundantAttrs: redundantAttrs
     };
   }
-
   function handleUnsupportedNodeAttributes(prevEntity, newEntity, invalidAttrs, redundantAttrs, errorCallback) {
     var attr = invalidAttrs.concat(redundantAttrs);
     var result = {
@@ -615,18 +523,15 @@ export function validator(nodes, marks, options) {
     };
     return result;
   }
-
   function handleUnsupportedMarkAttributes(prevEntity, invalidAttrs, redundantAttrs) {
     var errorCode = 'INVALID_ATTRIBUTES';
     var message = errorMessageFor(prevEntity.type, "'attrs' validation failed");
     var hasRedundantAttrs = redundantAttrs.length;
     var hasBothInvalidAndRedundantAttrs = hasRedundantAttrs && invalidAttrs.length;
-
     if (!hasBothInvalidAndRedundantAttrs && hasRedundantAttrs) {
       errorCode = 'REDUNDANT_ATTRIBUTES';
       message = errorMessageFor('redundant attributes found', redundantAttrs.join(', '));
     }
-
     var markValidationResult = {
       valid: true,
       originalMark: prevEntity,
@@ -638,7 +543,6 @@ export function validator(nodes, marks, options) {
       marksValidationOutput: [markValidationResult]
     };
   }
-
   function handleNoAttibutesAllowedInSpecForMark(prevEntity, attributes) {
     var message = errorMessageFor('redundant attributes found', Object.keys(attributes).join(', '));
     var errorCode = 'REDUNDANT_ATTRIBUTES';
@@ -653,22 +557,16 @@ export function validator(nodes, marks, options) {
       marksValidationOutput: [markValidationResult]
     };
   }
-
   function wrapUnSupportedNodeAttributes(prevEntity, newEntity, invalidAttrs, errorCode, message, errorCallback) {
     var invalidValues = {};
-
     for (var invalidAttr in invalidAttrs) {
       invalidValues[invalidAttrs[invalidAttr]] = prevEntity.attrs && prevEntity.attrs[invalidAttrs[invalidAttr]];
-
       if (newEntity.attrs) {
         delete newEntity.attrs[invalidAttrs[invalidAttr]];
       }
     }
-
     var unsupportedNodeAttributeValues = unsupportedNodeAttributesContent(prevEntity, errorCode, invalidValues, message, errorCallback);
-
     var finalEntity = _objectSpread({}, newEntity);
-
     if (finalEntity.marks) {
       unsupportedNodeAttributeValues && finalEntity.marks.push(unsupportedNodeAttributeValues);
       return finalEntity.marks;
@@ -676,20 +574,17 @@ export function validator(nodes, marks, options) {
       return [unsupportedNodeAttributeValues];
     }
   }
-
   function extraPropsValidationFor(validatorSpec, prevEntity, err, newEntity, type) {
     var result = {
       valid: true,
       entity: prevEntity
     };
-
     var _partitionObject3 = partitionObject(prevEntity, function (k) {
-      return isDefined(validatorSpec.props[k]);
-    }),
-        _partitionObject4 = _slicedToArray(_partitionObject3, 2),
-        requiredProps = _partitionObject4[0],
-        redundantProps = _partitionObject4[1];
-
+        return isDefined(validatorSpec.props[k]);
+      }),
+      _partitionObject4 = _slicedToArray(_partitionObject3, 2),
+      requiredProps = _partitionObject4[0],
+      redundantProps = _partitionObject4[1];
     if (redundantProps.length) {
       if (mode === 'loose') {
         newEntity = {
@@ -706,34 +601,29 @@ export function validator(nodes, marks, options) {
         }
       }
     }
-
     return result;
   }
-
   function specBasedValidationFor(spec, typeOptions, prevEntity, err, newEntity, type, errorCallback, isMark) {
     var specBasedValidationResult = {
       hasValidated: false
     };
     var 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
     var requiredPropertyValidatonResult = requiredPropertyValidationFor(validatorSpec, prevEntity, err);
-
     if (!requiredPropertyValidatonResult.valid) {
       return {
         hasValidated: true,
         result: requiredPropertyValidatonResult
       };
     }
-
     if (!validatorSpec.props) {
-      var props = Object.keys(prevEntity); // If there's no validator.props then there shouldn't be any key except `type`
-
+      var 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,
@@ -742,38 +632,33 @@ export function validator(nodes, marks, options) {
           })
         };
       }
-
       return specBasedValidationResult;
-    } // Check text
-
+    }
 
+    // Check text
     var textPropertyValidationResult = textPropertyValidationFor(validatorSpec, prevEntity, err);
-
     if (!textPropertyValidationResult.valid) {
       return {
         hasValidated: true,
         result: textPropertyValidationResult
       };
-    } // Content Length
-
-
+    }
+    // Content Length
     var 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
     var _partitionObject5 = partitionObject(validatorSpec.props, function (k, v) {
-      return v.optional || isDefined(prevEntity[k]);
-    }),
-        _partitionObject6 = _slicedToArray(_partitionObject5, 2),
-        missingProps = _partitionObject6[1];
-
+        return v.optional || isDefined(prevEntity[k]);
+      }),
+      _partitionObject6 = _slicedToArray(_partitionObject5, 2),
+      missingProps = _partitionObject6[1];
     if (missingProps.length) {
       return {
         hasValidated: true,
@@ -782,46 +667,38 @@ export function validator(nodes, marks, options) {
         })
       };
     }
-
     var attributesValidationResult = attributesValidationFor(validatorSpec, prevEntity, newEntity, isMark, errorCallback);
-
     if (!attributesValidationResult.valid) {
       return {
         hasValidated: true,
         result: attributesValidationResult
       };
     }
-
     if (isMark && attributesValidationResult.valid) {
       return {
         hasValidated: true,
         result: attributesValidationResult
       };
     }
-
     var extraPropsValidationResult = extraPropsValidationFor(validatorSpec, prevEntity, err, newEntity, type);
-
     if (!extraPropsValidationResult.valid) {
       return {
         hasValidated: true,
         result: extraPropsValidationResult
       };
-    } // Children
-
+    }
 
+    // Children
     if (validatorSpec.props.content) {
       var contentValidatorSpec = validatorSpec.props.content;
-
       if (prevEntity.content) {
         var validateChildNode = function validateChildNode(child, index) {
           if (child === undefined) {
             return child;
           }
-
           var validateChildMarks = function validateChildMarks(childEntity, marksValidationOutput, errorCallback, isLastValidationSpec) {
             var isParentTupleLike = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
             var marksAreValid = true;
-
             if (childEntity && childEntity.marks && marksValidationOutput) {
               var validMarks = marksValidationOutput.filter(function (mark) {
                 return mark.valid;
@@ -833,11 +710,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 {
@@ -845,77 +720,63 @@ export function validator(nodes, marks, options) {
                 marksAreValid = false;
               }
             }
-
             return {
               valid: marksAreValid,
               entity: childEntity
             };
           };
-
           var hasMultipleCombinationOfContentAllowed = !!contentValidatorSpec.isTupleLike;
-
           if (hasMultipleCombinationOfContentAllowed) {
             var _validateNode = validateNode(child, errorCallback, makeArray(contentValidatorSpec.items[index] || contentValidatorSpec.items[contentValidatorSpec.items.length - 1]), validatorSpec),
-                newChildEntity = _validateNode.entity,
-                marksValidationOutput = _validateNode.marksValidationOutput;
-
+              newChildEntity = _validateNode.entity,
+              marksValidationOutput = _validateNode.marksValidationOutput;
             var _validateChildMarks = validateChildMarks(newChildEntity, marksValidationOutput, errorCallback, false, true),
-                entity = _validateChildMarks.entity;
-
+              entity = _validateChildMarks.entity;
             return entity;
-          } // Only go inside valid branch
-
+          }
 
+          // Only go inside valid branch
           var allowedSpecsForEntity = contentValidatorSpec.items.filter(function (item) {
-            return Array.isArray(item) ? item.some( // [p, hr, ...] or [p, [text, {}], ...]
+            return Array.isArray(item) ? item.some(
+            // [p, hr, ...] or [p, [text, {}], ...]
             function (spec) {
               return (Array.isArray(spec) ? spec[0] : spec) === child.type;
             }) : true;
           });
-
           if (allowedSpecsForEntity.length) {
             if (allowedSpecsForEntity.length > 1) {
               throw new Error('Consider using Tuple instead!');
             }
-
             var maybeArray = makeArray(allowedSpecsForEntity[0]);
             var allowedSpecsForChild = maybeArray.filter(function (item) {
               return (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'] }]]
              */
-
-
             var firstError;
             var firstChild;
-
             for (var i = 0, len = allowedSpecsForChild.length; i < len; i++) {
               try {
                 var allowedValueForCurrentSpec = [allowedSpecsForChild[i]];
-
                 var _validateNode2 = validateNode(child, errorCallback, allowedValueForCurrentSpec, validatorSpec),
-                    valid = _validateNode2.valid,
-                    _newChildEntity = _validateNode2.entity,
-                    _marksValidationOutput = _validateNode2.marksValidationOutput;
-
+                  valid = _validateNode2.valid,
+                  _newChildEntity = _validateNode2.entity,
+                  _marksValidationOutput = _validateNode2.marksValidationOutput;
                 if (valid) {
                   var isLastValidationSpec = i === allowedSpecsForChild.length - 1;
-
                   var _validateChildMarks2 = validateChildMarks(_newChildEntity, _marksValidationOutput, errorCallback, isLastValidationSpec),
-                      marksAreValid = _validateChildMarks2.valid,
-                      _entity = _validateChildMarks2.entity;
-
+                    marksAreValid = _validateChildMarks2.valid,
+                    _entity = _validateChildMarks2.entity;
                   var unsupportedMarks = _entity && _entity.marks && _entity.marks.filter(function (mark) {
                     return mark.type === 'unsupportedMark';
                   }) || [];
-
                   if (marksAreValid && !unsupportedMarks.length) {
                     return _entity;
                   } else {
@@ -928,7 +789,6 @@ export function validator(nodes, marks, options) {
                 firstError = firstError || error;
               }
             }
-
             if (!errorCallback) {
               throw firstError;
             } else {
@@ -938,7 +798,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 {
@@ -946,16 +805,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;
   }
 }