Check indent for array block content or object block content
@param {ASTNode} node node to examine
@returns {void}
function checkIndentInArrayOrObjectBlock(node) {
		// Skip inline
		if (isSingleLineNode(node)) {
			return;
		}

		var elements = (node.type === "ArrayExpression") ? node.elements : node.properties;

		// filter out empty elements example would be [ , 2] so remove first element as espree considers it as null
		elements = elements.filter(function(elem) {
			return elem !== null;
		});

		// Skip if first element is in same line with this node
		if (elements.length > 0 && elements[0].loc.start.line === node.loc.start.line) {
			return;
		}

		var nodeIndent;
		var elementsIndent;
		var parentVarNode = getVariableDeclaratorNode(node);

		// TODO - come up with a better strategy in future
		if (isNodeFirstInLine(node)) {
			var parent = node.parent;
			var effectiveParent = parent;

			if (parent.type === "MemberExpression") {
				if (isNodeFirstInLine(parent)) {
					effectiveParent = parent.parent.parent;
				} else {
					effectiveParent = parent.parent;
				}
			}
			nodeIndent = getNodeIndent(effectiveParent);
			if (parentVarNode && parentVarNode.loc.start.line !== node.loc.start.line) {
				if (parent.type !== "VariableDeclarator" || parentVarNode === parentVarNode.parent.declarations[0]) {
					if (parentVarNode.loc.start.line === effectiveParent.loc.start.line) {
						nodeIndent = nodeIndent + (indentSize * options.VariableDeclarator[parentVarNode.parent.kind]);
					} else if (
						parent.type === "ObjectExpression" ||
						parent.type === "ArrayExpression" ||
						parent.type === "CallExpression" ||
						parent.type === "ArrowFunctionExpression" ||
						parent.type === "NewExpression"
					) {
						nodeIndent = nodeIndent + indentSize;
					}
				}
			} else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && effectiveParent.type !== "MemberExpression" && effectiveParent.type !== "ExpressionStatement" && effectiveParent.type !== "AssignmentExpression" && effectiveParent.type !== "Property") {
				nodeIndent = nodeIndent + indentSize;
			}

			elementsIndent = nodeIndent + indentSize;

			checkFirstNodeLineIndent(node, nodeIndent);
		} else {
			nodeIndent = getNodeIndent(node);
			elementsIndent = nodeIndent + indentSize;
		}

		// check if the node is a multiple variable declaration, if yes then make sure indentation takes into account
		// variable indentation concept
		if (isNodeInVarOnTop(node, parentVarNode)) {
			elementsIndent += indentSize * options.VariableDeclarator[parentVarNode.parent.kind];
		}

		if (node.parent && node.parent.type === "CallExpression" && node.parent.arguments.length > 1 && isNodeFirstArgument(node) && isNodeOnSameLineAsPrevious(node) && isNextArgumentOnNextLine(node)) {
			elementsIndent += indentSize;
		}

		// Comma can be placed before property name
		checkNodesIndent(elements, elementsIndent, true);

		if (elements.length > 0) {
			// Skip last block line check if last item in same line
			if (elements[elements.length - 1].loc.end.line === node.loc.end.line) {
				return;
			}
		}

		var lastIndent = elementsIndent - indentSize;

		checkLastNodeLineIndent(node, lastIndent);
	}