Remove IIFEs29219-remove-iifes-f

13 files changed, 1400 insertions, 1434 deletions

diff --git a/app/assets/javascripts/boards/components/modal/footer.js b/app/assets/javascripts/boards/components/modal/footer.js
index 887ce373096..ccd270b27da 100644
--- a/app/assets/javascripts/boards/components/modal/footer.js
+++ b/app/assets/javascripts/boards/components/modal/footer.js
@@ -5,80 +5,78 @@ import Vue from 'vue';
 
 require('./lists_dropdown');
 
-(() => {
-  const ModalStore = gl.issueBoards.ModalStore;
+const ModalStore = gl.issueBoards.ModalStore;
 
-  gl.issueBoards.ModalFooter = Vue.extend({
-    mixins: [gl.issueBoards.ModalMixins],
-    data() {
-      return {
-        modal: ModalStore.store,
-        state: gl.issueBoards.BoardsStore.state,
-      };
+gl.issueBoards.ModalFooter = Vue.extend({
+  mixins: [gl.issueBoards.ModalMixins],
+  data() {
+    return {
+      modal: ModalStore.store,
+      state: gl.issueBoards.BoardsStore.state,
+    };
+  },
+  computed: {
+    submitDisabled() {
+      return !ModalStore.selectedCount();
     },
-    computed: {
-      submitDisabled() {
-        return !ModalStore.selectedCount();
-      },
-      submitText() {
-        const count = ModalStore.selectedCount();
+    submitText() {
+      const count = ModalStore.selectedCount();
 
-        return `Add ${count > 0 ? count : ''} ${gl.text.pluralize('issue', count)}`;
-      },
+      return `Add ${count > 0 ? count : ''} ${gl.text.pluralize('issue', count)}`;
     },
-    methods: {
-      addIssues() {
-        const list = this.modal.selectedList || this.state.lists[0];
-        const selectedIssues = ModalStore.getSelectedIssues();
-        const issueIds = selectedIssues.map(issue => issue.globalId);
+  },
+  methods: {
+    addIssues() {
+      const list = this.modal.selectedList || this.state.lists[0];
+      const selectedIssues = ModalStore.getSelectedIssues();
+      const issueIds = selectedIssues.map(issue => issue.globalId);
 
-        // Post the data to the backend
-        gl.boardService.bulkUpdate(issueIds, {
-          add_label_ids: [list.label.id],
-        }).catch(() => {
-          new Flash('Failed to update issues, please try again.', 'alert');
+      // Post the data to the backend
+      gl.boardService.bulkUpdate(issueIds, {
+        add_label_ids: [list.label.id],
+      }).catch(() => {
+        new Flash('Failed to update issues, please try again.', 'alert');
 
-          selectedIssues.forEach((issue) => {
-            list.removeIssue(issue);
-            list.issuesSize -= 1;
-          });
-        });
-
-        // Add the issues on the frontend
         selectedIssues.forEach((issue) => {
-          list.addIssue(issue);
-          list.issuesSize += 1;
+          list.removeIssue(issue);
+          list.issuesSize -= 1;
         });
+      });
 
-        this.toggleModal(false);
-      },
-    },
-    components: {
-      'lists-dropdown': gl.issueBoards.ModalFooterListsDropdown,
+      // Add the issues on the frontend
+      selectedIssues.forEach((issue) => {
+        list.addIssue(issue);
+        list.issuesSize += 1;
+      });
+
+      this.toggleModal(false);
     },
-    template: `
-      <footer
-        class="form-actions add-issues-footer">
-        <div class="pull-left">
-          <button
-            class="btn btn-success"
-            type="button"
-            :disabled="submitDisabled"
-            @click="addIssues">
-            {{ submitText }}
-          </button>
-          <span class="inline add-issues-footer-to-list">
-            to list
-          </span>
-          <lists-dropdown></lists-dropdown>
-        </div>
+  },
+  components: {
+    'lists-dropdown': gl.issueBoards.ModalFooterListsDropdown,
+  },
+  template: `
+    <footer
+      class="form-actions add-issues-footer">
+      <div class="pull-left">
         <button
-          class="btn btn-default pull-right"
+          class="btn btn-success"
           type="button"
-          @click="toggleModal(false)">
-          Cancel
+          :disabled="submitDisabled"
+          @click="addIssues">
+          {{ submitText }}
         </button>
-      </footer>
-    `,
-  });
-})();
+        <span class="inline add-issues-footer-to-list">
+          to list
+        </span>
+        <lists-dropdown></lists-dropdown>
+      </div>
+      <button
+        class="btn btn-default pull-right"
+        type="button"
+        @click="toggleModal(false)">
+        Cancel
+      </button>
+    </footer>
+  `,
+});
diff --git a/app/assets/javascripts/commit/file.js b/app/assets/javascripts/commit/file.js
index ee087c978dd..28e5e06b155 100644
--- a/app/assets/javascripts/commit/file.js
+++ b/app/assets/javascripts/commit/file.js
@@ -1,14 +1,10 @@
 /* eslint-disable func-names, space-before-function-paren, wrap-iife, no-new */
 /* global ImageFile */
 
-(function() {
-  this.CommitFile = (function() {
-    function CommitFile(file) {
-      if ($('.image', file).length) {
-        new gl.ImageFile(file);
-      }
-    }
+function CommitFile(file) {
+  if ($('.image', file).length) {
+    new gl.ImageFile(file);
+  }
+}
 
-    return CommitFile;
-  })();
-}).call(window);
+window.CommitFile = CommitFile;
diff --git a/app/assets/javascripts/files_comment_button.js b/app/assets/javascripts/files_comment_button.js
index 3f041172ff3..bba4474cb06 100644
--- a/app/assets/javascripts/files_comment_button.js
+++ b/app/assets/javascripts/files_comment_button.js
@@ -5,127 +5,123 @@
 let $commentButtonTemplate;
 var bind = function(fn, me) { return function() { return fn.apply(me, arguments); }; };
 
-window.FilesCommentButton = (function() {
-  var COMMENT_BUTTON_CLASS, EMPTY_CELL_CLASS, LINE_COLUMN_CLASSES, LINE_CONTENT_CLASS, LINE_HOLDER_CLASS, LINE_NUMBER_CLASS, OLD_LINE_CLASS, TEXT_FILE_SELECTOR, UNFOLDABLE_LINE_CLASS;
+var COMMENT_BUTTON_CLASS, EMPTY_CELL_CLASS, LINE_COLUMN_CLASSES, LINE_CONTENT_CLASS, LINE_HOLDER_CLASS, LINE_NUMBER_CLASS, OLD_LINE_CLASS, TEXT_FILE_SELECTOR, UNFOLDABLE_LINE_CLASS;
 
-  COMMENT_BUTTON_CLASS = '.add-diff-note';
+COMMENT_BUTTON_CLASS = '.add-diff-note';
 
-  LINE_HOLDER_CLASS = '.line_holder';
+LINE_HOLDER_CLASS = '.line_holder';
 
-  LINE_NUMBER_CLASS = 'diff-line-num';
+LINE_NUMBER_CLASS = 'diff-line-num';
 
-  LINE_CONTENT_CLASS = 'line_content';
+LINE_CONTENT_CLASS = 'line_content';
 
-  UNFOLDABLE_LINE_CLASS = 'js-unfold';
+UNFOLDABLE_LINE_CLASS = 'js-unfold';
 
-  EMPTY_CELL_CLASS = 'empty-cell';
+EMPTY_CELL_CLASS = 'empty-cell';
 
-  OLD_LINE_CLASS = 'old_line';
+OLD_LINE_CLASS = 'old_line';
 
-  LINE_COLUMN_CLASSES = "." + LINE_NUMBER_CLASS + ", .line_content";
+LINE_COLUMN_CLASSES = "." + LINE_NUMBER_CLASS + ", .line_content";
 
-  TEXT_FILE_SELECTOR = '.text-file';
+TEXT_FILE_SELECTOR = '.text-file';
 
-  function FilesCommentButton(filesContainerElement) {
-    this.render = bind(this.render, this);
-    this.hideButton = bind(this.hideButton, this);
-    this.isParallelView = notes.isParallelView();
-    filesContainerElement.on('mouseover', LINE_COLUMN_CLASSES, this.render)
-      .on('mouseleave', LINE_COLUMN_CLASSES, this.hideButton);
+function FilesCommentButton(filesContainerElement) {
+  this.render = bind(this.render, this);
+  this.hideButton = bind(this.hideButton, this);
+  this.isParallelView = notes.isParallelView();
+  filesContainerElement.on('mouseover', LINE_COLUMN_CLASSES, this.render)
+    .on('mouseleave', LINE_COLUMN_CLASSES, this.hideButton);
+}
+
+FilesCommentButton.prototype.render = function(e) {
+  var $currentTarget, buttonParentElement, lineContentElement, textFileElement, $button;
+  $currentTarget = $(e.currentTarget);
+
+  if ($currentTarget.hasClass('js-no-comment-btn')) return;
+
+  lineContentElement = this.getLineContent($currentTarget);
+  buttonParentElement = this.getButtonParent($currentTarget);
+
+  if (!this.validateButtonParent(buttonParentElement) || !this.validateLineContent(lineContentElement)) return;
+
+  $button = $(COMMENT_BUTTON_CLASS, buttonParentElement);
+  buttonParentElement.addClass('is-over')
+    .nextUntil(`.${LINE_CONTENT_CLASS}`).addClass('is-over');
+
+  if ($button.length) {
+    return;
   }
 
-  FilesCommentButton.prototype.render = function(e) {
-    var $currentTarget, buttonParentElement, lineContentElement, textFileElement, $button;
-    $currentTarget = $(e.currentTarget);
+  textFileElement = this.getTextFileElement($currentTarget);
+  buttonParentElement.append(this.buildButton({
+    noteableType: textFileElement.attr('data-noteable-type'),
+    noteableID: textFileElement.attr('data-noteable-id'),
+    commitID: textFileElement.attr('data-commit-id'),
+    noteType: lineContentElement.attr('data-note-type'),
+    position: lineContentElement.attr('data-position'),
+    lineType: lineContentElement.attr('data-line-type'),
+    discussionID: lineContentElement.attr('data-discussion-id'),
+    lineCode: lineContentElement.attr('data-line-code')
+  }));
+};
 
-    if ($currentTarget.hasClass('js-no-comment-btn')) return;
+FilesCommentButton.prototype.hideButton = function(e) {
+  var $currentTarget = $(e.currentTarget);
+  var buttonParentElement = this.getButtonParent($currentTarget);
 
-    lineContentElement = this.getLineContent($currentTarget);
-    buttonParentElement = this.getButtonParent($currentTarget);
+  buttonParentElement.removeClass('is-over')
+    .nextUntil(`.${LINE_CONTENT_CLASS}`).removeClass('is-over');
+};
 
-    if (!this.validateButtonParent(buttonParentElement) || !this.validateLineContent(lineContentElement)) return;
+FilesCommentButton.prototype.buildButton = function(buttonAttributes) {
+  return $commentButtonTemplate.clone().attr({
+    'data-noteable-type': buttonAttributes.noteableType,
+    'data-noteable-id': buttonAttributes.noteableID,
+    'data-commit-id': buttonAttributes.commitID,
+    'data-note-type': buttonAttributes.noteType,
+    'data-line-code': buttonAttributes.lineCode,
+    'data-position': buttonAttributes.position,
+    'data-discussion-id': buttonAttributes.discussionID,
+    'data-line-type': buttonAttributes.lineType
+  });
+};
 
-    $button = $(COMMENT_BUTTON_CLASS, buttonParentElement);
-    buttonParentElement.addClass('is-over')
-      .nextUntil(`.${LINE_CONTENT_CLASS}`).addClass('is-over');
+FilesCommentButton.prototype.getTextFileElement = function(hoveredElement) {
+  return hoveredElement.closest(TEXT_FILE_SELECTOR);
+};
 
-    if ($button.length) {
-      return;
-    }
+FilesCommentButton.prototype.getLineContent = function(hoveredElement) {
+  if (hoveredElement.hasClass(LINE_CONTENT_CLASS)) {
+    return hoveredElement;
+  }
+  if (!this.isParallelView) {
+    return $(hoveredElement).closest(LINE_HOLDER_CLASS).find("." + LINE_CONTENT_CLASS);
+  } else {
+    return $(hoveredElement).next("." + LINE_CONTENT_CLASS);
+  }
+};
 
-    textFileElement = this.getTextFileElement($currentTarget);
-    buttonParentElement.append(this.buildButton({
-      noteableType: textFileElement.attr('data-noteable-type'),
-      noteableID: textFileElement.attr('data-noteable-id'),
-      commitID: textFileElement.attr('data-commit-id'),
-      noteType: lineContentElement.attr('data-note-type'),
-      position: lineContentElement.attr('data-position'),
-      lineType: lineContentElement.attr('data-line-type'),
-      discussionID: lineContentElement.attr('data-discussion-id'),
-      lineCode: lineContentElement.attr('data-line-code')
-    }));
-  };
-
-  FilesCommentButton.prototype.hideButton = function(e) {
-    var $currentTarget = $(e.currentTarget);
-    var buttonParentElement = this.getButtonParent($currentTarget);
-
-    buttonParentElement.removeClass('is-over')
-      .nextUntil(`.${LINE_CONTENT_CLASS}`).removeClass('is-over');
-  };
-
-  FilesCommentButton.prototype.buildButton = function(buttonAttributes) {
-    return $commentButtonTemplate.clone().attr({
-      'data-noteable-type': buttonAttributes.noteableType,
-      'data-noteable-id': buttonAttributes.noteableID,
-      'data-commit-id': buttonAttributes.commitID,
-      'data-note-type': buttonAttributes.noteType,
-      'data-line-code': buttonAttributes.lineCode,
-      'data-position': buttonAttributes.position,
-      'data-discussion-id': buttonAttributes.discussionID,
-      'data-line-type': buttonAttributes.lineType
-    });
-  };
-
-  FilesCommentButton.prototype.getTextFileElement = function(hoveredElement) {
-    return hoveredElement.closest(TEXT_FILE_SELECTOR);
-  };
-
-  FilesCommentButton.prototype.getLineContent = function(hoveredElement) {
-    if (hoveredElement.hasClass(LINE_CONTENT_CLASS)) {
+FilesCommentButton.prototype.getButtonParent = function(hoveredElement) {
+  if (!this.isParallelView) {
+    if (hoveredElement.hasClass(OLD_LINE_CLASS)) {
       return hoveredElement;
     }
-    if (!this.isParallelView) {
-      return $(hoveredElement).closest(LINE_HOLDER_CLASS).find("." + LINE_CONTENT_CLASS);
-    } else {
-      return $(hoveredElement).next("." + LINE_CONTENT_CLASS);
-    }
-  };
-
-  FilesCommentButton.prototype.getButtonParent = function(hoveredElement) {
-    if (!this.isParallelView) {
-      if (hoveredElement.hasClass(OLD_LINE_CLASS)) {
-        return hoveredElement;
-      }
-      return hoveredElement.parent().find("." + OLD_LINE_CLASS);
-    } else {
-      if (hoveredElement.hasClass(LINE_NUMBER_CLASS)) {
-        return hoveredElement;
-      }
-      return $(hoveredElement).prev("." + LINE_NUMBER_CLASS);
+    return hoveredElement.parent().find("." + OLD_LINE_CLASS);
+  } else {
+    if (hoveredElement.hasClass(LINE_NUMBER_CLASS)) {
+      return hoveredElement;
     }
-  };
-
-  FilesCommentButton.prototype.validateButtonParent = function(buttonParentElement) {
-    return !buttonParentElement.hasClass(EMPTY_CELL_CLASS) && !buttonParentElement.hasClass(UNFOLDABLE_LINE_CLASS);
-  };
+    return $(hoveredElement).prev("." + LINE_NUMBER_CLASS);
+  }
+};
 
-  FilesCommentButton.prototype.validateLineContent = function(lineContentElement) {
-    return lineContentElement.attr('data-discussion-id') && lineContentElement.attr('data-discussion-id') !== '';
-  };
+FilesCommentButton.prototype.validateButtonParent = function(buttonParentElement) {
+  return !buttonParentElement.hasClass(EMPTY_CELL_CLASS) && !buttonParentElement.hasClass(UNFOLDABLE_LINE_CLASS);
+};
 
-  return FilesCommentButton;
-})();
+FilesCommentButton.prototype.validateLineContent = function(lineContentElement) {
+  return lineContentElement.attr('data-discussion-id') && lineContentElement.attr('data-discussion-id') !== '';
+};
 
 $.fn.filesCommentButton = function() {
   $commentButtonTemplate = $('<button name="button" type="submit" class="add-diff-note js-add-diff-note-button" title="Add a comment to this line"><i class="fa fa-comment-o"></i></button>');
diff --git a/app/assets/javascripts/filtered_search/filtered_search_dropdown.js b/app/assets/javascripts/filtered_search/filtered_search_dropdown.js
index e7bf530d343..15b64fecce8 100644
--- a/app/assets/javascripts/filtered_search/filtered_search_dropdown.js
+++ b/app/assets/javascripts/filtered_search/filtered_search_dropdown.js
@@ -1,124 +1,122 @@
-(() => {
-  const DATA_DROPDOWN_TRIGGER = 'data-dropdown-trigger';
-
-  class FilteredSearchDropdown {
-    constructor(droplab, dropdown, input, filter) {
-      this.droplab = droplab;
-      this.hookId = input && input.getAttribute('data-id');
-      this.input = input;
-      this.filter = filter;
-      this.dropdown = dropdown;
-      this.loadingTemplate = `<div class="filter-dropdown-loading">
-        <i class="fa fa-spinner fa-spin"></i>
-      </div>`;
-      this.bindEvents();
-    }
-
-    bindEvents() {
-      this.itemClickedWrapper = this.itemClicked.bind(this);
-      this.dropdown.addEventListener('click.dl', this.itemClickedWrapper);
-    }
+const DATA_DROPDOWN_TRIGGER = 'data-dropdown-trigger';
+
+class FilteredSearchDropdown {
+  constructor(droplab, dropdown, input, filter) {
+    this.droplab = droplab;
+    this.hookId = input && input.getAttribute('data-id');
+    this.input = input;
+    this.filter = filter;
+    this.dropdown = dropdown;
+    this.loadingTemplate = `<div class="filter-dropdown-loading">
+      <i class="fa fa-spinner fa-spin"></i>
+    </div>`;
+    this.bindEvents();
+  }
 
-    unbindEvents() {
-      this.dropdown.removeEventListener('click.dl', this.itemClickedWrapper);
-    }
+  bindEvents() {
+    this.itemClickedWrapper = this.itemClicked.bind(this);
+    this.dropdown.addEventListener('click.dl', this.itemClickedWrapper);
+  }
 
-    getCurrentHook() {
-      return this.droplab.hooks.filter(h => h.id === this.hookId)[0] || null;
-    }
+  unbindEvents() {
+    this.dropdown.removeEventListener('click.dl', this.itemClickedWrapper);
+  }
 
-    itemClicked(e, getValueFunction) {
-      const { selected } = e.detail;
+  getCurrentHook() {
+    return this.droplab.hooks.filter(h => h.id === this.hookId)[0] || null;
+  }
 
-      if (selected.tagName === 'LI' && selected.innerHTML) {
-        const dataValueSet = gl.DropdownUtils.setDataValueIfSelected(this.filter, selected);
+  itemClicked(e, getValueFunction) {
+    const { selected } = e.detail;
 
-        if (!dataValueSet) {
-          const value = getValueFunction(selected);
-          gl.FilteredSearchDropdownManager.addWordToInput(this.filter, value, true);
-        }
+    if (selected.tagName === 'LI' && selected.innerHTML) {
+      const dataValueSet = gl.DropdownUtils.setDataValueIfSelected(this.filter, selected);
 
-        this.resetFilters();
-        this.dismissDropdown();
-        this.dispatchInputEvent();
+      if (!dataValueSet) {
+        const value = getValueFunction(selected);
+        gl.FilteredSearchDropdownManager.addWordToInput(this.filter, value, true);
       }
-    }
 
-    setAsDropdown() {
-      this.input.setAttribute(DATA_DROPDOWN_TRIGGER, `#${this.dropdown.id}`);
+      this.resetFilters();
+      this.dismissDropdown();
+      this.dispatchInputEvent();
     }
+  }
 
-    setOffset(offset = 0) {
-      if (window.innerWidth > 480) {
-        this.dropdown.style.left = `${offset}px`;
-      } else {
-        this.dropdown.style.left = '0px';
-      }
+  setAsDropdown() {
+    this.input.setAttribute(DATA_DROPDOWN_TRIGGER, `#${this.dropdown.id}`);
+  }
+
+  setOffset(offset = 0) {
+    if (window.innerWidth > 480) {
+      this.dropdown.style.left = `${offset}px`;
+    } else {
+      this.dropdown.style.left = '0px';
     }
+  }
 
-    renderContent(forceShowList = false) {
-      const currentHook = this.getCurrentHook();
-      if (forceShowList && currentHook && currentHook.list.hidden) {
-        currentHook.list.show();
-      }
+  renderContent(forceShowList = false) {
+    const currentHook = this.getCurrentHook();
+    if (forceShowList && currentHook && currentHook.list.hidden) {
+      currentHook.list.show();
     }
+  }
 
-    render(forceRenderContent = false, forceShowList = false) {
-      this.setAsDropdown();
+  render(forceRenderContent = false, forceShowList = false) {
+    this.setAsDropdown();
 
-      const currentHook = this.getCurrentHook();
-      const firstTimeInitialized = currentHook === null;
+    const currentHook = this.getCurrentHook();
+    const firstTimeInitialized = currentHook === null;
 
-      if (firstTimeInitialized || forceRenderContent) {
-        this.renderContent(forceShowList);
-      } else if (currentHook.list.list.id !== this.dropdown.id) {
-        this.renderContent(forceShowList);
-      }
+    if (firstTimeInitialized || forceRenderContent) {
+      this.renderContent(forceShowList);
+    } else if (currentHook.list.list.id !== this.dropdown.id) {
+      this.renderContent(forceShowList);
     }
+  }
 
-    dismissDropdown() {
-      // Focusing on the input will dismiss dropdown
-      // (default droplab functionality)
-      this.input.focus();
-    }
+  dismissDropdown() {
+    // Focusing on the input will dismiss dropdown
+    // (default droplab functionality)
+    this.input.focus();
+  }
 
-    dispatchInputEvent() {
-      // Propogate input change to FilteredSearchDropdownManager
-      // so that it can determine which dropdowns to open
-      this.input.dispatchEvent(new CustomEvent('input', {
-        bubbles: true,
-        cancelable: true,
-      }));
-    }
+  dispatchInputEvent() {
+    // Propogate input change to FilteredSearchDropdownManager
+    // so that it can determine which dropdowns to open
+    this.input.dispatchEvent(new CustomEvent('input', {
+      bubbles: true,
+      cancelable: true,
+    }));
+  }
 
-    dispatchFormSubmitEvent() {
-      // dispatchEvent() is necessary as form.submit() does not
-      // trigger event handlers
-      this.input.form.dispatchEvent(new Event('submit'));
-    }
+  dispatchFormSubmitEvent() {
+    // dispatchEvent() is necessary as form.submit() does not
+    // trigger event handlers
+    this.input.form.dispatchEvent(new Event('submit'));
+  }
 
-    hideDropdown() {
-      const currentHook = this.getCurrentHook();
-      if (currentHook) {
-        currentHook.list.hide();
-      }
+  hideDropdown() {
+    const currentHook = this.getCurrentHook();
+    if (currentHook) {
+      currentHook.list.hide();
     }
+  }
 
-    resetFilters() {
-      const hook = this.getCurrentHook();
-
-      if (hook) {
-        const data = hook.list.data || [];
-        const results = data.map((o) => {
-          const updated = o;
-          updated.droplab_hidden = false;
-          return updated;
-        });
-        hook.list.render(results);
-      }
+  resetFilters() {
+    const hook = this.getCurrentHook();
+
+    if (hook) {
+      const data = hook.list.data || [];
+      const results = data.map((o) => {
+        const updated = o;
+        updated.droplab_hidden = false;
+        return updated;
+      });
+      hook.list.render(results);
     }
   }
+}
 
-  window.gl = window.gl || {};
-  gl.FilteredSearchDropdown = FilteredSearchDropdown;
-})();
+window.gl = window.gl || {};
+gl.FilteredSearchDropdown = FilteredSearchDropdown;
diff --git a/app/assets/javascripts/filtered_search/filtered_search_dropdown_manager.js b/app/assets/javascripts/filtered_search/filtered_search_dropdown_manager.js
index 5fbe0450bb8..4ad7b6ef547 100644
--- a/app/assets/javascripts/filtered_search/filtered_search_dropdown_manager.js
+++ b/app/assets/javascripts/filtered_search/filtered_search_dropdown_manager.js
@@ -1,191 +1,189 @@
 /* global DropLab */
 import FilteredSearchContainer from './container';
 
-(() => {
-  class FilteredSearchDropdownManager {
-    constructor(baseEndpoint = '', page) {
-      this.container = FilteredSearchContainer.container;
-      this.baseEndpoint = baseEndpoint.replace(/\/$/, '');
-      this.tokenizer = gl.FilteredSearchTokenizer;
-      this.filteredSearchTokenKeys = gl.FilteredSearchTokenKeys;
-      this.filteredSearchInput = this.container.querySelector('.filtered-search');
-      this.page = page;
-
-      this.setupMapping();
-
-      this.cleanupWrapper = this.cleanup.bind(this);
-      document.addEventListener('beforeunload', this.cleanupWrapper);
+class FilteredSearchDropdownManager {
+  constructor(baseEndpoint = '', page) {
+    this.container = FilteredSearchContainer.container;
+    this.baseEndpoint = baseEndpoint.replace(/\/$/, '');
+    this.tokenizer = gl.FilteredSearchTokenizer;
+    this.filteredSearchTokenKeys = gl.FilteredSearchTokenKeys;
+    this.filteredSearchInput = this.container.querySelector('.filtered-search');
+    this.page = page;
+
+    this.setupMapping();
+
+    this.cleanupWrapper = this.cleanup.bind(this);
+    document.addEventListener('beforeunload', this.cleanupWrapper);
+  }
+
+  cleanup() {
+    if (this.droplab) {
+      this.droplab.destroy();
+      this.droplab = null;
     }
 
-    cleanup() {
-      if (this.droplab) {
-        this.droplab.destroy();
-        this.droplab = null;
-      }
+    this.setupMapping();
 
-      this.setupMapping();
+    document.removeEventListener('beforeunload', this.cleanupWrapper);
+  }
 
-      document.removeEventListener('beforeunload', this.cleanupWrapper);
-    }
+  setupMapping() {
+    this.mapping = {
+      author: {
+        reference: null,
+        gl: 'DropdownUser',
+        element: this.container.querySelector('#js-dropdown-author'),
+      },
+      assignee: {
+        reference: null,
+        gl: 'DropdownUser',
+        element: this.container.querySelector('#js-dropdown-assignee'),
+      },
+      milestone: {
+        reference: null,
+        gl: 'DropdownNonUser',
+        extraArguments: [`${this.baseEndpoint}/milestones.json`, '%'],
+        element: this.container.querySelector('#js-dropdown-milestone'),
+      },
+      label: {
+        reference: null,
+        gl: 'DropdownNonUser',
+        extraArguments: [`${this.baseEndpoint}/labels.json`, '~'],
+        element: this.container.querySelector('#js-dropdown-label'),
+      },
+      hint: {
+        reference: null,
+        gl: 'DropdownHint',
+        element: this.container.querySelector('#js-dropdown-hint'),
+      },
+    };
+  }
 
-    setupMapping() {
-      this.mapping = {
-        author: {
-          reference: null,
-          gl: 'DropdownUser',
-          element: this.container.querySelector('#js-dropdown-author'),
-        },
-        assignee: {
-          reference: null,
-          gl: 'DropdownUser',
-          element: this.container.querySelector('#js-dropdown-assignee'),
-        },
-        milestone: {
-          reference: null,
-          gl: 'DropdownNonUser',
-          extraArguments: [`${this.baseEndpoint}/milestones.json`, '%'],
-          element: this.container.querySelector('#js-dropdown-milestone'),
-        },
-        label: {
-          reference: null,
-          gl: 'DropdownNonUser',
-          extraArguments: [`${this.baseEndpoint}/labels.json`, '~'],
-          element: this.container.querySelector('#js-dropdown-label'),
-        },
-        hint: {
-          reference: null,
-          gl: 'DropdownHint',
-          element: this.container.querySelector('#js-dropdown-hint'),
-        },
-      };
+  static addWordToInput(tokenName, tokenValue = '', clicked = false) {
+    const input = FilteredSearchContainer.container.querySelector('.filtered-search');
+
+    gl.FilteredSearchVisualTokens.addFilterVisualToken(tokenName, tokenValue);
+    input.value = '';
+
+    if (clicked) {
+      gl.FilteredSearchVisualTokens.moveInputToTheRight();
     }
+  }
 
-    static addWordToInput(tokenName, tokenValue = '', clicked = false) {
-      const input = FilteredSearchContainer.container.querySelector('.filtered-search');
+  updateCurrentDropdownOffset() {
+    this.updateDropdownOffset(this.currentDropdown);
+  }
 
-      gl.FilteredSearchVisualTokens.addFilterVisualToken(tokenName, tokenValue);
-      input.value = '';
+  updateDropdownOffset(key) {
+    // Always align dropdown with the input field
+    let offset = this.filteredSearchInput.getBoundingClientRect().left - this.container.querySelector('.scroll-container').getBoundingClientRect().left;
 
-      if (clicked) {
-        gl.FilteredSearchVisualTokens.moveInputToTheRight();
-      }
-    }
+    const maxInputWidth = 240;
+    const currentDropdownWidth = this.mapping[key].element.clientWidth || maxInputWidth;
 
-    updateCurrentDropdownOffset() {
-      this.updateDropdownOffset(this.currentDropdown);
+    // Make sure offset never exceeds the input container
+    const offsetMaxWidth = this.container.querySelector('.scroll-container').clientWidth - currentDropdownWidth;
+    if (offsetMaxWidth < offset) {
+      offset = offsetMaxWidth;
     }
 
-    updateDropdownOffset(key) {
-      // Always align dropdown with the input field
-      let offset = this.filteredSearchInput.getBoundingClientRect().left - this.container.querySelector('.scroll-container').getBoundingClientRect().left;
+    this.mapping[key].reference.setOffset(offset);
+  }
 
-      const maxInputWidth = 240;
-      const currentDropdownWidth = this.mapping[key].element.clientWidth || maxInputWidth;
+  load(key, firstLoad = false) {
+    const mappingKey = this.mapping[key];
+    const glClass = mappingKey.gl;
+    const element = mappingKey.element;
+    let forceShowList = false;
 
-      // Make sure offset never exceeds the input container
-      const offsetMaxWidth = this.container.querySelector('.scroll-container').clientWidth - currentDropdownWidth;
-      if (offsetMaxWidth < offset) {
-        offset = offsetMaxWidth;
-      }
+    if (!mappingKey.reference) {
+      const dl = this.droplab;
+      const defaultArguments = [null, dl, element, this.filteredSearchInput, key];
+      const glArguments = defaultArguments.concat(mappingKey.extraArguments || []);
 
-      this.mapping[key].reference.setOffset(offset);
+      // Passing glArguments to `new gl[glClass](<arguments>)`
+      mappingKey.reference = new (Function.prototype.bind.apply(gl[glClass], glArguments))();
     }
 
-    load(key, firstLoad = false) {
-      const mappingKey = this.mapping[key];
-      const glClass = mappingKey.gl;
-      const element = mappingKey.element;
-      let forceShowList = false;
-
-      if (!mappingKey.reference) {
-        const dl = this.droplab;
-        const defaultArguments = [null, dl, element, this.filteredSearchInput, key];
-        const glArguments = defaultArguments.concat(mappingKey.extraArguments || []);
+    if (firstLoad) {
+      mappingKey.reference.init();
+    }
 
-        // Passing glArguments to `new gl[glClass](<arguments>)`
-        mappingKey.reference = new (Function.prototype.bind.apply(gl[glClass], glArguments))();
-      }
+    if (this.currentDropdown === 'hint') {
+      // Force the dropdown to show if it was clicked from the hint dropdown
+      forceShowList = true;
+    }
 
-      if (firstLoad) {
-        mappingKey.reference.init();
-      }
+    this.updateDropdownOffset(key);
+    mappingKey.reference.render(firstLoad, forceShowList);
 
-      if (this.currentDropdown === 'hint') {
-        // Force the dropdown to show if it was clicked from the hint dropdown
-        forceShowList = true;
-      }
+    this.currentDropdown = key;
+  }
 
-      this.updateDropdownOffset(key);
-      mappingKey.reference.render(firstLoad, forceShowList);
+  loadDropdown(dropdownName = '') {
+    let firstLoad = false;
 
-      this.currentDropdown = key;
+    if (!this.droplab) {
+      firstLoad = true;
+      this.droplab = new DropLab();
     }
 
-    loadDropdown(dropdownName = '') {
-      let firstLoad = false;
+    const match = this.filteredSearchTokenKeys.searchByKey(dropdownName.toLowerCase());
+    const shouldOpenFilterDropdown = match && this.currentDropdown !== match.key
+      && this.mapping[match.key];
+    const shouldOpenHintDropdown = !match && this.currentDropdown !== 'hint';
 
-      if (!this.droplab) {
-        firstLoad = true;
-        this.droplab = new DropLab();
-      }
+    if (shouldOpenFilterDropdown || shouldOpenHintDropdown) {
+      const key = match && match.key ? match.key : 'hint';
+      this.load(key, firstLoad);
+    }
+  }
 
-      const match = this.filteredSearchTokenKeys.searchByKey(dropdownName.toLowerCase());
-      const shouldOpenFilterDropdown = match && this.currentDropdown !== match.key
-        && this.mapping[match.key];
-      const shouldOpenHintDropdown = !match && this.currentDropdown !== 'hint';
+  setDropdown() {
+    const query = gl.DropdownUtils.getSearchQuery(true);
+    const { lastToken, searchToken } = this.tokenizer.processTokens(query);
 
-      if (shouldOpenFilterDropdown || shouldOpenHintDropdown) {
-        const key = match && match.key ? match.key : 'hint';
-        this.load(key, firstLoad);
-      }
+    if (this.currentDropdown) {
+      this.updateCurrentDropdownOffset();
     }
 
-    setDropdown() {
-      const query = gl.DropdownUtils.getSearchQuery(true);
-      const { lastToken, searchToken } = this.tokenizer.processTokens(query);
-
-      if (this.currentDropdown) {
-        this.updateCurrentDropdownOffset();
-      }
-
-      if (lastToken === searchToken && lastToken !== null) {
-        // Token is not fully initialized yet because it has no value
-        // Eg. token = 'label:'
-
-        const split = lastToken.split(':');
-        const dropdownName = split[0].split(' ').last();
-        this.loadDropdown(split.length > 1 ? dropdownName : '');
-      } else if (lastToken) {
-        // Token has been initialized into an object because it has a value
-        this.loadDropdown(lastToken.key);
-      } else {
-        this.loadDropdown('hint');
-      }
+    if (lastToken === searchToken && lastToken !== null) {
+      // Token is not fully initialized yet because it has no value
+      // Eg. token = 'label:'
+
+      const split = lastToken.split(':');
+      const dropdownName = split[0].split(' ').last();
+      this.loadDropdown(split.length > 1 ? dropdownName : '');
+    } else if (lastToken) {
+      // Token has been initialized into an object because it has a value
+      this.loadDropdown(lastToken.key);
+    } else {
+      this.loadDropdown('hint');
     }
+  }
 
-    resetDropdowns() {
-      if (!this.currentDropdown) {
-        return;
-      }
+  resetDropdowns() {
+    if (!this.currentDropdown) {
+      return;
+    }
 
-      // Force current dropdown to hide
-      this.mapping[this.currentDropdown].reference.hideDropdown();
+    // Force current dropdown to hide
+    this.mapping[this.currentDropdown].reference.hideDropdown();
 
-      // Re-Load dropdown
-      this.setDropdown();
+    // Re-Load dropdown
+    this.setDropdown();
 
-      // Reset filters for current dropdown
-      this.mapping[this.currentDropdown].reference.resetFilters();
+    // Reset filters for current dropdown
+    this.mapping[this.currentDropdown].reference.resetFilters();
 
-      // Reposition dropdown so that it is aligned with cursor
-      this.updateDropdownOffset(this.currentDropdown);
-    }
+    // Reposition dropdown so that it is aligned with cursor
+    this.updateDropdownOffset(this.currentDropdown);
+  }
 
-    destroyDroplab() {
-      this.droplab.destroy();
-    }
+  destroyDroplab() {
+    this.droplab.destroy();
   }
+}
 
-  window.gl = window.gl || {};
-  gl.FilteredSearchDropdownManager = FilteredSearchDropdownManager;
-})();
+window.gl = window.gl || {};
+gl.FilteredSearchDropdownManager = FilteredSearchDropdownManager;
diff --git a/app/assets/javascripts/filtered_search/filtered_search_manager.js b/app/assets/javascripts/filtered_search/filtered_search_manager.js
index 22352950452..adbc5af29a0 100644
--- a/app/assets/javascripts/filtered_search/filtered_search_manager.js
+++ b/app/assets/javascripts/filtered_search/filtered_search_manager.js
@@ -1,423 +1,421 @@
 import FilteredSearchContainer from './container';
 
-(() => {
-  class FilteredSearchManager {
-    constructor(page) {
-      this.container = FilteredSearchContainer.container;
-      this.filteredSearchInput = this.container.querySelector('.filtered-search');
-      this.clearSearchButton = this.container.querySelector('.clear-search');
-      this.tokensContainer = this.container.querySelector('.tokens-container');
-      this.filteredSearchTokenKeys = gl.FilteredSearchTokenKeys;
-
-      if (this.filteredSearchInput) {
-        this.tokenizer = gl.FilteredSearchTokenizer;
-        this.dropdownManager = new gl.FilteredSearchDropdownManager(this.filteredSearchInput.getAttribute('data-base-endpoint') || '', page);
-
-        this.bindEvents();
-        this.loadSearchParamsFromURL();
-        this.dropdownManager.setDropdown();
-
-        this.cleanupWrapper = this.cleanup.bind(this);
-        document.addEventListener('beforeunload', this.cleanupWrapper);
-      }
-    }
-
-    cleanup() {
-      this.unbindEvents();
-      document.removeEventListener('beforeunload', this.cleanupWrapper);
+class FilteredSearchManager {
+  constructor(page) {
+    this.container = FilteredSearchContainer.container;
+    this.filteredSearchInput = this.container.querySelector('.filtered-search');
+    this.clearSearchButton = this.container.querySelector('.clear-search');
+    this.tokensContainer = this.container.querySelector('.tokens-container');
+    this.filteredSearchTokenKeys = gl.FilteredSearchTokenKeys;
+
+    if (this.filteredSearchInput) {
+      this.tokenizer = gl.FilteredSearchTokenizer;
+      this.dropdownManager = new gl.FilteredSearchDropdownManager(this.filteredSearchInput.getAttribute('data-base-endpoint') || '', page);
+
+      this.bindEvents();
+      this.loadSearchParamsFromURL();
+      this.dropdownManager.setDropdown();
+
+      this.cleanupWrapper = this.cleanup.bind(this);
+      document.addEventListener('beforeunload', this.cleanupWrapper);
     }
+  }
 
-    bindEvents() {
-      this.handleFormSubmit = this.handleFormSubmit.bind(this);
-      this.setDropdownWrapper = this.dropdownManager.setDropdown.bind(this.dropdownManager);
-      this.toggleClearSearchButtonWrapper = this.toggleClearSearchButton.bind(this);
-      this.handleInputPlaceholderWrapper = this.handleInputPlaceholder.bind(this);
-      this.handleInputVisualTokenWrapper = this.handleInputVisualToken.bind(this);
-      this.checkForEnterWrapper = this.checkForEnter.bind(this);
-      this.clearSearchWrapper = this.clearSearch.bind(this);
-      this.checkForBackspaceWrapper = this.checkForBackspace.bind(this);
-      this.removeSelectedTokenWrapper = this.removeSelectedToken.bind(this);
-      this.unselectEditTokensWrapper = this.unselectEditTokens.bind(this);
-      this.editTokenWrapper = this.editToken.bind(this);
-      this.tokenChange = this.tokenChange.bind(this);
-      this.addInputContainerFocusWrapper = this.addInputContainerFocus.bind(this);
-      this.removeInputContainerFocusWrapper = this.removeInputContainerFocus.bind(this);
-
-      this.filteredSearchInputForm = this.filteredSearchInput.form;
-      this.filteredSearchInputForm.addEventListener('submit', this.handleFormSubmit);
-      this.filteredSearchInput.addEventListener('input', this.setDropdownWrapper);
-      this.filteredSearchInput.addEventListener('input', this.toggleClearSearchButtonWrapper);
-      this.filteredSearchInput.addEventListener('input', this.handleInputPlaceholderWrapper);
-      this.filteredSearchInput.addEventListener('input', this.handleInputVisualTokenWrapper);
-      this.filteredSearchInput.addEventListener('keydown', this.checkForEnterWrapper);
-      this.filteredSearchInput.addEventListener('keyup', this.checkForBackspaceWrapper);
-      this.filteredSearchInput.addEventListener('click', this.tokenChange);
-      this.filteredSearchInput.addEventListener('keyup', this.tokenChange);
-      this.filteredSearchInput.addEventListener('focus', this.addInputContainerFocusWrapper);
-      this.tokensContainer.addEventListener('click', FilteredSearchManager.selectToken);
-      this.tokensContainer.addEventListener('dblclick', this.editTokenWrapper);
-      this.clearSearchButton.addEventListener('click', this.clearSearchWrapper);
-      document.addEventListener('click', gl.FilteredSearchVisualTokens.unselectTokens);
-      document.addEventListener('click', this.unselectEditTokensWrapper);
-      document.addEventListener('click', this.removeInputContainerFocusWrapper);
-      document.addEventListener('keydown', this.removeSelectedTokenWrapper);
-    }
+  cleanup() {
+    this.unbindEvents();
+    document.removeEventListener('beforeunload', this.cleanupWrapper);
+  }
 
-    unbindEvents() {
-      this.filteredSearchInputForm.removeEventListener('submit', this.handleFormSubmit);
-      this.filteredSearchInput.removeEventListener('input', this.setDropdownWrapper);
-      this.filteredSearchInput.removeEventListener('input', this.toggleClearSearchButtonWrapper);
-      this.filteredSearchInput.removeEventListener('input', this.handleInputPlaceholderWrapper);
-      this.filteredSearchInput.removeEventListener('input', this.handleInputVisualTokenWrapper);
-      this.filteredSearchInput.removeEventListener('keydown', this.checkForEnterWrapper);
-      this.filteredSearchInput.removeEventListener('keyup', this.checkForBackspaceWrapper);
-      this.filteredSearchInput.removeEventListener('click', this.tokenChange);
-      this.filteredSearchInput.removeEventListener('keyup', this.tokenChange);
-      this.filteredSearchInput.removeEventListener('focus', this.addInputContainerFocusWrapper);
-      this.tokensContainer.removeEventListener('click', FilteredSearchManager.selectToken);
-      this.tokensContainer.removeEventListener('dblclick', this.editTokenWrapper);
-      this.clearSearchButton.removeEventListener('click', this.clearSearchWrapper);
-      document.removeEventListener('click', gl.FilteredSearchVisualTokens.unselectTokens);
-      document.removeEventListener('click', this.unselectEditTokensWrapper);
-      document.removeEventListener('click', this.removeInputContainerFocusWrapper);
-      document.removeEventListener('keydown', this.removeSelectedTokenWrapper);
-    }
+  bindEvents() {
+    this.handleFormSubmit = this.handleFormSubmit.bind(this);
+    this.setDropdownWrapper = this.dropdownManager.setDropdown.bind(this.dropdownManager);
+    this.toggleClearSearchButtonWrapper = this.toggleClearSearchButton.bind(this);
+    this.handleInputPlaceholderWrapper = this.handleInputPlaceholder.bind(this);
+    this.handleInputVisualTokenWrapper = this.handleInputVisualToken.bind(this);
+    this.checkForEnterWrapper = this.checkForEnter.bind(this);
+    this.clearSearchWrapper = this.clearSearch.bind(this);
+    this.checkForBackspaceWrapper = this.checkForBackspace.bind(this);
+    this.removeSelectedTokenWrapper = this.removeSelectedToken.bind(this);
+    this.unselectEditTokensWrapper = this.unselectEditTokens.bind(this);
+    this.editTokenWrapper = this.editToken.bind(this);
+    this.tokenChange = this.tokenChange.bind(this);
+    this.addInputContainerFocusWrapper = this.addInputContainerFocus.bind(this);
+    this.removeInputContainerFocusWrapper = this.removeInputContainerFocus.bind(this);
+
+    this.filteredSearchInputForm = this.filteredSearchInput.form;
+    this.filteredSearchInputForm.addEventListener('submit', this.handleFormSubmit);
+    this.filteredSearchInput.addEventListener('input', this.setDropdownWrapper);
+    this.filteredSearchInput.addEventListener('input', this.toggleClearSearchButtonWrapper);
+    this.filteredSearchInput.addEventListener('input', this.handleInputPlaceholderWrapper);
+    this.filteredSearchInput.addEventListener('input', this.handleInputVisualTokenWrapper);
+    this.filteredSearchInput.addEventListener('keydown', this.checkForEnterWrapper);
+    this.filteredSearchInput.addEventListener('keyup', this.checkForBackspaceWrapper);
+    this.filteredSearchInput.addEventListener('click', this.tokenChange);
+    this.filteredSearchInput.addEventListener('keyup', this.tokenChange);
+    this.filteredSearchInput.addEventListener('focus', this.addInputContainerFocusWrapper);
+    this.tokensContainer.addEventListener('click', FilteredSearchManager.selectToken);
+    this.tokensContainer.addEventListener('dblclick', this.editTokenWrapper);
+    this.clearSearchButton.addEventListener('click', this.clearSearchWrapper);
+    document.addEventListener('click', gl.FilteredSearchVisualTokens.unselectTokens);
+    document.addEventListener('click', this.unselectEditTokensWrapper);
+    document.addEventListener('click', this.removeInputContainerFocusWrapper);
+    document.addEventListener('keydown', this.removeSelectedTokenWrapper);
+  }
 
-    checkForBackspace(e) {
-      // 8 = Backspace Key
-      // 46 = Delete Key
-      if (e.keyCode === 8 || e.keyCode === 46) {
-        const { lastVisualToken } = gl.FilteredSearchVisualTokens.getLastVisualTokenBeforeInput();
+  unbindEvents() {
+    this.filteredSearchInputForm.removeEventListener('submit', this.handleFormSubmit);
+    this.filteredSearchInput.removeEventListener('input', this.setDropdownWrapper);
+    this.filteredSearchInput.removeEventListener('input', this.toggleClearSearchButtonWrapper);
+    this.filteredSearchInput.removeEventListener('input', this.handleInputPlaceholderWrapper);
+    this.filteredSearchInput.removeEventListener('input', this.handleInputVisualTokenWrapper);
+    this.filteredSearchInput.removeEventListener('keydown', this.checkForEnterWrapper);
+    this.filteredSearchInput.removeEventListener('keyup', this.checkForBackspaceWrapper);
+    this.filteredSearchInput.removeEventListener('click', this.tokenChange);
+    this.filteredSearchInput.removeEventListener('keyup', this.tokenChange);
+    this.filteredSearchInput.removeEventListener('focus', this.addInputContainerFocusWrapper);
+    this.tokensContainer.removeEventListener('click', FilteredSearchManager.selectToken);
+    this.tokensContainer.removeEventListener('dblclick', this.editTokenWrapper);
+    this.clearSearchButton.removeEventListener('click', this.clearSearchWrapper);
+    document.removeEventListener('click', gl.FilteredSearchVisualTokens.unselectTokens);
+    document.removeEventListener('click', this.unselectEditTokensWrapper);
+    document.removeEventListener('click', this.removeInputContainerFocusWrapper);
+    document.removeEventListener('keydown', this.removeSelectedTokenWrapper);
+  }
 
-        if (this.filteredSearchInput.value === '' && lastVisualToken) {
-          this.filteredSearchInput.value = gl.FilteredSearchVisualTokens.getLastTokenPartial();
-          gl.FilteredSearchVisualTokens.removeLastTokenPartial();
-        }
+  checkForBackspace(e) {
+    // 8 = Backspace Key
+    // 46 = Delete Key
+    if (e.keyCode === 8 || e.keyCode === 46) {
+      const { lastVisualToken } = gl.FilteredSearchVisualTokens.getLastVisualTokenBeforeInput();
 
-        // Reposition dropdown so that it is aligned with cursor
-        this.dropdownManager.updateCurrentDropdownOffset();
+      if (this.filteredSearchInput.value === '' && lastVisualToken) {
+        this.filteredSearchInput.value = gl.FilteredSearchVisualTokens.getLastTokenPartial();
+        gl.FilteredSearchVisualTokens.removeLastTokenPartial();
       }
-    }
 
-    checkForEnter(e) {
-      if (e.keyCode === 38 || e.keyCode === 40) {
-        const selectionStart = this.filteredSearchInput.selectionStart;
+      // Reposition dropdown so that it is aligned with cursor
+      this.dropdownManager.updateCurrentDropdownOffset();
+    }
+  }
 
-        e.preventDefault();
-        this.filteredSearchInput.setSelectionRange(selectionStart, selectionStart);
-      }
+  checkForEnter(e) {
+    if (e.keyCode === 38 || e.keyCode === 40) {
+      const selectionStart = this.filteredSearchInput.selectionStart;
 
-      if (e.keyCode === 13) {
-        const dropdown = this.dropdownManager.mapping[this.dropdownManager.currentDropdown];
-        const dropdownEl = dropdown.element;
-        const activeElements = dropdownEl.querySelectorAll('.dropdown-active');
+      e.preventDefault();
+      this.filteredSearchInput.setSelectionRange(selectionStart, selectionStart);
+    }
 
-        e.preventDefault();
+    if (e.keyCode === 13) {
+      const dropdown = this.dropdownManager.mapping[this.dropdownManager.currentDropdown];
+      const dropdownEl = dropdown.element;
+      const activeElements = dropdownEl.querySelectorAll('.dropdown-active');
 
-        if (!activeElements.length) {
-          if (this.isHandledAsync) {
-            e.stopImmediatePropagation();
+      e.preventDefault();
 
-            this.filteredSearchInput.blur();
-            this.dropdownManager.resetDropdowns();
-          } else {
-            // Prevent droplab from opening dropdown
-            this.dropdownManager.destroyDroplab();
-          }
+      if (!activeElements.length) {
+        if (this.isHandledAsync) {
+          e.stopImmediatePropagation();
 
-          this.search();
+          this.filteredSearchInput.blur();
+          this.dropdownManager.resetDropdowns();
+        } else {
+          // Prevent droplab from opening dropdown
+          this.dropdownManager.destroyDroplab();
         }
+
+        this.search();
       }
     }
+  }
 
-    addInputContainerFocus() {
-      const inputContainer = this.filteredSearchInput.closest('.filtered-search-input-container');
+  addInputContainerFocus() {
+    const inputContainer = this.filteredSearchInput.closest('.filtered-search-input-container');
 
-      if (inputContainer) {
-        inputContainer.classList.add('focus');
-      }
+    if (inputContainer) {
+      inputContainer.classList.add('focus');
     }
+  }
 
-    removeInputContainerFocus(e) {
-      const inputContainer = this.filteredSearchInput.closest('.filtered-search-input-container');
-      const isElementInFilteredSearch = inputContainer && inputContainer.contains(e.target);
-      const isElementInDynamicFilterDropdown = e.target.closest('.filter-dropdown') !== null;
-      const isElementInStaticFilterDropdown = e.target.closest('ul[data-dropdown]') !== null;
+  removeInputContainerFocus(e) {
+    const inputContainer = this.filteredSearchInput.closest('.filtered-search-input-container');
+    const isElementInFilteredSearch = inputContainer && inputContainer.contains(e.target);
+    const isElementInDynamicFilterDropdown = e.target.closest('.filter-dropdown') !== null;
+    const isElementInStaticFilterDropdown = e.target.closest('ul[data-dropdown]') !== null;
 
-      if (!isElementInFilteredSearch && !isElementInDynamicFilterDropdown &&
-        !isElementInStaticFilterDropdown && inputContainer) {
-        inputContainer.classList.remove('focus');
-      }
+    if (!isElementInFilteredSearch && !isElementInDynamicFilterDropdown &&
+      !isElementInStaticFilterDropdown && inputContainer) {
+      inputContainer.classList.remove('focus');
     }
+  }
 
-    static selectToken(e) {
-      const button = e.target.closest('.selectable');
+  static selectToken(e) {
+    const button = e.target.closest('.selectable');
 
-      if (button) {
-        e.preventDefault();
-        e.stopPropagation();
-        gl.FilteredSearchVisualTokens.selectToken(button);
-      }
+    if (button) {
+      e.preventDefault();
+      e.stopPropagation();
+      gl.FilteredSearchVisualTokens.selectToken(button);
     }
+  }
 
-    unselectEditTokens(e) {
-      const inputContainer = this.container.querySelector('.filtered-search-input-container');
-      const isElementInFilteredSearch = inputContainer && inputContainer.contains(e.target);
-      const isElementInFilterDropdown = e.target.closest('.filter-dropdown') !== null;
-      const isElementTokensContainer = e.target.classList.contains('tokens-container');
+  unselectEditTokens(e) {
+    const inputContainer = this.container.querySelector('.filtered-search-input-container');
+    const isElementInFilteredSearch = inputContainer && inputContainer.contains(e.target);
+    const isElementInFilterDropdown = e.target.closest('.filter-dropdown') !== null;
+    const isElementTokensContainer = e.target.classList.contains('tokens-container');
 
-      if ((!isElementInFilteredSearch && !isElementInFilterDropdown) || isElementTokensContainer) {
-        gl.FilteredSearchVisualTokens.moveInputToTheRight();
-        this.dropdownManager.resetDropdowns();
-      }
+    if ((!isElementInFilteredSearch && !isElementInFilterDropdown) || isElementTokensContainer) {
+      gl.FilteredSearchVisualTokens.moveInputToTheRight();
+      this.dropdownManager.resetDropdowns();
     }
+  }
 
-    editToken(e) {
-      const token = e.target.closest('.js-visual-token');
+  editToken(e) {
+    const token = e.target.closest('.js-visual-token');
 
-      if (token) {
-        gl.FilteredSearchVisualTokens.editToken(token);
-        this.tokenChange();
-      }
+    if (token) {
+      gl.FilteredSearchVisualTokens.editToken(token);
+      this.tokenChange();
     }
+  }
 
-    toggleClearSearchButton() {
-      const query = gl.DropdownUtils.getSearchQuery();
-      const hidden = 'hidden';
-      const hasHidden = this.clearSearchButton.classList.contains(hidden);
+  toggleClearSearchButton() {
+    const query = gl.DropdownUtils.getSearchQuery();
+    const hidden = 'hidden';
+    const hasHidden = this.clearSearchButton.classList.contains(hidden);
 
-      if (query.length === 0 && !hasHidden) {
-        this.clearSearchButton.classList.add(hidden);
-      } else if (query.length && hasHidden) {
-        this.clearSearchButton.classList.remove(hidden);
-      }
+    if (query.length === 0 && !hasHidden) {
+      this.clearSearchButton.classList.add(hidden);
+    } else if (query.length && hasHidden) {
+      this.clearSearchButton.classList.remove(hidden);
     }
+  }
 
-    handleInputPlaceholder() {
-      const query = gl.DropdownUtils.getSearchQuery();
-      const placeholder = 'Search or filter results...';
-      const currentPlaceholder = this.filteredSearchInput.placeholder;
+  handleInputPlaceholder() {
+    const query = gl.DropdownUtils.getSearchQuery();
+    const placeholder = 'Search or filter results...';
+    const currentPlaceholder = this.filteredSearchInput.placeholder;
 
-      if (query.length === 0 && currentPlaceholder !== placeholder) {
-        this.filteredSearchInput.placeholder = placeholder;
-      } else if (query.length > 0 && currentPlaceholder !== '') {
-        this.filteredSearchInput.placeholder = '';
-      }
+    if (query.length === 0 && currentPlaceholder !== placeholder) {
+      this.filteredSearchInput.placeholder = placeholder;
+    } else if (query.length > 0 && currentPlaceholder !== '') {
+      this.filteredSearchInput.placeholder = '';
     }
+  }
 
-    removeSelectedToken(e) {
-      // 8 = Backspace Key
-      // 46 = Delete Key
-      if (e.keyCode === 8 || e.keyCode === 46) {
-        gl.FilteredSearchVisualTokens.removeSelectedToken();
-        this.handleInputPlaceholder();
-        this.toggleClearSearchButton();
-      }
+  removeSelectedToken(e) {
+    // 8 = Backspace Key
+    // 46 = Delete Key
+    if (e.keyCode === 8 || e.keyCode === 46) {
+      gl.FilteredSearchVisualTokens.removeSelectedToken();
+      this.handleInputPlaceholder();
+      this.toggleClearSearchButton();
     }
+  }
 
-    clearSearch(e) {
-      e.preventDefault();
+  clearSearch(e) {
+    e.preventDefault();
 
-      this.filteredSearchInput.value = '';
+    this.filteredSearchInput.value = '';
 
-      const removeElements = [];
+    const removeElements = [];
 
-      [].forEach.call(this.tokensContainer.children, (t) => {
-        if (t.classList.contains('js-visual-token')) {
-          removeElements.push(t);
-        }
-      });
+    [].forEach.call(this.tokensContainer.children, (t) => {
+      if (t.classList.contains('js-visual-token')) {
+        removeElements.push(t);
+      }
+    });
 
-      removeElements.forEach((el) => {
-        el.parentElement.removeChild(el);
-      });
+    removeElements.forEach((el) => {
+      el.parentElement.removeChild(el);
+    });
 
-      this.clearSearchButton.classList.add('hidden');
-      this.handleInputPlaceholder();
+    this.clearSearchButton.classList.add('hidden');
+    this.handleInputPlaceholder();
 
-      this.dropdownManager.resetDropdowns();
+    this.dropdownManager.resetDropdowns();
 
-      if (this.isHandledAsync) {
-        this.search();
-      }
+    if (this.isHandledAsync) {
+      this.search();
     }
+  }
 
-    handleInputVisualToken() {
-      const input = this.filteredSearchInput;
-      const { tokens, searchToken }
-        = gl.FilteredSearchTokenizer.processTokens(input.value);
-      const { isLastVisualTokenValid }
-        = gl.FilteredSearchVisualTokens.getLastVisualTokenBeforeInput();
-
-      if (isLastVisualTokenValid) {
-        tokens.forEach((t) => {
-          input.value = input.value.replace(`${t.key}:${t.symbol}${t.value}`, '');
-          gl.FilteredSearchVisualTokens.addFilterVisualToken(t.key, `${t.symbol}${t.value}`);
-        });
-
-        const fragments = searchToken.split(':');
-        if (fragments.length > 1) {
-          const inputValues = fragments[0].split(' ');
-          const tokenKey = inputValues.last();
-
-          if (inputValues.length > 1) {
-            inputValues.pop();
-            const searchTerms = inputValues.join(' ');
-
-            input.value = input.value.replace(searchTerms, '');
-            gl.FilteredSearchVisualTokens.addSearchVisualToken(searchTerms);
-          }
+  handleInputVisualToken() {
+    const input = this.filteredSearchInput;
+    const { tokens, searchToken }
+      = gl.FilteredSearchTokenizer.processTokens(input.value);
+    const { isLastVisualTokenValid }
+      = gl.FilteredSearchVisualTokens.getLastVisualTokenBeforeInput();
+
+    if (isLastVisualTokenValid) {
+      tokens.forEach((t) => {
+        input.value = input.value.replace(`${t.key}:${t.symbol}${t.value}`, '');
+        gl.FilteredSearchVisualTokens.addFilterVisualToken(t.key, `${t.symbol}${t.value}`);
+      });
 
-          gl.FilteredSearchVisualTokens.addFilterVisualToken(tokenKey);
-          input.value = input.value.replace(`${tokenKey}:`, '');
-        }
-      } else {
-        // Keep listening to token until we determine that the user is done typing the token value
-        const valueCompletedRegex = /([~%@]{0,1}".+")|([~%@]{0,1}'.+')|^((?![~%@]')(?![~%@]")(?!')(?!")).*/g;
+      const fragments = searchToken.split(':');
+      if (fragments.length > 1) {
+        const inputValues = fragments[0].split(' ');
+        const tokenKey = inputValues.last();
 
-        if (searchToken.match(valueCompletedRegex) && input.value[input.value.length - 1] === ' ') {
-          gl.FilteredSearchVisualTokens.addFilterVisualToken(searchToken);
+        if (inputValues.length > 1) {
+          inputValues.pop();
+          const searchTerms = inputValues.join(' ');
 
-          // Trim the last space as seen in the if statement above
-          input.value = input.value.replace(searchToken, '').trim();
+          input.value = input.value.replace(searchTerms, '');
+          gl.FilteredSearchVisualTokens.addSearchVisualToken(searchTerms);
         }
+
+        gl.FilteredSearchVisualTokens.addFilterVisualToken(tokenKey);
+        input.value = input.value.replace(`${tokenKey}:`, '');
       }
-    }
+    } else {
+      // Keep listening to token until we determine that the user is done typing the token value
+      const valueCompletedRegex = /([~%@]{0,1}".+")|([~%@]{0,1}'.+')|^((?![~%@]')(?![~%@]")(?!')(?!")).*/g;
 
-    handleFormSubmit(e) {
-      e.preventDefault();
-      this.search();
+      if (searchToken.match(valueCompletedRegex) && input.value[input.value.length - 1] === ' ') {
+        gl.FilteredSearchVisualTokens.addFilterVisualToken(searchToken);
+
+        // Trim the last space as seen in the if statement above
+        input.value = input.value.replace(searchToken, '').trim();
+      }
     }
+  }
 
-    loadSearchParamsFromURL() {
-      const params = gl.utils.getUrlParamsArray();
-      const usernameParams = this.getUsernameParams();
-      let hasFilteredSearch = false;
+  handleFormSubmit(e) {
+    e.preventDefault();
+    this.search();
+  }
 
-      params.forEach((p) => {
-        const split = p.split('=');
-        const keyParam = decodeURIComponent(split[0]);
-        const value = split[1];
+  loadSearchParamsFromURL() {
+    const params = gl.utils.getUrlParamsArray();
+    const usernameParams = this.getUsernameParams();
+    let hasFilteredSearch = false;
 
-        // Check if it matches edge conditions listed in this.filteredSearchTokenKeys
-        const condition = this.filteredSearchTokenKeys.searchByConditionUrl(p);
+    params.forEach((p) => {
+      const split = p.split('=');
+      const keyParam = decodeURIComponent(split[0]);
+      const value = split[1];
 
-        if (condition) {
-          hasFilteredSearch = true;
-          gl.FilteredSearchVisualTokens.addFilterVisualToken(condition.tokenKey, condition.value);
-        } else {
-          // Sanitize value since URL converts spaces into +
-          // Replace before decode so that we know what was originally + versus the encoded +
-          const sanitizedValue = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : value;
-          const match = this.filteredSearchTokenKeys.searchByKeyParam(keyParam);
-
-          if (match) {
-            const indexOf = keyParam.indexOf('_');
-            const sanitizedKey = indexOf !== -1 ? keyParam.slice(0, keyParam.indexOf('_')) : keyParam;
-            const symbol = match.symbol;
-            let quotationsToUse = '';
-
-            if (sanitizedValue.indexOf(' ') !== -1) {
-              // Prefer ", but use ' if required
-              quotationsToUse = sanitizedValue.indexOf('"') === -1 ? '"' : '\'';
-            }
+      // Check if it matches edge conditions listed in this.filteredSearchTokenKeys
+      const condition = this.filteredSearchTokenKeys.searchByConditionUrl(p);
+
+      if (condition) {
+        hasFilteredSearch = true;
+        gl.FilteredSearchVisualTokens.addFilterVisualToken(condition.tokenKey, condition.value);
+      } else {
+        // Sanitize value since URL converts spaces into +
+        // Replace before decode so that we know what was originally + versus the encoded +
+        const sanitizedValue = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : value;
+        const match = this.filteredSearchTokenKeys.searchByKeyParam(keyParam);
+
+        if (match) {
+          const indexOf = keyParam.indexOf('_');
+          const sanitizedKey = indexOf !== -1 ? keyParam.slice(0, keyParam.indexOf('_')) : keyParam;
+          const symbol = match.symbol;
+          let quotationsToUse = '';
+
+          if (sanitizedValue.indexOf(' ') !== -1) {
+            // Prefer ", but use ' if required
+            quotationsToUse = sanitizedValue.indexOf('"') === -1 ? '"' : '\'';
+          }
 
+          hasFilteredSearch = true;
+          gl.FilteredSearchVisualTokens.addFilterVisualToken(sanitizedKey, `${symbol}${quotationsToUse}${sanitizedValue}${quotationsToUse}`);
+        } else if (!match && keyParam === 'assignee_id') {
+          const id = parseInt(value, 10);
+          if (usernameParams[id]) {
             hasFilteredSearch = true;
-            gl.FilteredSearchVisualTokens.addFilterVisualToken(sanitizedKey, `${symbol}${quotationsToUse}${sanitizedValue}${quotationsToUse}`);
-          } else if (!match && keyParam === 'assignee_id') {
-            const id = parseInt(value, 10);
-            if (usernameParams[id]) {
-              hasFilteredSearch = true;
-              gl.FilteredSearchVisualTokens.addFilterVisualToken('assignee', `@${usernameParams[id]}`);
-            }
-          } else if (!match && keyParam === 'author_id') {
-            const id = parseInt(value, 10);
-            if (usernameParams[id]) {
-              hasFilteredSearch = true;
-              gl.FilteredSearchVisualTokens.addFilterVisualToken('author', `@${usernameParams[id]}`);
-            }
-          } else if (!match && keyParam === 'search') {
+            gl.FilteredSearchVisualTokens.addFilterVisualToken('assignee', `@${usernameParams[id]}`);
+          }
+        } else if (!match && keyParam === 'author_id') {
+          const id = parseInt(value, 10);
+          if (usernameParams[id]) {
             hasFilteredSearch = true;
-            this.filteredSearchInput.value = sanitizedValue;
+            gl.FilteredSearchVisualTokens.addFilterVisualToken('author', `@${usernameParams[id]}`);
           }
+        } else if (!match && keyParam === 'search') {
+          hasFilteredSearch = true;
+          this.filteredSearchInput.value = sanitizedValue;
         }
-      });
-
-      if (hasFilteredSearch) {
-        this.clearSearchButton.classList.remove('hidden');
-        this.handleInputPlaceholder();
       }
-    }
+    });
 
-    search() {
-      const paths = [];
-      const { tokens, searchToken }
-        = this.tokenizer.processTokens(gl.DropdownUtils.getSearchQuery());
-      const currentState = gl.utils.getParameterByName('state') || 'opened';
-      paths.push(`state=${currentState}`);
-
-      tokens.forEach((token) => {
-        const condition = this.filteredSearchTokenKeys
-          .searchByConditionKeyValue(token.key, token.value.toLowerCase());
-        const { param } = this.filteredSearchTokenKeys.searchByKey(token.key) || {};
-        const keyParam = param ? `${token.key}_${param}` : token.key;
-        let tokenPath = '';
-
-        if (condition) {
-          tokenPath = condition.url;
-        } else {
-          let tokenValue = token.value;
+    if (hasFilteredSearch) {
+      this.clearSearchButton.classList.remove('hidden');
+      this.handleInputPlaceholder();
+    }
+  }
 
-          if ((tokenValue[0] === '\'' && tokenValue[tokenValue.length - 1] === '\'') ||
-            (tokenValue[0] === '"' && tokenValue[tokenValue.length - 1] === '"')) {
-            tokenValue = tokenValue.slice(1, tokenValue.length - 1);
-          }
+  search() {
+    const paths = [];
+    const { tokens, searchToken }
+      = this.tokenizer.processTokens(gl.DropdownUtils.getSearchQuery());
+    const currentState = gl.utils.getParameterByName('state') || 'opened';
+    paths.push(`state=${currentState}`);
+
+    tokens.forEach((token) => {
+      const condition = this.filteredSearchTokenKeys
+        .searchByConditionKeyValue(token.key, token.value.toLowerCase());
+      const { param } = this.filteredSearchTokenKeys.searchByKey(token.key) || {};
+      const keyParam = param ? `${token.key}_${param}` : token.key;
+      let tokenPath = '';
+
+      if (condition) {
+        tokenPath = condition.url;
+      } else {
+        let tokenValue = token.value;
 
-          tokenPath = `${keyParam}=${encodeURIComponent(tokenValue)}`;
+        if ((tokenValue[0] === '\'' && tokenValue[tokenValue.length - 1] === '\'') ||
+          (tokenValue[0] === '"' && tokenValue[tokenValue.length - 1] === '"')) {
+          tokenValue = tokenValue.slice(1, tokenValue.length - 1);
         }
 
-        paths.push(tokenPath);
-      });
-
-      if (searchToken) {
-        const sanitized = searchToken.split(' ').map(t => encodeURIComponent(t)).join('+');
-        paths.push(`search=${sanitized}`);
+        tokenPath = `${keyParam}=${encodeURIComponent(tokenValue)}`;
       }
 
-      const parameterizedUrl = `?scope=all&utf8=%E2%9C%93&${paths.join('&')}`;
+      paths.push(tokenPath);
+    });
 
-      if (this.updateObject) {
-        this.updateObject(parameterizedUrl);
-      } else {
-        gl.utils.visitUrl(parameterizedUrl);
-      }
+    if (searchToken) {
+      const sanitized = searchToken.split(' ').map(t => encodeURIComponent(t)).join('+');
+      paths.push(`search=${sanitized}`);
     }
 
-    getUsernameParams() {
-      const usernamesById = {};
-      try {
-        const attribute = this.filteredSearchInput.getAttribute('data-username-params');
-        JSON.parse(attribute).forEach((user) => {
-          usernamesById[user.id] = user.username;
-        });
-      } catch (e) {
-        // do nothing
-      }
-      return usernamesById;
+    const parameterizedUrl = `?scope=all&utf8=%E2%9C%93&${paths.join('&')}`;
+
+    if (this.updateObject) {
+      this.updateObject(parameterizedUrl);
+    } else {
+      gl.utils.visitUrl(parameterizedUrl);
     }
+  }
 
-    tokenChange() {
-      const dropdown = this.dropdownManager.mapping[this.dropdownManager.currentDropdown];
+  getUsernameParams() {
+    const usernamesById = {};
+    try {
+      const attribute = this.filteredSearchInput.getAttribute('data-username-params');
+      JSON.parse(attribute).forEach((user) => {
+        usernamesById[user.id] = user.username;
+      });
+    } catch (e) {
+      // do nothing
+    }
+    return usernamesById;
+  }
 
-      if (dropdown) {
-        const currentDropdownRef = dropdown.reference;
+  tokenChange() {
+    const dropdown = this.dropdownManager.mapping[this.dropdownManager.currentDropdown];
 
-        this.setDropdownWrapper();
-        currentDropdownRef.dispatchInputEvent();
-      }
+    if (dropdown) {
+      const currentDropdownRef = dropdown.reference;
+
+      this.setDropdownWrapper();
+      currentDropdownRef.dispatchInputEvent();
     }
   }
+}
 
-  window.gl = window.gl || {};
-  gl.FilteredSearchManager = FilteredSearchManager;
-})();
+window.gl = window.gl || {};
+gl.FilteredSearchManager = FilteredSearchManager;
diff --git a/app/assets/javascripts/filtered_search/filtered_search_token_keys.js b/app/assets/javascripts/filtered_search/filtered_search_token_keys.js
index 6d5df86f2a5..1abad9d1b73 100644
--- a/app/assets/javascripts/filtered_search/filtered_search_token_keys.js
+++ b/app/assets/javascripts/filtered_search/filtered_search_token_keys.js
@@ -1,100 +1,98 @@
-(() => {
-  const tokenKeys = [{
-    key: 'author',
-    type: 'string',
-    param: 'username',
-    symbol: '@',
-  }, {
-    key: 'assignee',
-    type: 'string',
-    param: 'username',
-    symbol: '@',
-  }, {
-    key: 'milestone',
-    type: 'string',
-    param: 'title',
-    symbol: '%',
-  }, {
-    key: 'label',
-    type: 'array',
-    param: 'name[]',
-    symbol: '~',
-  }];
+const tokenKeys = [{
+  key: 'author',
+  type: 'string',
+  param: 'username',
+  symbol: '@',
+}, {
+  key: 'assignee',
+  type: 'string',
+  param: 'username',
+  symbol: '@',
+}, {
+  key: 'milestone',
+  type: 'string',
+  param: 'title',
+  symbol: '%',
+}, {
+  key: 'label',
+  type: 'array',
+  param: 'name[]',
+  symbol: '~',
+}];
 
-  const alternativeTokenKeys = [{
-    key: 'label',
-    type: 'string',
-    param: 'name',
-    symbol: '~',
-  }];
+const alternativeTokenKeys = [{
+  key: 'label',
+  type: 'string',
+  param: 'name',
+  symbol: '~',
+}];
 
-  const tokenKeysWithAlternative = tokenKeys.concat(alternativeTokenKeys);
+const tokenKeysWithAlternative = tokenKeys.concat(alternativeTokenKeys);
 
-  const conditions = [{
-    url: 'assignee_id=0',
-    tokenKey: 'assignee',
-    value: 'none',
-  }, {
-    url: 'milestone_title=No+Milestone',
-    tokenKey: 'milestone',
-    value: 'none',
-  }, {
-    url: 'milestone_title=%23upcoming',
-    tokenKey: 'milestone',
-    value: 'upcoming',
-  }, {
-    url: 'milestone_title=%23started',
-    tokenKey: 'milestone',
-    value: 'started',
-  }, {
-    url: 'label_name[]=No+Label',
-    tokenKey: 'label',
-    value: 'none',
-  }];
+const conditions = [{
+  url: 'assignee_id=0',
+  tokenKey: 'assignee',
+  value: 'none',
+}, {
+  url: 'milestone_title=No+Milestone',
+  tokenKey: 'milestone',
+  value: 'none',
+}, {
+  url: 'milestone_title=%23upcoming',
+  tokenKey: 'milestone',
+  value: 'upcoming',
+}, {
+  url: 'milestone_title=%23started',
+  tokenKey: 'milestone',
+  value: 'started',
+}, {
+  url: 'label_name[]=No+Label',
+  tokenKey: 'label',
+  value: 'none',
+}];
 
-  class FilteredSearchTokenKeys {
-    static get() {
-      return tokenKeys;
-    }
+class FilteredSearchTokenKeys {
+  static get() {
+    return tokenKeys;
+  }
 
-    static getAlternatives() {
-      return alternativeTokenKeys;
-    }
+  static getAlternatives() {
+    return alternativeTokenKeys;
+  }
 
-    static getConditions() {
-      return conditions;
-    }
+  static getConditions() {
+    return conditions;
+  }
 
-    static searchByKey(key) {
-      return tokenKeys.find(tokenKey => tokenKey.key === key) || null;
-    }
+  static searchByKey(key) {
+    return tokenKeys.find(tokenKey => tokenKey.key === key) || null;
+  }
 
-    static searchBySymbol(symbol) {
-      return tokenKeys.find(tokenKey => tokenKey.symbol === symbol) || null;
-    }
+  static searchBySymbol(symbol) {
+    return tokenKeys.find(tokenKey => tokenKey.symbol === symbol) || null;
+  }
 
-    static searchByKeyParam(keyParam) {
-      return tokenKeysWithAlternative.find((tokenKey) => {
-        let tokenKeyParam = tokenKey.key;
+  static searchByKeyParam(keyParam) {
+    return tokenKeysWithAlternative.find((tokenKey) => {
+      let tokenKeyParam = tokenKey.key;
 
-        if (tokenKey.param) {
-          tokenKeyParam += `_${tokenKey.param}`;
-        }
+      if (tokenKey.param) {
+        tokenKeyParam += `_${tokenKey.param}`;
+      }
 
-        return keyParam === tokenKeyParam;
-      }) || null;
-    }
+      return keyParam === tokenKeyParam;
+    }) || null;
+  }
 
-    static searchByConditionUrl(url) {
-      return conditions.find(condition => condition.url === url) || null;
-    }
+  static searchByConditionUrl(url) {
+    return conditions.find(condition => condition.url === url) || null;
+  }
 
-    static searchByConditionKeyValue(key, value) {
-      return conditions
-        .find(condition => condition.tokenKey === key && condition.value === value) || null;
-    }
+  static searchByConditionKeyValue(key, value) {
+    return conditions
+      .find(condition => condition.tokenKey === key && condition.value === value) || null;
   }
+}
 
-  window.gl = window.gl || {};
-  gl.FilteredSearchTokenKeys = FilteredSearchTokenKeys;
-})();
+window.gl = window.gl || {};
+gl.FilteredSearchTokenKeys = FilteredSearchTokenKeys;
diff --git a/app/assets/javascripts/filtered_search/filtered_search_tokenizer.js b/app/assets/javascripts/filtered_search/filtered_search_tokenizer.js
index a2729dc0e95..2808e4b238a 100644
--- a/app/assets/javascripts/filtered_search/filtered_search_tokenizer.js
+++ b/app/assets/javascripts/filtered_search/filtered_search_tokenizer.js
@@ -1,58 +1,56 @@
 require('./filtered_search_token_keys');
 
-(() => {
-  class FilteredSearchTokenizer {
-    static processTokens(input) {
-      const allowedKeys = gl.FilteredSearchTokenKeys.get().map(i => i.key);
-      // Regex extracts `(token):(symbol)(value)`
-      // Values that start with a double quote must end in a double quote (same for single)
-      const tokenRegex = new RegExp(`(${allowedKeys.join('|')}):([~%@]?)(?:('[^']*'{0,1})|("[^"]*"{0,1})|(\\S+))`, 'g');
-      const tokens = [];
-      const tokenIndexes = []; // stores key+value for simple search
-      let lastToken = null;
-      const searchToken = input.replace(tokenRegex, (match, key, symbol, v1, v2, v3) => {
-        let tokenValue = v1 || v2 || v3;
-        let tokenSymbol = symbol;
-        let tokenIndex = '';
-
-        if (tokenValue === '~' || tokenValue === '%' || tokenValue === '@') {
-          tokenSymbol = tokenValue;
-          tokenValue = '';
-        }
-
-        tokenIndex = `${key}:${tokenValue}`;
-
-        // Prevent adding duplicates
-        if (tokenIndexes.indexOf(tokenIndex) === -1) {
-          tokenIndexes.push(tokenIndex);
-
-          tokens.push({
-            key,
-            value: tokenValue || '',
-            symbol: tokenSymbol || '',
-          });
-        }
-
-        return '';
-      }).replace(/\s{2,}/g, ' ').trim() || '';
-
-      if (tokens.length > 0) {
-        const last = tokens[tokens.length - 1];
-        const lastString = `${last.key}:${last.symbol}${last.value}`;
-        lastToken = input.lastIndexOf(lastString) ===
-          input.length - lastString.length ? last : searchToken;
-      } else {
-        lastToken = searchToken;
+class FilteredSearchTokenizer {
+  static processTokens(input) {
+    const allowedKeys = gl.FilteredSearchTokenKeys.get().map(i => i.key);
+    // Regex extracts `(token):(symbol)(value)`
+    // Values that start with a double quote must end in a double quote (same for single)
+    const tokenRegex = new RegExp(`(${allowedKeys.join('|')}):([~%@]?)(?:('[^']*'{0,1})|("[^"]*"{0,1})|(\\S+))`, 'g');
+    const tokens = [];
+    const tokenIndexes = []; // stores key+value for simple search
+    let lastToken = null;
+    const searchToken = input.replace(tokenRegex, (match, key, symbol, v1, v2, v3) => {
+      let tokenValue = v1 || v2 || v3;
+      let tokenSymbol = symbol;
+      let tokenIndex = '';
+
+      if (tokenValue === '~' || tokenValue === '%' || tokenValue === '@') {
+        tokenSymbol = tokenValue;
+        tokenValue = '';
       }
 
-      return {
-        tokens,
-        lastToken,
-        searchToken,
-      };
+      tokenIndex = `${key}:${tokenValue}`;
+
+      // Prevent adding duplicates
+      if (tokenIndexes.indexOf(tokenIndex) === -1) {
+        tokenIndexes.push(tokenIndex);
+
+        tokens.push({
+          key,
+          value: tokenValue || '',
+          symbol: tokenSymbol || '',
+        });
+      }
+
+      return '';
+    }).replace(/\s{2,}/g, ' ').trim() || '';
+
+    if (tokens.length > 0) {
+      const last = tokens[tokens.length - 1];
+      const lastString = `${last.key}:${last.symbol}${last.value}`;
+      lastToken = input.lastIndexOf(lastString) ===
+        input.length - lastString.length ? last : searchToken;
+    } else {
+      lastToken = searchToken;
     }
+
+    return {
+      tokens,
+      lastToken,
+      searchToken,
+    };
   }
+}
 
-  window.gl = window.gl || {};
-  gl.FilteredSearchTokenizer = FilteredSearchTokenizer;
-})();
+window.gl = window.gl || {};
+gl.FilteredSearchTokenizer = FilteredSearchTokenizer;
diff --git a/app/assets/javascripts/flash.js b/app/assets/javascripts/flash.js
index eec30624ff2..afac7e972ef 100644
--- a/app/assets/javascripts/flash.js
+++ b/app/assets/javascripts/flash.js
@@ -1,41 +1,35 @@
 /* eslint-disable func-names, space-before-function-paren, wrap-iife, no-var, one-var, one-var-declaration-per-line, no-param-reassign, quotes, quote-props, prefer-template, comma-dangle, max-len */
 
-window.Flash = (function() {
-  var hideFlash;
-
-  hideFlash = function() {
+function Flash(message, type, parent) {
+  var flash, textDiv;
+  if (type == null) {
+    type = 'alert';
+  }
+  if (parent == null) {
+    parent = null;
+  }
+  if (parent) {
+    this.flashContainer = parent.find('.flash-container');
+  } else {
+    this.flashContainer = $('.flash-container-page');
+  }
+  this.flashContainer.html('');
+  flash = $('<div/>', {
+    "class": "flash-" + type
+  });
+  flash.on('click', function() {
     return $(this).fadeOut();
-  };
-
-  function Flash(message, type, parent) {
-    var flash, textDiv;
-    if (type == null) {
-      type = 'alert';
-    }
-    if (parent == null) {
-      parent = null;
-    }
-    if (parent) {
-      this.flashContainer = parent.find('.flash-container');
-    } else {
-      this.flashContainer = $('.flash-container-page');
-    }
-    this.flashContainer.html('');
-    flash = $('<div/>', {
-      "class": "flash-" + type
-    });
-    flash.on('click', hideFlash);
-    textDiv = $('<div/>', {
-      "class": 'flash-text',
-      text: message
-    });
-    textDiv.appendTo(flash);
-    if (this.flashContainer.parent().hasClass('content-wrapper')) {
-      textDiv.addClass('container-fluid container-limited');
-    }
-    flash.appendTo(this.flashContainer);
-    this.flashContainer.show();
+  });
+  textDiv = $('<div/>', {
+    "class": 'flash-text',
+    text: message
+  });
+  textDiv.appendTo(flash);
+  if (this.flashContainer.parent().hasClass('content-wrapper')) {
+    textDiv.addClass('container-fluid container-limited');
   }
+  flash.appendTo(this.flashContainer);
+  this.flashContainer.show();
+}
 
-  return Flash;
-})();
+window.Flash = Flash;
diff --git a/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js b/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js
index a1da3396d7b..17bf8932489 100644
--- a/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js
+++ b/spec/javascripts/filtered_search/filtered_search_dropdown_manager_spec.js
@@ -3,99 +3,97 @@ require('~/filtered_search/filtered_search_visual_tokens');
 require('~/filtered_search/filtered_search_tokenizer');
 require('~/filtered_search/filtered_search_dropdown_manager');
 
-(() => {
-  describe('Filtered Search Dropdown Manager', () => {
-    describe('addWordToInput', () => {
-      function getInputValue() {
-        return document.querySelector('.filtered-search').value;
-      }
-
-      function setInputValue(value) {
-        document.querySelector('.filtered-search').value = value;
-      }
-
-      beforeEach(() => {
-        setFixtures(`
-          <ul class="tokens-container">
-            <li class="input-token">
-              <input class="filtered-search">
-            </li>
-          </ul>
-        `);
-      });
+describe('Filtered Search Dropdown Manager', () => {
+  describe('addWordToInput', () => {
+    function getInputValue() {
+      return document.querySelector('.filtered-search').value;
+    }
+
+    function setInputValue(value) {
+      document.querySelector('.filtered-search').value = value;
+    }
+
+    beforeEach(() => {
+      setFixtures(`
+        <ul class="tokens-container">
+          <li class="input-token">
+            <input class="filtered-search">
+          </li>
+        </ul>
+      `);
+    });
 
-      describe('input has no existing value', () => {
-        it('should add just tokenName', () => {
-          gl.FilteredSearchDropdownManager.addWordToInput('milestone');
+    describe('input has no existing value', () => {
+      it('should add just tokenName', () => {
+        gl.FilteredSearchDropdownManager.addWordToInput('milestone');
 
-          const token = document.querySelector('.tokens-container .js-visual-token');
+        const token = document.querySelector('.tokens-container .js-visual-token');
 
-          expect(token.classList.contains('filtered-search-token')).toEqual(true);
-          expect(token.querySelector('.name').innerText).toBe('milestone');
-          expect(getInputValue()).toBe('');
-        });
+        expect(token.classList.contains('filtered-search-token')).toEqual(true);
+        expect(token.querySelector('.name').innerText).toBe('milestone');
+        expect(getInputValue()).toBe('');
+      });
 
-        it('should add tokenName and tokenValue', () => {
-          gl.FilteredSearchDropdownManager.addWordToInput('label');
+      it('should add tokenName and tokenValue', () => {
+        gl.FilteredSearchDropdownManager.addWordToInput('label');
 
-          let token = document.querySelector('.tokens-container .js-visual-token');
+        let token = document.querySelector('.tokens-container .js-visual-token');
 
-          expect(token.classList.contains('filtered-search-token')).toEqual(true);
-          expect(token.querySelector('.name').innerText).toBe('label');
-          expect(getInputValue()).toBe('');
+        expect(token.classList.contains('filtered-search-token')).toEqual(true);
+        expect(token.querySelector('.name').innerText).toBe('label');
+        expect(getInputValue()).toBe('');
 
-          gl.FilteredSearchDropdownManager.addWordToInput('label', 'none');
-          // We have to get that reference again
-          // Because gl.FilteredSearchDropdownManager deletes the previous token
-          token = document.querySelector('.tokens-container .js-visual-token');
+        gl.FilteredSearchDropdownManager.addWordToInput('label', 'none');
+        // We have to get that reference again
+        // Because gl.FilteredSearchDropdownManager deletes the previous token
+        token = document.querySelector('.tokens-container .js-visual-token');
 
-          expect(token.classList.contains('filtered-search-token')).toEqual(true);
-          expect(token.querySelector('.name').innerText).toBe('label');
-          expect(token.querySelector('.value').innerText).toBe('none');
-          expect(getInputValue()).toBe('');
-        });
+        expect(token.classList.contains('filtered-search-token')).toEqual(true);
+        expect(token.querySelector('.name').innerText).toBe('label');
+        expect(token.querySelector('.value').innerText).toBe('none');
+        expect(getInputValue()).toBe('');
       });
+    });
 
-      describe('input has existing value', () => {
-        it('should be able to just add tokenName', () => {
-          setInputValue('a');
-          gl.FilteredSearchDropdownManager.addWordToInput('author');
+    describe('input has existing value', () => {
+      it('should be able to just add tokenName', () => {
+        setInputValue('a');
+        gl.FilteredSearchDropdownManager.addWordToInput('author');
 
-          const token = document.querySelector('.tokens-container .js-visual-token');
+        const token = document.querySelector('.tokens-container .js-visual-token');
 
-          expect(token.classList.contains('filtered-search-token')).toEqual(true);
-          expect(token.querySelector('.name').innerText).toBe('author');
-          expect(getInputValue()).toBe('');
-        });
+        expect(token.classList.contains('filtered-search-token')).toEqual(true);
+        expect(token.querySelector('.name').innerText).toBe('author');
+        expect(getInputValue()).toBe('');
+      });
 
-        it('should replace tokenValue', () => {
-          gl.FilteredSearchDropdownManager.addWordToInput('author');
+      it('should replace tokenValue', () => {
+        gl.FilteredSearchDropdownManager.addWordToInput('author');
 
-          setInputValue('roo');
-          gl.FilteredSearchDropdownManager.addWordToInput(null, '@root');
+        setInputValue('roo');
+        gl.FilteredSearchDropdownManager.addWordToInput(null, '@root');
 
-          const token = document.querySelector('.tokens-container .js-visual-token');
+        const token = document.querySelector('.tokens-container .js-visual-token');
 
-          expect(token.classList.contains('filtered-search-token')).toEqual(true);
-          expect(token.querySelector('.name').innerText).toBe('author');
-          expect(token.querySelector('.value').innerText).toBe('@root');
-          expect(getInputValue()).toBe('');
-        });
+        expect(token.classList.contains('filtered-search-token')).toEqual(true);
+        expect(token.querySelector('.name').innerText).toBe('author');
+        expect(token.querySelector('.value').innerText).toBe('@root');
+        expect(getInputValue()).toBe('');
+      });
 
-        it('should add tokenValues containing spaces', () => {
-          gl.FilteredSearchDropdownManager.addWordToInput('label');
+      it('should add tokenValues containing spaces', () => {
+        gl.FilteredSearchDropdownManager.addWordToInput('label');
 
-          setInputValue('"test ');
-          gl.FilteredSearchDropdownManager.addWordToInput('label', '~\'"test me"\'');
+        setInputValue('"test ');
+        gl.FilteredSearchDropdownManager.addWordToInput('label', '~\'"test me"\'');
 
-          const token = document.querySelector('.tokens-container .js-visual-token');
+        const token = document.querySelector('.tokens-container .js-visual-token');
 
-          expect(token.classList.contains('filtered-search-token')).toEqual(true);
-          expect(token.querySelector('.name').innerText).toBe('label');
-          expect(token.querySelector('.value').innerText).toBe('~\'"test me"\'');
-          expect(getInputValue()).toBe('');
-        });
+        expect(token.classList.contains('filtered-search-token')).toEqual(true);
+        expect(token.querySelector('.name').innerText).toBe('label');
+        expect(token.querySelector('.value').innerText).toBe('~\'"test me"\'');
+        expect(getInputValue()).toBe('');
       });
     });
   });
-})();
+});
diff --git a/spec/javascripts/filtered_search/filtered_search_manager_spec.js b/spec/javascripts/filtered_search/filtered_search_manager_spec.js
index 5f7c05e9014..22418ba2591 100644
--- a/spec/javascripts/filtered_search/filtered_search_manager_spec.js
+++ b/spec/javascripts/filtered_search/filtered_search_manager_spec.js
@@ -6,271 +6,269 @@ require('~/filtered_search/filtered_search_dropdown_manager');
 require('~/filtered_search/filtered_search_manager');
 const FilteredSearchSpecHelper = require('../helpers/filtered_search_spec_helper');
 
-(() => {
-  describe('Filtered Search Manager', () => {
-    let input;
-    let manager;
-    let tokensContainer;
-    const placeholder = 'Search or filter results...';
-
-    function dispatchBackspaceEvent(element, eventType) {
-      const backspaceKey = 8;
-      const event = new Event(eventType);
-      event.keyCode = backspaceKey;
-      element.dispatchEvent(event);
-    }
+describe('Filtered Search Manager', () => {
+  let input;
+  let manager;
+  let tokensContainer;
+  const placeholder = 'Search or filter results...';
+
+  function dispatchBackspaceEvent(element, eventType) {
+    const backspaceKey = 8;
+    const event = new Event(eventType);
+    event.keyCode = backspaceKey;
+    element.dispatchEvent(event);
+  }
+
+  function dispatchDeleteEvent(element, eventType) {
+    const deleteKey = 46;
+    const event = new Event(eventType);
+    event.keyCode = deleteKey;
+    element.dispatchEvent(event);
+  }
+
+  beforeEach(() => {
+    setFixtures(`
+      <div class="filtered-search-input-container">
+        <form>
+          <ul class="tokens-container list-unstyled">
+            ${FilteredSearchSpecHelper.createInputHTML(placeholder)}
+          </ul>
+          <button class="clear-search" type="button">
+            <i class="fa fa-times"></i>
+          </button>
+        </form>
+      </div>
+    `);
+
+    spyOn(gl.FilteredSearchManager.prototype, 'loadSearchParamsFromURL').and.callFake(() => {});
+    spyOn(gl.FilteredSearchManager.prototype, 'tokenChange').and.callFake(() => {});
+    spyOn(gl.FilteredSearchDropdownManager.prototype, 'setDropdown').and.callFake(() => {});
+    spyOn(gl.FilteredSearchDropdownManager.prototype, 'updateDropdownOffset').and.callFake(() => {});
+    spyOn(gl.utils, 'getParameterByName').and.returnValue(null);
+    spyOn(gl.FilteredSearchVisualTokens, 'unselectTokens').and.callThrough();
+
+    input = document.querySelector('.filtered-search');
+    tokensContainer = document.querySelector('.tokens-container');
+    manager = new gl.FilteredSearchManager();
+  });
 
-    function dispatchDeleteEvent(element, eventType) {
-      const deleteKey = 46;
-      const event = new Event(eventType);
-      event.keyCode = deleteKey;
-      element.dispatchEvent(event);
-    }
+  afterEach(() => {
+    manager.cleanup();
+  });
 
-    beforeEach(() => {
-      setFixtures(`
-        <div class="filtered-search-input-container">
-          <form>
-            <ul class="tokens-container list-unstyled">
-              ${FilteredSearchSpecHelper.createInputHTML(placeholder)}
-            </ul>
-            <button class="clear-search" type="button">
-              <i class="fa fa-times"></i>
-            </button>
-          </form>
-        </div>
-      `);
+  describe('search', () => {
+    const defaultParams = '?scope=all&utf8=%E2%9C%93&state=opened';
 
-      spyOn(gl.FilteredSearchManager.prototype, 'loadSearchParamsFromURL').and.callFake(() => {});
-      spyOn(gl.FilteredSearchManager.prototype, 'tokenChange').and.callFake(() => {});
-      spyOn(gl.FilteredSearchDropdownManager.prototype, 'setDropdown').and.callFake(() => {});
-      spyOn(gl.FilteredSearchDropdownManager.prototype, 'updateDropdownOffset').and.callFake(() => {});
-      spyOn(gl.utils, 'getParameterByName').and.returnValue(null);
-      spyOn(gl.FilteredSearchVisualTokens, 'unselectTokens').and.callThrough();
+    it('should search with a single word', (done) => {
+      input.value = 'searchTerm';
 
-      input = document.querySelector('.filtered-search');
-      tokensContainer = document.querySelector('.tokens-container');
-      manager = new gl.FilteredSearchManager();
-    });
+      spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
+        expect(url).toEqual(`${defaultParams}&search=searchTerm`);
+        done();
+      });
 
-    afterEach(() => {
-      manager.cleanup();
+      manager.search();
     });
 
-    describe('search', () => {
-      const defaultParams = '?scope=all&utf8=%E2%9C%93&state=opened';
-
-      it('should search with a single word', (done) => {
-        input.value = 'searchTerm';
+    it('should search with multiple words', (done) => {
+      input.value = 'awesome search terms';
 
-        spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
-          expect(url).toEqual(`${defaultParams}&search=searchTerm`);
-          done();
-        });
-
-        manager.search();
+      spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
+        expect(url).toEqual(`${defaultParams}&search=awesome+search+terms`);
+        done();
       });
 
-      it('should search with multiple words', (done) => {
-        input.value = 'awesome search terms';
+      manager.search();
+    });
 
-        spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
-          expect(url).toEqual(`${defaultParams}&search=awesome+search+terms`);
-          done();
-        });
+    it('should search with special characters', (done) => {
+      input.value = '~!@#$%^&*()_+{}:<>,.?/';
 
-        manager.search();
+      spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
+        expect(url).toEqual(`${defaultParams}&search=~!%40%23%24%25%5E%26*()_%2B%7B%7D%3A%3C%3E%2C.%3F%2F`);
+        done();
       });
 
-      it('should search with special characters', (done) => {
-        input.value = '~!@#$%^&*()_+{}:<>,.?/';
+      manager.search();
+    });
 
-        spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
-          expect(url).toEqual(`${defaultParams}&search=~!%40%23%24%25%5E%26*()_%2B%7B%7D%3A%3C%3E%2C.%3F%2F`);
-          done();
-        });
+    it('removes duplicated tokens', (done) => {
+      tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(`
+        ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug')}
+        ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug')}
+      `);
 
-        manager.search();
+      spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
+        expect(url).toEqual(`${defaultParams}&label_name[]=bug`);
+        done();
       });
 
-      it('removes duplicated tokens', (done) => {
-        tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(`
-          ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug')}
-          ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug')}
-        `);
-
-        spyOn(gl.utils, 'visitUrl').and.callFake((url) => {
-          expect(url).toEqual(`${defaultParams}&label_name[]=bug`);
-          done();
-        });
+      manager.search();
+    });
+  });
 
-        manager.search();
-      });
+  describe('handleInputPlaceholder', () => {
+    it('should render placeholder when there is no input', () => {
+      expect(input.placeholder).toEqual(placeholder);
     });
 
-    describe('handleInputPlaceholder', () => {
-      it('should render placeholder when there is no input', () => {
-        expect(input.placeholder).toEqual(placeholder);
-      });
+    it('should not render placeholder when there is input', () => {
+      input.value = 'test words';
+
+      const event = new Event('input');
+      input.dispatchEvent(event);
 
-      it('should not render placeholder when there is input', () => {
-        input.value = 'test words';
+      expect(input.placeholder).toEqual('');
+    });
 
-        const event = new Event('input');
-        input.dispatchEvent(event);
+    it('should not render placeholder when there are tokens and no input', () => {
+      tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(
+        FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug'),
+      );
 
-        expect(input.placeholder).toEqual('');
-      });
+      const event = new Event('input');
+      input.dispatchEvent(event);
 
-      it('should not render placeholder when there are tokens and no input', () => {
+      expect(input.placeholder).toEqual('');
+    });
+  });
+
+  describe('checkForBackspace', () => {
+    describe('tokens and no input', () => {
+      beforeEach(() => {
         tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(
           FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug'),
         );
-
-        const event = new Event('input');
-        input.dispatchEvent(event);
-
-        expect(input.placeholder).toEqual('');
       });
-    });
-
-    describe('checkForBackspace', () => {
-      describe('tokens and no input', () => {
-        beforeEach(() => {
-          tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(
-            FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug'),
-          );
-        });
 
-        it('removes last token', () => {
-          spyOn(gl.FilteredSearchVisualTokens, 'removeLastTokenPartial').and.callThrough();
-          dispatchBackspaceEvent(input, 'keyup');
-
-          expect(gl.FilteredSearchVisualTokens.removeLastTokenPartial).toHaveBeenCalled();
-        });
-
-        it('sets the input', () => {
-          spyOn(gl.FilteredSearchVisualTokens, 'getLastTokenPartial').and.callThrough();
-          dispatchDeleteEvent(input, 'keyup');
+      it('removes last token', () => {
+        spyOn(gl.FilteredSearchVisualTokens, 'removeLastTokenPartial').and.callThrough();
+        dispatchBackspaceEvent(input, 'keyup');
 
-          expect(gl.FilteredSearchVisualTokens.getLastTokenPartial).toHaveBeenCalled();
-          expect(input.value).toEqual('~bug');
-        });
+        expect(gl.FilteredSearchVisualTokens.removeLastTokenPartial).toHaveBeenCalled();
       });
 
-      it('does not remove token or change input when there is existing input', () => {
-        spyOn(gl.FilteredSearchVisualTokens, 'removeLastTokenPartial').and.callThrough();
+      it('sets the input', () => {
         spyOn(gl.FilteredSearchVisualTokens, 'getLastTokenPartial').and.callThrough();
-
-        input.value = 'text';
         dispatchDeleteEvent(input, 'keyup');
 
-        expect(gl.FilteredSearchVisualTokens.removeLastTokenPartial).not.toHaveBeenCalled();
-        expect(gl.FilteredSearchVisualTokens.getLastTokenPartial).not.toHaveBeenCalled();
-        expect(input.value).toEqual('text');
+        expect(gl.FilteredSearchVisualTokens.getLastTokenPartial).toHaveBeenCalled();
+        expect(input.value).toEqual('~bug');
       });
     });
 
-    describe('removeSelectedToken', () => {
-      function getVisualTokens() {
-        return tokensContainer.querySelectorAll('.js-visual-token');
-      }
+    it('does not remove token or change input when there is existing input', () => {
+      spyOn(gl.FilteredSearchVisualTokens, 'removeLastTokenPartial').and.callThrough();
+      spyOn(gl.FilteredSearchVisualTokens, 'getLastTokenPartial').and.callThrough();
 
-      beforeEach(() => {
-        tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(
-          FilteredSearchSpecHelper.createFilterVisualTokenHTML('milestone', 'none', true),
-        );
-      });
+      input.value = 'text';
+      dispatchDeleteEvent(input, 'keyup');
 
-      it('removes selected token when the backspace key is pressed', () => {
-        expect(getVisualTokens().length).toEqual(1);
+      expect(gl.FilteredSearchVisualTokens.removeLastTokenPartial).not.toHaveBeenCalled();
+      expect(gl.FilteredSearchVisualTokens.getLastTokenPartial).not.toHaveBeenCalled();
+      expect(input.value).toEqual('text');
+    });
+  });
 
-        dispatchBackspaceEvent(document, 'keydown');
+  describe('removeSelectedToken', () => {
+    function getVisualTokens() {
+      return tokensContainer.querySelectorAll('.js-visual-token');
+    }
 
-        expect(getVisualTokens().length).toEqual(0);
-      });
+    beforeEach(() => {
+      tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(
+        FilteredSearchSpecHelper.createFilterVisualTokenHTML('milestone', 'none', true),
+      );
+    });
 
-      it('removes selected token when the delete key is pressed', () => {
-        expect(getVisualTokens().length).toEqual(1);
+    it('removes selected token when the backspace key is pressed', () => {
+      expect(getVisualTokens().length).toEqual(1);
 
-        dispatchDeleteEvent(document, 'keydown');
+      dispatchBackspaceEvent(document, 'keydown');
 
-        expect(getVisualTokens().length).toEqual(0);
-      });
+      expect(getVisualTokens().length).toEqual(0);
+    });
 
-      it('updates the input placeholder after removal', () => {
-        manager.handleInputPlaceholder();
+    it('removes selected token when the delete key is pressed', () => {
+      expect(getVisualTokens().length).toEqual(1);
 
-        expect(input.placeholder).toEqual('');
-        expect(getVisualTokens().length).toEqual(1);
+      dispatchDeleteEvent(document, 'keydown');
 
-        dispatchBackspaceEvent(document, 'keydown');
+      expect(getVisualTokens().length).toEqual(0);
+    });
 
-        expect(input.placeholder).not.toEqual('');
-        expect(getVisualTokens().length).toEqual(0);
-      });
+    it('updates the input placeholder after removal', () => {
+      manager.handleInputPlaceholder();
 
-      it('updates the clear button after removal', () => {
-        manager.toggleClearSearchButton();
+      expect(input.placeholder).toEqual('');
+      expect(getVisualTokens().length).toEqual(1);
 
-        const clearButton = document.querySelector('.clear-search');
+      dispatchBackspaceEvent(document, 'keydown');
 
-        expect(clearButton.classList.contains('hidden')).toEqual(false);
-        expect(getVisualTokens().length).toEqual(1);
+      expect(input.placeholder).not.toEqual('');
+      expect(getVisualTokens().length).toEqual(0);
+    });
 
-        dispatchBackspaceEvent(document, 'keydown');
+    it('updates the clear button after removal', () => {
+      manager.toggleClearSearchButton();
 
-        expect(clearButton.classList.contains('hidden')).toEqual(true);
-        expect(getVisualTokens().length).toEqual(0);
-      });
+      const clearButton = document.querySelector('.clear-search');
+
+      expect(clearButton.classList.contains('hidden')).toEqual(false);
+      expect(getVisualTokens().length).toEqual(1);
+
+      dispatchBackspaceEvent(document, 'keydown');
+
+      expect(clearButton.classList.contains('hidden')).toEqual(true);
+      expect(getVisualTokens().length).toEqual(0);
     });
+  });
 
-    describe('unselects token', () => {
-      beforeEach(() => {
-        tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(`
-          ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug', true)}
-          ${FilteredSearchSpecHelper.createSearchVisualTokenHTML('search term')}
-          ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~awesome')}
-        `);
-      });
+  describe('unselects token', () => {
+    beforeEach(() => {
+      tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(`
+        ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~bug', true)}
+        ${FilteredSearchSpecHelper.createSearchVisualTokenHTML('search term')}
+        ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '~awesome')}
+      `);
+    });
 
-      it('unselects token when input is clicked', () => {
-        const selectedToken = tokensContainer.querySelector('.js-visual-token .selected');
+    it('unselects token when input is clicked', () => {
+      const selectedToken = tokensContainer.querySelector('.js-visual-token .selected');
 
-        expect(selectedToken.classList.contains('selected')).toEqual(true);
-        expect(gl.FilteredSearchVisualTokens.unselectTokens).not.toHaveBeenCalled();
+      expect(selectedToken.classList.contains('selected')).toEqual(true);
+      expect(gl.FilteredSearchVisualTokens.unselectTokens).not.toHaveBeenCalled();
 
-        // Click directly on input attached to document
-        // so that the click event will propagate properly
-        document.querySelector('.filtered-search').click();
+      // Click directly on input attached to document
+      // so that the click event will propagate properly
+      document.querySelector('.filtered-search').click();
 
-        expect(gl.FilteredSearchVisualTokens.unselectTokens).toHaveBeenCalled();
-        expect(selectedToken.classList.contains('selected')).toEqual(false);
-      });
+      expect(gl.FilteredSearchVisualTokens.unselectTokens).toHaveBeenCalled();
+      expect(selectedToken.classList.contains('selected')).toEqual(false);
+    });
 
-      it('unselects token when document.body is clicked', () => {
-        const selectedToken = tokensContainer.querySelector('.js-visual-token .selected');
+    it('unselects token when document.body is clicked', () => {
+      const selectedToken = tokensContainer.querySelector('.js-visual-token .selected');
 
-        expect(selectedToken.classList.contains('selected')).toEqual(true);
-        expect(gl.FilteredSearchVisualTokens.unselectTokens).not.toHaveBeenCalled();
+      expect(selectedToken.classList.contains('selected')).toEqual(true);
+      expect(gl.FilteredSearchVisualTokens.unselectTokens).not.toHaveBeenCalled();
 
-        document.body.click();
+      document.body.click();
 
-        expect(selectedToken.classList.contains('selected')).toEqual(false);
-        expect(gl.FilteredSearchVisualTokens.unselectTokens).toHaveBeenCalled();
-      });
+      expect(selectedToken.classList.contains('selected')).toEqual(false);
+      expect(gl.FilteredSearchVisualTokens.unselectTokens).toHaveBeenCalled();
     });
+  });
 
-    describe('toggleInputContainerFocus', () => {
-      it('toggles on focus', () => {
-        input.focus();
-        expect(document.querySelector('.filtered-search-input-container').classList.contains('focus')).toEqual(true);
-      });
+  describe('toggleInputContainerFocus', () => {
+    it('toggles on focus', () => {
+      input.focus();
+      expect(document.querySelector('.filtered-search-input-container').classList.contains('focus')).toEqual(true);
+    });
 
-      it('toggles on blur', () => {
-        input.blur();
-        expect(document.querySelector('.filtered-search-input-container').classList.contains('focus')).toEqual(false);
-      });
+    it('toggles on blur', () => {
+      input.blur();
+      expect(document.querySelector('.filtered-search-input-container').classList.contains('focus')).toEqual(false);
     });
   });
-})();
+});
diff --git a/spec/javascripts/filtered_search/filtered_search_token_keys_spec.js b/spec/javascripts/filtered_search/filtered_search_token_keys_spec.js
index cf409a7e509..6f9fa434c35 100644
--- a/spec/javascripts/filtered_search/filtered_search_token_keys_spec.js
+++ b/spec/javascripts/filtered_search/filtered_search_token_keys_spec.js
@@ -1,110 +1,108 @@
 require('~/extensions/array');
 require('~/filtered_search/filtered_search_token_keys');
 
-(() => {
-  describe('Filtered Search Token Keys', () => {
-    describe('get', () => {
-      let tokenKeys;
-
-      beforeEach(() => {
-        tokenKeys = gl.FilteredSearchTokenKeys.get();
-      });
-
-      it('should return tokenKeys', () => {
-        expect(tokenKeys !== null).toBe(true);
-      });
-
-      it('should return tokenKeys as an array', () => {
-        expect(tokenKeys instanceof Array).toBe(true);
-      });
-    });
-
-    describe('getConditions', () => {
-      let conditions;
-
-      beforeEach(() => {
-        conditions = gl.FilteredSearchTokenKeys.getConditions();
-      });
-
-      it('should return conditions', () => {
-        expect(conditions !== null).toBe(true);
-      });
-
-      it('should return conditions as an array', () => {
-        expect(conditions instanceof Array).toBe(true);
-      });
-    });
-
-    describe('searchByKey', () => {
-      it('should return null when key not found', () => {
-        const tokenKey = gl.FilteredSearchTokenKeys.searchByKey('notakey');
-        expect(tokenKey === null).toBe(true);
-      });
-
-      it('should return tokenKey when found by key', () => {
-        const tokenKeys = gl.FilteredSearchTokenKeys.get();
-        const result = gl.FilteredSearchTokenKeys.searchByKey(tokenKeys[0].key);
-        expect(result).toEqual(tokenKeys[0]);
-      });
-    });
-
-    describe('searchBySymbol', () => {
-      it('should return null when symbol not found', () => {
-        const tokenKey = gl.FilteredSearchTokenKeys.searchBySymbol('notasymbol');
-        expect(tokenKey === null).toBe(true);
-      });
-
-      it('should return tokenKey when found by symbol', () => {
-        const tokenKeys = gl.FilteredSearchTokenKeys.get();
-        const result = gl.FilteredSearchTokenKeys.searchBySymbol(tokenKeys[0].symbol);
-        expect(result).toEqual(tokenKeys[0]);
-      });
-    });
-
-    describe('searchByKeyParam', () => {
-      it('should return null when key param not found', () => {
-        const tokenKey = gl.FilteredSearchTokenKeys.searchByKeyParam('notakeyparam');
-        expect(tokenKey === null).toBe(true);
-      });
-
-      it('should return tokenKey when found by key param', () => {
-        const tokenKeys = gl.FilteredSearchTokenKeys.get();
-        const result = gl.FilteredSearchTokenKeys.searchByKeyParam(`${tokenKeys[0].key}_${tokenKeys[0].param}`);
-        expect(result).toEqual(tokenKeys[0]);
-      });
-
-      it('should return alternative tokenKey when found by key param', () => {
-        const tokenKeys = gl.FilteredSearchTokenKeys.getAlternatives();
-        const result = gl.FilteredSearchTokenKeys.searchByKeyParam(`${tokenKeys[0].key}_${tokenKeys[0].param}`);
-        expect(result).toEqual(tokenKeys[0]);
-      });
-    });
-
-    describe('searchByConditionUrl', () => {
-      it('should return null when condition url not found', () => {
-        const condition = gl.FilteredSearchTokenKeys.searchByConditionUrl(null);
-        expect(condition === null).toBe(true);
-      });
-
-      it('should return condition when found by url', () => {
-        const conditions = gl.FilteredSearchTokenKeys.getConditions();
-        const result = gl.FilteredSearchTokenKeys.searchByConditionUrl(conditions[0].url);
-        expect(result).toBe(conditions[0]);
-      });
-    });
-
-    describe('searchByConditionKeyValue', () => {
-      it('should return null when condition tokenKey and value not found', () => {
-        const condition = gl.FilteredSearchTokenKeys.searchByConditionKeyValue(null, null);
-        expect(condition === null).toBe(true);
-      });
-
-      it('should return condition when found by tokenKey and value', () => {
-        const conditions = gl.FilteredSearchTokenKeys.getConditions();
-        const result = gl.FilteredSearchTokenKeys
-          .searchByConditionKeyValue(conditions[0].tokenKey, conditions[0].value);
-        expect(result).toEqual(conditions[0]);
-      });
+describe('Filtered Search Token Keys', () => {
+  describe('get', () => {
+    let tokenKeys;
+
+    beforeEach(() => {
+      tokenKeys = gl.FilteredSearchTokenKeys.get();
+    });
+
+    it('should return tokenKeys', () => {
+      expect(tokenKeys !== null).toBe(true);
+    });
+
+    it('should return tokenKeys as an array', () => {
+      expect(tokenKeys instanceof Array).toBe(true);
+    });
+  });
+
+  describe('getConditions', () => {
+    let conditions;
+
+    beforeEach(() => {
+      conditions = gl.FilteredSearchTokenKeys.getConditions();
+    });
+
+    it('should return conditions', () => {
+      expect(conditions !== null).toBe(true);
+    });
+
+    it('should return conditions as an array', () => {
+      expect(conditions instanceof Array).toBe(true);
+    });
+  });
+
+  describe('searchByKey', () => {
+    it('should return null when key not found', () => {
+      const tokenKey = gl.FilteredSearchTokenKeys.searchByKey('notakey');
+      expect(tokenKey === null).toBe(true);
+    });
+
+    it('should return tokenKey when found by key', () => {
+      const tokenKeys = gl.FilteredSearchTokenKeys.get();
+      const result = gl.FilteredSearchTokenKeys.searchByKey(tokenKeys[0].key);
+      expect(result).toEqual(tokenKeys[0]);
+    });
+  });
+
+  describe('searchBySymbol', () => {
+    it('should return null when symbol not found', () => {
+      const tokenKey = gl.FilteredSearchTokenKeys.searchBySymbol('notasymbol');
+      expect(tokenKey === null).toBe(true);
+    });
+
+    it('should return tokenKey when found by symbol', () => {
+      const tokenKeys = gl.FilteredSearchTokenKeys.get();
+      const result = gl.FilteredSearchTokenKeys.searchBySymbol(tokenKeys[0].symbol);
+      expect(result).toEqual(tokenKeys[0]);
+    });
+  });
+
+  describe('searchByKeyParam', () => {
+    it('should return null when key param not found', () => {
+      const tokenKey = gl.FilteredSearchTokenKeys.searchByKeyParam('notakeyparam');
+      expect(tokenKey === null).toBe(true);
+    });
+
+    it('should return tokenKey when found by key param', () => {
+      const tokenKeys = gl.FilteredSearchTokenKeys.get();
+      const result = gl.FilteredSearchTokenKeys.searchByKeyParam(`${tokenKeys[0].key}_${tokenKeys[0].param}`);
+      expect(result).toEqual(tokenKeys[0]);
+    });
+
+    it('should return alternative tokenKey when found by key param', () => {
+      const tokenKeys = gl.FilteredSearchTokenKeys.getAlternatives();
+      const result = gl.FilteredSearchTokenKeys.searchByKeyParam(`${tokenKeys[0].key}_${tokenKeys[0].param}`);
+      expect(result).toEqual(tokenKeys[0]);
+    });
+  });
+
+  describe('searchByConditionUrl', () => {
+    it('should return null when condition url not found', () => {
+      const condition = gl.FilteredSearchTokenKeys.searchByConditionUrl(null);
+      expect(condition === null).toBe(true);
+    });
+
+    it('should return condition when found by url', () => {
+      const conditions = gl.FilteredSearchTokenKeys.getConditions();
+      const result = gl.FilteredSearchTokenKeys.searchByConditionUrl(conditions[0].url);
+      expect(result).toBe(conditions[0]);
+    });
+  });
+
+  describe('searchByConditionKeyValue', () => {
+    it('should return null when condition tokenKey and value not found', () => {
+      const condition = gl.FilteredSearchTokenKeys.searchByConditionKeyValue(null, null);
+      expect(condition === null).toBe(true);
+    });
+
+    it('should return condition when found by tokenKey and value', () => {
+      const conditions = gl.FilteredSearchTokenKeys.getConditions();
+      const result = gl.FilteredSearchTokenKeys
+        .searchByConditionKeyValue(conditions[0].tokenKey, conditions[0].value);
+      expect(result).toEqual(conditions[0]);
     });
   });
-})();
+});
diff --git a/spec/javascripts/filtered_search/filtered_search_tokenizer_spec.js b/spec/javascripts/filtered_search/filtered_search_tokenizer_spec.js
index cabbc694ec4..3e2e577f115 100644
--- a/spec/javascripts/filtered_search/filtered_search_tokenizer_spec.js
+++ b/spec/javascripts/filtered_search/filtered_search_tokenizer_spec.js
@@ -2,134 +2,132 @@ require('~/extensions/array');
 require('~/filtered_search/filtered_search_token_keys');
 require('~/filtered_search/filtered_search_tokenizer');
 
-(() => {
-  describe('Filtered Search Tokenizer', () => {
-    describe('processTokens', () => {
-      it('returns for input containing only search value', () => {
-        const results = gl.FilteredSearchTokenizer.processTokens('searchTerm');
-        expect(results.searchToken).toBe('searchTerm');
-        expect(results.tokens.length).toBe(0);
-        expect(results.lastToken).toBe(results.searchToken);
-      });
-
-      it('returns for input containing only tokens', () => {
-        const results = gl.FilteredSearchTokenizer
-          .processTokens('author:@root label:~"Very Important" milestone:%v1.0 assignee:none');
-        expect(results.searchToken).toBe('');
-        expect(results.tokens.length).toBe(4);
-        expect(results.tokens[3]).toBe(results.lastToken);
-
-        expect(results.tokens[0].key).toBe('author');
-        expect(results.tokens[0].value).toBe('root');
-        expect(results.tokens[0].symbol).toBe('@');
-
-        expect(results.tokens[1].key).toBe('label');
-        expect(results.tokens[1].value).toBe('"Very Important"');
-        expect(results.tokens[1].symbol).toBe('~');
-
-        expect(results.tokens[2].key).toBe('milestone');
-        expect(results.tokens[2].value).toBe('v1.0');
-        expect(results.tokens[2].symbol).toBe('%');
-
-        expect(results.tokens[3].key).toBe('assignee');
-        expect(results.tokens[3].value).toBe('none');
-        expect(results.tokens[3].symbol).toBe('');
-      });
-
-      it('returns for input starting with search value and ending with tokens', () => {
-        const results = gl.FilteredSearchTokenizer
-          .processTokens('searchTerm anotherSearchTerm milestone:none');
-        expect(results.searchToken).toBe('searchTerm anotherSearchTerm');
-        expect(results.tokens.length).toBe(1);
-        expect(results.tokens[0]).toBe(results.lastToken);
-        expect(results.tokens[0].key).toBe('milestone');
-        expect(results.tokens[0].value).toBe('none');
-        expect(results.tokens[0].symbol).toBe('');
-      });
-
-      it('returns for input starting with tokens and ending with search value', () => {
-        const results = gl.FilteredSearchTokenizer
-          .processTokens('assignee:@user searchTerm');
-
-        expect(results.searchToken).toBe('searchTerm');
-        expect(results.tokens.length).toBe(1);
-        expect(results.tokens[0].key).toBe('assignee');
-        expect(results.tokens[0].value).toBe('user');
-        expect(results.tokens[0].symbol).toBe('@');
-        expect(results.lastToken).toBe(results.searchToken);
-      });
-
-      it('returns for input containing search value wrapped between tokens', () => {
-        const results = gl.FilteredSearchTokenizer
-          .processTokens('author:@root label:~"Won\'t fix" searchTerm anotherSearchTerm milestone:none');
-
-        expect(results.searchToken).toBe('searchTerm anotherSearchTerm');
-        expect(results.tokens.length).toBe(3);
-        expect(results.tokens[2]).toBe(results.lastToken);
-
-        expect(results.tokens[0].key).toBe('author');
-        expect(results.tokens[0].value).toBe('root');
-        expect(results.tokens[0].symbol).toBe('@');
-
-        expect(results.tokens[1].key).toBe('label');
-        expect(results.tokens[1].value).toBe('"Won\'t fix"');
-        expect(results.tokens[1].symbol).toBe('~');
-
-        expect(results.tokens[2].key).toBe('milestone');
-        expect(results.tokens[2].value).toBe('none');
-        expect(results.tokens[2].symbol).toBe('');
-      });
-
-      it('returns for input containing search value in between tokens', () => {
-        const results = gl.FilteredSearchTokenizer
-          .processTokens('author:@root searchTerm assignee:none anotherSearchTerm label:~Doing');
-        expect(results.searchToken).toBe('searchTerm anotherSearchTerm');
-        expect(results.tokens.length).toBe(3);
-        expect(results.tokens[2]).toBe(results.lastToken);
-
-        expect(results.tokens[0].key).toBe('author');
-        expect(results.tokens[0].value).toBe('root');
-        expect(results.tokens[0].symbol).toBe('@');
-
-        expect(results.tokens[1].key).toBe('assignee');
-        expect(results.tokens[1].value).toBe('none');
-        expect(results.tokens[1].symbol).toBe('');
-
-        expect(results.tokens[2].key).toBe('label');
-        expect(results.tokens[2].value).toBe('Doing');
-        expect(results.tokens[2].symbol).toBe('~');
-      });
-
-      it('returns search value for invalid tokens', () => {
-        const results = gl.FilteredSearchTokenizer.processTokens('fake:token');
-        expect(results.lastToken).toBe('fake:token');
-        expect(results.searchToken).toBe('fake:token');
-        expect(results.tokens.length).toEqual(0);
-      });
-
-      it('returns search value and token for mix of valid and invalid tokens', () => {
-        const results = gl.FilteredSearchTokenizer.processTokens('label:real fake:token');
-        expect(results.tokens.length).toEqual(1);
-        expect(results.tokens[0].key).toBe('label');
-        expect(results.tokens[0].value).toBe('real');
-        expect(results.tokens[0].symbol).toBe('');
-        expect(results.lastToken).toBe('fake:token');
-        expect(results.searchToken).toBe('fake:token');
-      });
-
-      it('returns search value for invalid symbols', () => {
-        const results = gl.FilteredSearchTokenizer.processTokens('std::includes');
-        expect(results.lastToken).toBe('std::includes');
-        expect(results.searchToken).toBe('std::includes');
-      });
-
-      it('removes duplicated values', () => {
-        const results = gl.FilteredSearchTokenizer.processTokens('label:~foo label:~foo');
-        expect(results.tokens.length).toBe(1);
-        expect(results.tokens[0].key).toBe('label');
-        expect(results.tokens[0].value).toBe('foo');
-        expect(results.tokens[0].symbol).toBe('~');
-      });
+describe('Filtered Search Tokenizer', () => {
+  describe('processTokens', () => {
+    it('returns for input containing only search value', () => {
+      const results = gl.FilteredSearchTokenizer.processTokens('searchTerm');
+      expect(results.searchToken).toBe('searchTerm');
+      expect(results.tokens.length).toBe(0);
+      expect(results.lastToken).toBe(results.searchToken);
+    });
+
+    it('returns for input containing only tokens', () => {
+      const results = gl.FilteredSearchTokenizer
+        .processTokens('author:@root label:~"Very Important" milestone:%v1.0 assignee:none');
+      expect(results.searchToken).toBe('');
+      expect(results.tokens.length).toBe(4);
+      expect(results.tokens[3]).toBe(results.lastToken);
+
+      expect(results.tokens[0].key).toBe('author');
+      expect(results.tokens[0].value).toBe('root');
+      expect(results.tokens[0].symbol).toBe('@');
+
+      expect(results.tokens[1].key).toBe('label');
+      expect(results.tokens[1].value).toBe('"Very Important"');
+      expect(results.tokens[1].symbol).toBe('~');
+
+      expect(results.tokens[2].key).toBe('milestone');
+      expect(results.tokens[2].value).toBe('v1.0');
+      expect(results.tokens[2].symbol).toBe('%');
+
+      expect(results.tokens[3].key).toBe('assignee');
+      expect(results.tokens[3].value).toBe('none');
+      expect(results.tokens[3].symbol).toBe('');
+    });
+
+    it('returns for input starting with search value and ending with tokens', () => {
+      const results = gl.FilteredSearchTokenizer
+        .processTokens('searchTerm anotherSearchTerm milestone:none');
+      expect(results.searchToken).toBe('searchTerm anotherSearchTerm');
+      expect(results.tokens.length).toBe(1);
+      expect(results.tokens[0]).toBe(results.lastToken);
+      expect(results.tokens[0].key).toBe('milestone');
+      expect(results.tokens[0].value).toBe('none');
+      expect(results.tokens[0].symbol).toBe('');
+    });
+
+    it('returns for input starting with tokens and ending with search value', () => {
+      const results = gl.FilteredSearchTokenizer
+        .processTokens('assignee:@user searchTerm');
+
+      expect(results.searchToken).toBe('searchTerm');
+      expect(results.tokens.length).toBe(1);
+      expect(results.tokens[0].key).toBe('assignee');
+      expect(results.tokens[0].value).toBe('user');
+      expect(results.tokens[0].symbol).toBe('@');
+      expect(results.lastToken).toBe(results.searchToken);
+    });
+
+    it('returns for input containing search value wrapped between tokens', () => {
+      const results = gl.FilteredSearchTokenizer
+        .processTokens('author:@root label:~"Won\'t fix" searchTerm anotherSearchTerm milestone:none');
+
+      expect(results.searchToken).toBe('searchTerm anotherSearchTerm');
+      expect(results.tokens.length).toBe(3);
+      expect(results.tokens[2]).toBe(results.lastToken);
+
+      expect(results.tokens[0].key).toBe('author');
+      expect(results.tokens[0].value).toBe('root');
+      expect(results.tokens[0].symbol).toBe('@');
+
+      expect(results.tokens[1].key).toBe('label');
+      expect(results.tokens[1].value).toBe('"Won\'t fix"');
+      expect(results.tokens[1].symbol).toBe('~');
+
+      expect(results.tokens[2].key).toBe('milestone');
+      expect(results.tokens[2].value).toBe('none');
+      expect(results.tokens[2].symbol).toBe('');
+    });
+
+    it('returns for input containing search value in between tokens', () => {
+      const results = gl.FilteredSearchTokenizer
+        .processTokens('author:@root searchTerm assignee:none anotherSearchTerm label:~Doing');
+      expect(results.searchToken).toBe('searchTerm anotherSearchTerm');
+      expect(results.tokens.length).toBe(3);
+      expect(results.tokens[2]).toBe(results.lastToken);
+
+      expect(results.tokens[0].key).toBe('author');
+      expect(results.tokens[0].value).toBe('root');
+      expect(results.tokens[0].symbol).toBe('@');
+
+      expect(results.tokens[1].key).toBe('assignee');
+      expect(results.tokens[1].value).toBe('none');
+      expect(results.tokens[1].symbol).toBe('');
+
+      expect(results.tokens[2].key).toBe('label');
+      expect(results.tokens[2].value).toBe('Doing');
+      expect(results.tokens[2].symbol).toBe('~');
+    });
+
+    it('returns search value for invalid tokens', () => {
+      const results = gl.FilteredSearchTokenizer.processTokens('fake:token');
+      expect(results.lastToken).toBe('fake:token');
+      expect(results.searchToken).toBe('fake:token');
+      expect(results.tokens.length).toEqual(0);
+    });
+
+    it('returns search value and token for mix of valid and invalid tokens', () => {
+      const results = gl.FilteredSearchTokenizer.processTokens('label:real fake:token');
+      expect(results.tokens.length).toEqual(1);
+      expect(results.tokens[0].key).toBe('label');
+      expect(results.tokens[0].value).toBe('real');
+      expect(results.tokens[0].symbol).toBe('');
+      expect(results.lastToken).toBe('fake:token');
+      expect(results.searchToken).toBe('fake:token');
+    });
+
+    it('returns search value for invalid symbols', () => {
+      const results = gl.FilteredSearchTokenizer.processTokens('std::includes');
+      expect(results.lastToken).toBe('std::includes');
+      expect(results.searchToken).toBe('std::includes');
+    });
+
+    it('removes duplicated values', () => {
+      const results = gl.FilteredSearchTokenizer.processTokens('label:~foo label:~foo');
+      expect(results.tokens.length).toBe(1);
+      expect(results.tokens[0].key).toBe('label');
+      expect(results.tokens[0].value).toBe('foo');
+      expect(results.tokens[0].symbol).toBe('~');
     });
   });
-})();
+});