How true hackers write JavaScript

  My opinion of the code is this. 
  It's pretty tight, which I can respect. 
  I haven't run it, but it PROBABLY works.

  But it's hard to read. 
  Things are named poorly. 
  Many edge cases are missed (not checking args properly).

  These functions are not pure and therefore, harder to test. 
  Maybe true 1337 H@X0Rz don't need to write tests, but some of us have mortgages to pay...

  I didn't re-write all of this mess, but check out the few util functions that I re-wrote.

  As a developer, which version would you rather work with?
  If you said the original version that's cool with me.
  But don't try to come work on my team.

  // isNull :: a -> Boolean
  const isNull = x => x == null

  // isNullOrEmpty :: String -> Boolean
  const isNullOrEmpty = string => string == null || !string.length

  // $ :: String -> HTMLDocument -> HTMLElement
  const $ = (id, _document = document) => {
    if (isNullOrEmpty(id)) return null
    if (isNull(_document)) return null
    return _document.getElementById(id) || null
  }

  // findClassInElement :: HTMLElement -> String -> [HTMLElement]
  const findClassInElement = (el, className) => {
    if (isNull(el)) return []
    if (isNullOrEmpty(tagName)) return []
    return el.getElementsByClassName(className) || []
  }

  // findTagInElement :: HTMLElement -> String -> [HTMLElement]
  const findTagInElement = (el, tagName) => {
    if (isNull(el)) return []
    if (isNullOrEmpty(tagName)) return []
    return el.getElementsByTagName(tagName) || []
  }

  // findClass :: String -> HTMLDocument -> [HTMLElement]
  const findClass = (className, _document = document) => {
    if (isNullOrEmpty(className)) return []
    if (isNull(_document)) return [] 
    return findClassInElement(_document, className) || []
  }

  // elementHasClass :: HTMLElement -> String -> Boolean
  const elementHasClass = (el, className) => {
    if (isNull(el)) return false
    if (isNullOrEmpty(className)) return false
    return el.className.includes(className)
  }

  // addClass :: HTMLElement -> String -> Boolean
  const addClass = (el, className) => {
    if (isNull(el) || isNull(el.className)) return false
    if (isNullOrEmpty(className)) return false
    if (el.className.includes(className)) return true
    el.className = `${el.className} ${className}`
    return true
  }

That is really beside the point. HTML and JS should not be coupled to the extent that adding or removing some whitespace from the HTML will cause the JS to fail. This kind of things turns a trivial improvement into a nightmare, so you end up not daring to change anything.