code: function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
      var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
          arrLength = array.length,
          othLength = other.length;
  
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var index = -1,
          result = true,
          seen = (bitmask & UNORDERED_COMPARE_FLAG) ? [] : undefined;
  
      // Ignore non-index properties.
      while (++index < arrLength) {
        var arrValue = array[index],
            othValue = other[index];
  
        var compared;
        if (compared !== undefined) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        // Recursively compare arrays (susceptible to call stack limits).
        if (seen) {
          if (!baseSome(other, function(othValue, othIndex) {
                if (!indexOf(seen, othIndex) &&
                    (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
                  return seen.push(othIndex);
                }
              })) {
            result = false;
            break;
          }
        } else if (!(
              arrValue === othValue ||
                equalFunc(arrValue, othValue, customizer, bitmask, stack)
            )) {
          result = false;
          break;
        }
      }
      return result;
    }
docs: A specialized version of `baseIsEqualDeep` for arrays with support for
  partial deep comparisons.
  
  @private
  @param {Array} array The array to compare.
  @param {Array} other The other array to compare.
  @param {Function} equalFunc The function to determine equivalents of values.
  @param {Function} customizer The function to customize comparisons.
  @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
  for more details.
  @param {Object} stack Tracks traversed `array` and `other` objects.
  @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.