RubyGems - unpoly-rails - Versions diffs - 0.57.0 → 0.60.0 - Mend

unpoly-rails 0.57.0 → 0.60.0

Potentially problematic release.

This version of unpoly-rails might be problematic. Click here for more details.

Files changed (186) hide show

data/lib/assets/javascripts/unpoly/toast.coffee CHANGED

@@ -2,17 +2,16 @@
 Toast alerts
 ============
-@class up.toast
+@module up.toast
 ###
-up.toast = (($) ->
+up.toast = do ->
   u = up.util
-  b = up.browser
+  e = up.element
   VARIABLE_FORMATTER = (arg) -> "<span class='up-toast-variable'>#{u.escapeHtml(arg)}</span>"
-  state = u.config
-    $toast: null
+  state = new up.Config
+    element: null
   reset = ->
     close()
@@ -21,39 +20,43 @@ up.toast = (($) ->
   messageToHtml = (message) ->
     if u.isArray(message)
       message[0] = u.escapeHtml(message[0])
-      message = b.sprintfWithFormattedArgs(VARIABLE_FORMATTER, message...)
+      message = up.log.sprintfWithFormattedArgs(VARIABLE_FORMATTER, message...)
     else
       message = u.escapeHtml(message)
     message
   isOpen = ->
-    !!state.$toast
+    !!state.element
-  addAction = ($actions, label, callback) ->
-    $action = $('<span class="up-toast-action"></span>').text(label)
-    $action.on 'click', callback
-    $action.appendTo($actions)
+  addAction = (label, callback) ->
+    actions = state.element.querySelector('.up-toast-actions')
+    action = e.affix(actions, '.up-toast-action')
+    action.innerText = label
+    action.addEventListener('click', callback)
   open = (message, options = {}) ->
     close()
-    $toast = $('<div class="up-toast"></div>').prependTo('body')
-    $message = $('<div class="up-toast-message"></div>').appendTo($toast)
-    $actions = $('<div class="up-toast-actions"></div>').appendTo($toast)
     message = messageToHtml(message)
-    $message.html(message)
+    state.element = e.createFromHtml """
+      <div class="up-toast">
+        <div class="up-toast-message">#{message}</div>
+        <div class="up-toast-actions"></div>
+      </div>
+    """
     if action = (options.action || options.inspect)
-      addAction($actions, action.label, action.callback)
+      addAction(action.label, action.callback)
-    addAction($actions, 'Close', close)
+    addAction('Close', close)
-    state.$toast = $toast
+    document.body.appendChild(state.element)
   close = ->
     if isOpen()
-      state.$toast.remove()
-      state.$toast = null
+      e.remove(state.element)
+      state.element = null
   # The framework is reset between tests
   up.on 'up:framework:reset', reset
@@ -62,5 +65,3 @@ up.toast = (($) ->
   close: close
   reset: reset
   isOpen: isOpen
-)(jQuery)

data/lib/assets/javascripts/unpoly/tooltip.coffee CHANGED

@@ -19,27 +19,36 @@ A gray triangle points to the element.
 To change the styling, simply override the [CSS rules](https://github.com/unpoly/unpoly/blob/master/lib/assets/stylesheets/unpoly/tooltip.sass) for the `.up-tooltip` selector and its `:after`
 selector that is used for the triangle.
-The HTML of a tooltip element is simply this:
+The HTML of a tooltip element looks like this:
     <div class="up-tooltip">
-      Show all decks
+      <div class="up-tooltip-content">
+        Tooltip text here
+      </div>
     </div>
-The tooltip element is appended to the end of `<body>`.
+The tooltip element is appended to the [viewport](/up.viewport) of the anchor element.
-@class up.tooltip
+@module up.tooltip
 ###
-up.tooltip = (($) ->
+up.tooltip = do ->
   u = up.util
+  e = up.element
   ###**
   Configures defaults for future tooltips.
   @property up.tooltip.config
   @param {string} [config.position]
-    The default position of tooltips relative to the element.
-    Can be `'top'`, `'right'`, `'bottom'` or `'left'`.
+    The default position of tooltips relative to the opening element.
+    Valid values are `'top'`, `'right'`, `'bottom'` or `'left'`.
+  @param {string} [config.align]
+    Defines the alignment of the tooltip along its side.
+    When the tooltip's `{ position }` is `'top'` or `'bottom'`, valid `{ align }` values are `'left'`, `center'` and `'right'`.
+    When the tooltip's `{ position }` is `'left'` or `'right'`, valid `{ align }` values are `top'`, `center'` and `bottom'`.
   @param {string} [config.openAnimation='fade-in']
     The animation used to open a tooltip.
   @param {string} [config.closeAnimation='fade-out']
@@ -54,8 +63,9 @@ up.tooltip = (($) ->
     The timing function controlling the acceleration of the closing animation.
   @stable
   ###
-  config = u.config
+  config = new up.Config
     position: 'top'
+    align: 'center'
     openAnimation: 'fade-in'
     closeAnimation: 'fade-out'
     openDuration: 100
@@ -63,58 +73,45 @@ up.tooltip = (($) ->
     openEasing: null
     closeEasing: null
-  state = u.config
+  state = new up.Config
     phase: 'closed'      # can be 'opening', 'opened', 'closing' and 'closed'
-    $anchor: null        # the element to which the tooltip is anchored
-    $tooltip: null       # the tooltiop element
+    anchor: null         # the element to which the tooltip is anchored
+    tooltip: null        # the .up-tooltip element
+    content: null        # the .up-tooltip-content element
+    tether: null         # the up.Tether instance controlling the tooltip's position
     position: null       # the position of the tooltip element relative to its anchor
+    align: null
-  chain = new u.DivertibleChain()
+  chain = new up.DivertibleChain()
   reset = ->
-    # Destroy the tooltip container regardless whether it's currently in a closing animation
-    state.$tooltip?.remove()
+    state.tether?.destroy()
     state.reset()
     chain.reset()
     config.reset()
-  align = ->
-    style = {}
-    tooltipBox = u.measure(state.$tooltip)
+  createElement = (options) ->
+    state.tether = new up.Tether(u.only(state, 'anchor', 'position', 'align'))
+    state.tooltip = e.affix(state.tether.root, '.up-tooltip', 'up-position': state.position, 'up-align': state.align)
+    state.content = e.affix(state.tooltip, '.up-tooltip-content')
-    if u.isFixed(state.$anchor)
-      linkBox = state.$anchor.get(0).getBoundingClientRect()
-      style.position = 'fixed'
+    if options.text
+      state.content.innerText = options.text
     else
-      linkBox = u.measure(state.$anchor)
-    switch state.position
-      when 'top'
-        style.top = linkBox.top - tooltipBox.height
-        style.left = linkBox.left + 0.5 * (linkBox.width - tooltipBox.width)
-      when 'left'
-        style.top = linkBox.top + 0.5 * (linkBox.height - tooltipBox.height)
-        style.left = linkBox.left - tooltipBox.width
-      when 'right'
-        style.top = linkBox.top + 0.5 * (linkBox.height - tooltipBox.height)
-        style.left = linkBox.left + linkBox.width
-      when 'bottom'
-        style.top = linkBox.top + linkBox.height
-        style.left = linkBox.left + 0.5 * (linkBox.width - tooltipBox.width)
-      else
-        up.fail("Unknown position option '%s'", state.position)
-    state.$tooltip.attr('up-position', state.position)
-    u.writeInlineStyle(state.$tooltip, style)
+      state.content.innerHTML = options.html
-  createElement = (options) ->
-    $element = u.$createElementFromSelector('.up-tooltip')
-    if u.isGiven(options.text)
-      $element.text(options.text)
-    else
-      $element.html(options.html)
-    $element.appendTo(document.body)
-    state.$tooltip = $element
+  ###**
+  Forces the tooltip to update its position relative to its anchor element.
+  Unpoly will automatically keep tooltips aligned when
+  the document is resized or scrolled. Complex layout changes may make
+  it necessary to call this function.
+  @function up.tooltip.sync
+  @experimental
+  ###
+  syncPosition = ->
+    state.tether?.sync()
   ###**
   Opens a tooltip over the given element.
@@ -125,9 +122,7 @@ up.tooltip = (($) ->
   In order to attach a tooltip to a `<span class="help">?</span>`:
-      up.tooltip.attach('.help', {
-        text: 'Enter multiple words or phrases'
-      });
+      up.tooltip.attach('.help', { text: 'Useful info' })
   @function up.tooltip.attach
   @param {Element|jQuery|string} elementOrSelector
@@ -141,33 +136,40 @@ up.tooltip = (($) ->
     Make sure to escape any user-provided text before passing it as this option,
     or use `options.text` (which automatically escapes).
-  @param {string} [options.position='top']
-    The position of the tooltip.
-    Can be `'top'`, `'right'`, `'bottom'` or `'left'`.
+  @param {string} [options.position]
+    The tooltip's position relative to the opening element.
+    Valid values are `'top'`, `'right'`, `'bottom'` or `'left'`.
+  @param {string} [options.align]
+    Defines the alignment of the tooltip along its side.
+    When the tooltip's `{ position }` is `'top'` or `'bottom'`, valid `{ align }` values are `'left'`, `center'` and `'right'`.
+    When the tooltip's `{ position }` is `'left'` or `'right'`, valid `{ align }` values are `top'`, `center'` and `bottom'`.
   @param {string} [options.animation]
     The [animation](/up.motion) to use when opening the tooltip.
   @return {Promise}
     A promise that will be fulfilled when the tooltip's opening animation has finished.
   @stable
   ###
-  attachAsap = (elementOrSelector, options = {}) ->
+  attachAsap = (elementOrSelector, options) ->
     chain.asap closeNow, (-> attachNow(elementOrSelector, options))
-  attachNow = (elementOrSelector, options) ->
-    $anchor = $(elementOrSelector)
-    options = u.options(options)
-    html = u.option(options.html, $anchor.attr('up-tooltip-html'))
-    text = u.option(options.text, $anchor.attr('up-tooltip'))
-    position = u.option(options.position, $anchor.attr('up-position'), config.position)
-    animation = u.option(options.animation, u.castedAttr($anchor, 'up-animation'), config.openAnimation)
-    animateOptions = up.motion.animateOptions(options, $anchor, duration: config.openDuration, easing: config.openEasing)
+  attachNow = (elementOrSelector, options = {}) ->
+    anchor = e.get(elementOrSelector)
+    html = options.html ? anchor.getAttribute('up-tooltip-html')
+    text = options.text ? anchor.getAttribute('up-tooltip')
+    position = options.position ? anchor.getAttribute('up-position') ? config.position
+    align = options.align ? anchor.getAttribute('up-align') ? config.align
+    animation = options.animation ? e.booleanOrStringAttr(anchor, 'up-animation') ? config.openAnimation
+    animateOptions = up.motion.animateOptions(options, anchor, duration: config.openDuration, easing: config.openEasing)
     state.phase = 'opening'
-    state.$anchor = $anchor
-    createElement(text: text, html: html)
+    state.anchor = anchor
     state.position = position
-    align()
-    up.animate(state.$tooltip, animation, animateOptions).then ->
+    state.align = align
+    createElement({ text, html })
+    syncPosition()
+    up.animate(state.tooltip, animation, animateOptions).then ->
       state.phase = 'opened'
   ###**
@@ -193,10 +195,13 @@ up.tooltip = (($) ->
     animateOptions = up.motion.animateOptions(options, duration: config.closeDuration, easing: config.closeEasing)
     u.assign(options, animateOptions)
     state.phase = 'closing'
-    up.destroy(state.$tooltip, options).then ->
+    up.destroy(state.tooltip, options).then ->
       state.phase = 'closed'
-      state.$tooltip = null
-      state.$anchor = null
+      state.tether.destroy()
+      state.tether = null
+      state.tooltip = null
+      state.content = null
+      state.anchor = null
   ###**
   Returns whether a tooltip is currently showing.
@@ -224,9 +229,14 @@ up.tooltip = (($) ->
     The animation used to open the tooltip.
     Defaults to [`up.tooltip.config.openAnimation`](/up.tooltip.config).
   @param {string} [up-position]
-    The default position of tooltips relative to the element.
-    Can be either `"top"` or `"bottom"`.
-    Defaults to [`up.tooltip.config.position`](/up.tooltip.config).
+    The tooltip's position relative to the opening element.
+    Valid values are `'top'`, `'right'`, `'bottom'` or `'left'`.
+  @param {string} [up-align]
+    Defines the alignment of the tooltip along its side.
+    When the tooltip's `{ position }` is `'top'` or `'bottom'`, valid `{ align }` values are `'left'`, `center'` and `'right'`.
+    When the tooltip's `{ position }` is `'left'` or `'right'`, valid `{ align }` values are `top'`, `center'` and `bottom'`.
   @stable
   ###
@@ -238,16 +248,16 @@ up.tooltip = (($) ->
   @selector [up-tooltip-html]
   @stable
   ###
-  up.compiler '[up-tooltip], [up-tooltip-html]', ($opener) ->
+  up.compiler '[up-tooltip], [up-tooltip-html]', (opener) ->
     # Don't register these events on document since *every*
     # mouse move interaction  bubbles up to the document.
-    $opener.on('mouseenter', -> attachAsap($opener))
-    $opener.on('mouseleave', -> closeAsap())
+    opener.addEventListener 'mouseenter', -> attachAsap(opener)
+    opener.addEventListener 'mouseleave', -> closeAsap()
   # We close the tooltip when someone clicks on the document.
   # We also need to listen to up:action:consumed in case an [up-instant] link
   # was followed on mousedown.
-  up.on 'click up:action:consumed', (event) ->
+  up.on 'click up:action:consumed', (_event) -> # do take an argument so we won't parse [up-data]
     closeAsap()
     # Do not halt the event chain here. The user is allowed to directly activate
     # a link in the background, even with a (now closing) tooltip open.
@@ -256,11 +266,11 @@ up.tooltip = (($) ->
   up.on 'up:framework:reset', reset
   # Close the tooltip when the user presses ESC.
-  up.bus.onEscape(-> closeAsap())
+  up.event.onEscape(-> closeAsap())
   config: config
   attach: attachAsap
   isOpen: isOpen
   close: closeAsap
+  sync: syncPosition
-)(jQuery)

data/lib/assets/javascripts/unpoly/util.coffee.erb CHANGED

@@ -1,13 +1,17 @@
 ###**
 Utility functions
 =================
-Unpoly comes with a number of utility functions
-that might save you from loading something like [Lodash](https://lodash.com/).
-@class up.util
+The `up.util` module contains functions to facilitate the work with basic JavaScript
+values like lists, strings or functions.
+You will recognize many functions form other utility libraries like [Lodash](https://lodash.com/).
+While feature parity with Lodash is not a goal of `up.util`, you might find it sufficient
+to not include another library in your asset bundle.
+@module up.util
 ###
-up.util = (($) ->
+up.util = do ->
   ###**
   A function that does nothing.
@@ -75,10 +79,6 @@ up.util = (($) ->
     normalized = parts.protocol + "//" + parts.hostname
     normalized += ":#{parts.port}" unless isStandardPort(parts.protocol, parts.port)
     pathname = parts.pathname
-    # Some IEs don't include a leading slash in the #pathname property.
-    # We have seen this in IE11 and W3Schools claims it happens in IE9 or earlier
-    # http://www.w3schools.com/jsref/prop_anchor_pathname.asp
-    pathname = "/#{pathname}" unless pathname[0] == '/'
     pathname = pathname.replace(/\/$/, '') if options?.stripTrailingSlash == true
     normalized += pathname
     normalized += parts.search unless options?.search == false
@@ -88,7 +88,7 @@ up.util = (($) ->
   isCrossDomain = (targetUrl) ->
     currentUrl = parseUrl(location.href)
     targetUrl = parseUrl(targetUrl)
-    currentUrl.protocol != targetUrl.protocol || currentUrl.host != targetUrl.host
+    currentUrl.protocol != targetUrl.protocol || currentUrl.hostname != targetUrl.hostname
   ###**
   Parses the given URL into components such as hostname and path.
@@ -101,24 +101,33 @@ up.util = (($) ->
     The parsed URL as an object with
     `protocol`, `hostname`, `port`, `pathname`, `search` and `hash`
     properties.
-  @experimental
+  @stable
   ###
-  parseUrl = (urlOrAnchor) ->
-    # In case someone passed us a $link, unwrap it
-    if isJQuery(urlOrAnchor)
-      urlOrAnchor = getElement(urlOrAnchor)
+  parseUrl = (urlOrLink) ->
+    if isJQuery(urlOrLink)
+      # In case someone passed us a $link, unwrap it
+      link = up.element.get(urlOrLink)
+    else if urlOrLink.pathname
+      # If we are handed a parsed URL, just return it
+      link = urlOrLink
+    else
+      link = document.createElement('a')
+      link.href = urlOrLink
-    # If we are handed a parsed URL, just return it
-    if urlOrAnchor.pathname
-      return urlOrAnchor
+    # In IE11 the #hostname and #port properties of unqualified URLs are empty strings.
+    # We can fix this by setting the link's { href } on the link itself.
+    unless link.hostname
+      link.href = link.href
-    anchor = $('<a>').attr(href: urlOrAnchor).get(0)
-    # In IE11 the #hostname and #port properties of such a link are empty
-    # strings. However, we can fix this by assigning the anchor its own
-    # href because computer:
-    # https://gist.github.com/jlong/2428561#comment-1461205
-    anchor.href = anchor.href if isBlank(anchor.hostname)
-    anchor
+    # Some IEs don't include a leading slash in the #pathname property.
+    # We have confirmed this in IE11 and earlier.
+    unless link.pathname[0] == '/'
+      # Only copy the link into an object when we need to (to change a property).
+      # Note that we're parsing a lot of URLs for [up-active].
+      link = only(link, 'protocol', 'hostname', 'port', 'pathname', 'search', 'hash')
+      link.pathname = '/' + link.pathname
+    link
   ###**
   @function up.util.normalizeMethod
@@ -137,122 +146,6 @@ up.util = (($) ->
   methodAllowsPayload = (method) ->
     method != 'GET' && method != 'HEAD'
-  ###**
-  @function $createElementFromSelector
-  @internal
-  ###
-  $createElementFromSelector = (selector) ->
-    path = selector.split(/[ >]/)
-    $root = null
-    for depthSelector, iteration in path
-      conjunction = depthSelector.match(/(^|\.|\#)[A-Za-z0-9\-_]+/g)
-      tag = "div"
-      classes = []
-      id = null
-      for expression in conjunction
-        switch expression[0]
-          when "."
-            classes.push expression.substr(1)
-          when "#"
-            id = expression.substr(1)
-          else
-            tag = expression
-      html = "<" + tag
-      html += " class=\"" + classes.join(" ") + "\""  if classes.length
-      html += " id=\"" + id + "\""  if id
-      html += ">"
-      $element = $(html)
-      $element.appendTo($parent) if $parent
-      $root = $element if iteration == 0
-      $parent = $element
-    $root
-  ###**
-  @function $createPlaceHolder
-  @internal
-  ###
-  $createPlaceholder = (selector, container = document.body) ->
-    $placeholder = $createElementFromSelector(selector)
-    $placeholder.addClass('up-placeholder')
-    $placeholder.appendTo(container)
-    $placeholder
-  ###**
-  Returns a CSS selector that matches the given element as good as possible.
-  This uses, in decreasing order of priority:
-  - The element's `up-id` attribute
-  - The element's ID
-  - The element's name
-  - The element's classes
-  - The element's tag names
-  @function up.util.selectorForElement
-  @param {string|Element|jQuery}
-    The element for which to create a selector.
-  @experimental
-  ###
-  selectorForElement = (element) ->
-    $element = $(element)
-    selector = undefined
-    if isSingletonElement($element)
-      selector = elementTagName($element)
-    else if upId = presence($element.attr("up-id"))
-      selector = attributeSelector('up-id', upId)
-    else if id = presence($element.attr("id"))
-      if id.match(/^[a-z0-9\-_]+$/i)
-        selector = "##{id}"
-      else
-        selector = attributeSelector('id', id)
-    else if name = presence($element.attr("name"))
-      selector = elementTagName($element) + attributeSelector('name', name)
-    else if classes = presence(nonUpClasses($element))
-      selector = ''
-      for klass in classes
-        selector += ".#{klass}"
-    else if ariaLabel = presence($element.attr("aria-label"))
-      selector = attributeSelector('aria-label', ariaLabel)
-    else
-      selector = elementTagName($element)
-    return selector
-  isSingletonElement = ($element) ->
-    # jQuery's is() returns true if at least one element
-    # in the collection matches the selector
-    $element.is('html, body, head, title')
-#  isGoodSelector = (selector) ->
-#    selector.indexOf('#') >= -1 || selector.indexOf('[') >= -1
-#  defineMemoizedGetter = (obj, property, fetchFn) ->
-#    cacheProperty = "_#{property}Cache"
-#    Object.defineProperty methods, property,
-#      get: ->
-#        @[cacheProperty] ||= [fetchFn(this)]
-#        @[cacheProperty][0]
-  elementTagName = ($element) ->
-    $element.prop('tagName').toLowerCase()
-  attributeSelector = (attribute, value) ->
-    value = value.replace(/"/g, '\\"')
-    "[#{attribute}=\"#{value}\"]"
-  nonUpClasses = ($element) ->
-    classString = $element.attr('class') || ''
-    classes = splitValues(classString)
-    reject classes, (klass) -> klass.match(/^up-/)
-  # jQuery's implementation of $(...) cannot create elements that have
-  # an <html> or <body> tag. So we're using native elements.
-  # Also IE9 cannot set innerHTML on a <html> or <head> element.
-  createElementFromHtml = (html) ->
-    parser = new DOMParser()
-    parser.parseFromString(html, 'text/html')
   assignPolyfill = (target, sources...) ->
     for source in sources
       for own key, value of source
@@ -278,23 +171,11 @@ up.util = (($) ->
   @function up.util.values
   @param {Object} object
   @return {Array<string>}
-  @experimental
-  ###
-  objectValues = Object.values || valuesPolyfill
-  ###**
-  Returns a new string with whitespace removed from the beginning
-  and end of the given string.
-  @param {string}
-    A string that might have whitespace at the beginning and end.
-  @return {string}
-    The trimmed string.
   @stable
   ###
-  trim = $.trim
+  objectValues = Object.values || valuesPolyfill
-  listBlock = (block) ->
+  iteratee = (block) ->
     if isString(block)
       (item) -> item[block]
     else
@@ -304,8 +185,8 @@ up.util = (($) ->
   Translate all items in an array to new array of items.
   @function up.util.map
-  @param {Array<T>} array
-  @param {Function(T, number): any|String} block
+  @param {Array} array
+  @param {Function(element, index): any|String} block
     A function that will be called with each element and (optional) iteration index.
     You can also pass a property name as a String,
@@ -316,17 +197,27 @@ up.util = (($) ->
   ###
   map = (array, block) ->
     return [] if array.length == 0
-    block = listBlock(block)
+    block = iteratee(block)
     for item, index in array
       block(item, index)
+  ###**
+  @function up.util.mapObject
+  @internal
+  ###
+  mapObject = (array, pairer) ->
+    merger = (object, pair) ->
+      object[pair[0]] = pair[1]
+      return object
+    map(array, pairer).reduce(merger, {})
   ###**
   Calls the given function for each element (and, optional, index)
   of the given array.
   @function up.util.each
-  @param {Array<T>} array
-  @param {Function(T, number)} block
+  @param {Array} array
+  @param {Function(element, index)} block
     A function that will be called with each element and (optional) iteration index.
   @stable
   ###
@@ -341,7 +232,7 @@ up.util = (($) ->
   @function up.util.times
   @param {number} count
-  @param {Function} block
+  @param {Function()} block
   @stable
   ###
   times = (count, block) ->
@@ -416,41 +307,91 @@ up.util = (($) ->
   ###**
   Return whether the given argument is considered to be blank.
-  This returns `true` for:
+  By default, this function returns `true` for:
   - `undefined`
   - `null`
   - Empty strings
   - Empty arrays
-  - An object without own enumerable properties
+  - A plain object without own enumerable properties
   All other arguments return `false`.
+  To check implement blank-ness checks for user-defined classes,
+  see `up.util.isBlank.key`.
   @function up.util.isBlank
-  @param object
+  @param value
+    The value is to check.
   @return {boolean}
+    Whether the value is blank.
   @stable
   ###
-  isBlank = (object) ->
-    return true if isMissing(object)
-    return false if isFunction(object)
-    return true if isObject(object) && Object.keys(object).length == 0 # object
-    return true if object.length == 0 # string, array, jQuery
+  isBlank = (value) ->
+    if isMissing(value)
+      return true
+    if isObject(value) && value[isBlank.key]
+      return value[isBlank.key]()
+    if isString(value) || isList(value)
+      return value.length == 0
+    if isOptions(value)
+      return Object.keys(value).length == 0
     return false
+  ###**
+  This property contains the name of a method that user-defined classes
+  may implement to hook into the `up.util.isBlank()` protocol.
+  \#\#\# Example
+  We have a user-defined `Account` class that we want to use with `up.util.isBlank()`:
+  ```
+  class Account {
+    constructor(email) {
+      this.email = email
+    }
+    [up.util.isBlank.key]() {
+      return up.util.isBlank(this.email)
+    }
+  }
+  ```
+  Note that the protocol method is not actually named `'up.util.isBlank.key'`.
+  Instead it is named after the *value* of the `up.util.isBlank.key` property.
+  To do so, the code sample above is using a
+  [computed property name](https://medium.com/front-end-weekly/javascript-object-creation-356e504173a8)
+  in square brackets.
+  We may now use `Account` instances with `up.util.isBlank()`:
+  ```
+  foo = new Account('foo@foo.com')
+  bar = new Account('')
+  console.log(up.util.isBlank(foo)) // prints false
+  console.log(up.util.isBlank(bar)) // prints true
+  ```
+  @property up.util.isBlank.key
+  @experimental
+  ###
+  isBlank.key = 'up.util.isBlank'
   ###**
   Returns the given argument if the argument is [present](/up.util.isPresent),
   otherwise returns `undefined`.
   @function up.util.presence
-  @param object
-  @param {Function(T): boolean} [tester=up.util.isPresent]
+  @param value
+  @param {Function(value): boolean} [tester=up.util.isPresent]
     The function that will be used to test whether the argument is present.
-  @return {T|undefined}
+  @return {any|undefined}
   @stable
   ###
-  presence = (object, tester = isPresent) ->
-    if tester(object) then object else undefined
+  presence = (value, tester = isPresent) ->
+    if tester(value) then value else undefined
   ###**
   Returns whether the given argument is not [blank](/up.util.isBlank).
@@ -491,7 +432,7 @@ up.util = (($) ->
   @function up.util.isBoolean
   @param object
   @return {boolean}
-  @experimental
+  @stable
   ###
   isBoolean = (object) ->
     typeof(object) == 'boolean' || object instanceof Boolean
@@ -539,7 +480,7 @@ up.util = (($) ->
     (typeOfResult == 'object' && !isNull(object)) || typeOfResult == 'function'
   ###**
-  Returns whether the given argument is a DOM element.
+  Returns whether the given argument is a [DOM element](https://developer.mozilla.org/de/docs/Web/API/Element).
   @function up.util.isElement
   @param object
@@ -547,10 +488,10 @@ up.util = (($) ->
   @stable
   ###
   isElement = (object) ->
-    !!(object && object.nodeType == 1)
+    object instanceof Element
   ###**
-  Returns whether the given argument is a jQuery collection.
+  Returns whether the given argument is a [jQuery collection](https://learn.jquery.com/using-jquery-core/jquery-object/).
   @function up.util.isJQuery
   @param object
@@ -558,7 +499,7 @@ up.util = (($) ->
   @stable
   ###
   isJQuery = (object) ->
-    object instanceof jQuery
+    up.browser.canJQuery() && (object instanceof jQuery)
   ###**
   Returns whether the given argument is an object with a `then` method.
@@ -596,66 +537,183 @@ up.util = (($) ->
     object instanceof FormData
   ###**
-  Converts the given array-like argument into an array.
+  Converts the given [array-like value](/up.util.isList) into an array.
-  Returns the array.
+  If the given value is already an array, it is returned unchanged.
   @function up.util.toArray
   @param object
   @return {Array}
   @stable
   ###
-  toArray = (object) ->
-    Array.prototype.slice.call(object)
+  toArray = (value) ->
+    if isArray(value)
+      value
+    else
+      Array.prototype.slice.call(value)
+  ###***
+  Returns whether the given argument is an array-like value.
+  Return true for `Array`, a
+  [`NodeList`](https://developer.mozilla.org/en-US/docs/Web/API/NodeList),
+   the [arguments object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments)
+   or a jQuery collection.
+  Use [`up.util.isArray()`](/up.util.isArray) to test whether a value is an actual `Array`.
+  @function up.util.isList
+  @param value
+  @return {Boolean}
+  @experimental
+  ###
+  isList = (value) ->
+    isArray(value) ||
+      isNodeList(value) ||
+      isArguments(value) ||
+      isJQuery(value) ||
+      isHTMLCollection(value)
   ###**
-  Returns a shallow copy of the given array or object.
+  Returns whether the given value is a [`NodeList`](https://developer.mozilla.org/en-US/docs/Web/API/NodeList).
-  @function up.util.copy
-  @param {Object|Array} object
-  @return {Object|Array}
-  @stable
+  `NodeLists` are array-like objects returned by [`document.querySelectorAll()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/querySelectorAll).
+  @function up.util.isNodeList
+  @param value
+  @return {Boolean}
+  @internal
   ###
-  copy = (object, deep)  ->
-    if isArray(object)
-      object = object.slice()
-#      copied = true
-    else if isOptions(object)
-      object = assign({}, object)
-#      copied = true
-#    if copied && deep
-#      for key, value of object
-#        object[key] = copy(value, true)
-    object
+  isNodeList = (value) ->
+    value instanceof NodeList
+  isHTMLCollection = (value) ->
+    value instanceof HTMLCollection
 #  ###**
-#  Returns a deep copy of the given array or object.
+#  Returns whether the given value is an [`HTMLCollection`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection).
 #
-#  @function up.util.deepCopy
-#  @param {Object|Array} object
-#  @return {Object|Array}
-#  @internal
+#  @function up.util.isHtmlCollection
+#  @param value
+#  @return {Boolean}
+#  @experimental
 #  ###
-#  deepCopy = (object) ->
-#    copy(object, true)
+#  isHtmlCollection = (value) ->
+#    value instanceof HTMLCollection
   ###**
-  If given a jQuery collection, returns the first native DOM element in the collection.
-  If given a string, returns the first element matching that string.
-  If given any other argument, returns the argument unchanged.
+  Returns whether the given value is an [arguments object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments).
-  @function up.util.element
-  @param {jQuery|Element|String} object
-  @return {Element}
+  @function up.util.isArguments
+  @param value
+  @return {Boolean}
   @internal
   ###
-  getElement = (object) ->
-    if isJQuery(object)
-      object.get(0)
-    else if isString(object)
-      $(object).get(0)
+  isArguments = (value) ->
+    Object.prototype.toString.call(value) == '[object Arguments]'
+  ###**
+  @function up.util.wrapList
+  @return {Array|NodeList|jQuery}
+  @internal
+  ###
+  wrapList = (value) ->
+    if isList(value)
+      value
+    else if isMissing(value)
+      []
     else
-      object
+      [value]
+  ###**
+  Returns a shallow copy of the given value.
+  \#\#\# Copying protocol
+  - By default `up.util.copy()` can copy [array-like values](/up.util.isList),
+    plain objects and `Date` instances.
+  - Array-like objects are copied into new arrays.
+  - Unsupported types of values are returned unchanged.
+  - To make the copying protocol work with user-defined class,
+    see `up.util.copy.key`.
+  - Immutable objects, like strings or numbers, do not need to be copied.
+  @function up.util.copy
+  @param {any} object
+  @return {any}
+  @stable
+  ###
+  copy = (value, deep)  ->
+    if isObject(value) && value[copy.key]
+      value = value[copy.key]()
+    else if isList(value)
+      value = Array.prototype.slice.call(value)
+      copied = true
+    else if isOptions(value)
+      value = assign({}, value)
+      copied = true
+    if copied && deep
+      for k, v of value
+        value[k] = copy(v, true)
+    value
+  ###**
+  This property contains the name of a method that user-defined classes
+  may implement to hook into the `up.util.copy()` protocol.
+  \#\#\# Example
+  We have a user-defined `Account` class that we want to use with `up.util.copy()`:
+  ```
+  class Account {
+    constructor(email) {
+      this.email = email
+    }
+    [up.util.copy.key]() {
+      return new Account(this.email)
+    }
+  }
+  ```
+  Note that the protocol method is not actually named `'up.util.copy.key'`.
+  Instead it is named after the *value* of the `up.util.copy.key` property.
+  To do so, the code sample above is using a
+  [computed property name](https://medium.com/front-end-weekly/javascript-object-creation-356e504173a8)
+  in square brackets.
+  We may now use `Account` instances with `up.util.copy()`:
+  ```
+  original = new User('foo@foo.com')
+  copy = up.util.copy(original)
+  console.log(copy.email) // prints 'foo@foo.com'
+  original.email = 'bar@bar.com' // change the original
+  console.log(copy.email) // still prints 'foo@foo.com'
+  ```
+  @property up.util.copy.key
+  @param {string} key
+  @experimental
+  ###
+  copy.key = 'up.util.copy'
+  # Implement up.util.copy protocol for Date
+  Date.prototype[copy.key] = -> new Date(+@)
+  ###**
+  Returns a deep copy of the given array or object.
+  @function up.util.deepCopy
+  @param {Object|Array} object
+  @return {Object|Array}
+  @internal
+  ###
+  deepCopy = (object) ->
+    copy(object, true)
   ###**
   Creates a new object by merging together the properties from the given objects.
@@ -716,34 +774,20 @@ up.util = (($) ->
       {}
   ###**
-  Returns the first argument that is considered [given](/up.util.isGiven).
-  This function is useful when you have multiple option sources and the value can be boolean.
-  In that case you cannot change the sources with a `||` operator
-  (since that doesn't short-circuit at `false`).
-  @function up.util.option
-  @param {Array} args...
-  @internal
-  ###
-  option = (args...) ->
-    detect(args, isGiven)
-  ###**
-  Passes each element in the given array to the given function.
+  Passes each element in the given [array-like value](/up.util.isList) to the given function.
   Returns the first element for which the function returns a truthy value.
   If no object matches, returns `undefined`.
-  @function up.util.detect
-  @param {Array<T>} array
-  @param {Function(T): boolean} tester
+  @function up.util.find
+  @param {List<T>} list
+  @param {Function(value): boolean} tester
   @return {T|undefined}
   @stable
   ###
-  detect = (array, tester) ->
+  findInList = (list, tester) ->
     match = undefined
-    for element in array
+    for element in list
       if tester(element)
         match = element
         break
@@ -751,41 +795,57 @@ up.util = (($) ->
   ###**
   Returns whether the given function returns a truthy value
-  for any element in the given array.
+  for any element in the given [array-like value](/up.util.isList).
-  @function up.util.any
-  @param {Array<T>} array
-  @param {Function(T, number): boolean} tester
+  @function up.util.some
+  @param {List} list
+  @param {Function(value, index): boolean} tester
     A function that will be called with each element and (optional) iteration index.
   @return {boolean}
+  @stable
+  ###
+  some = (list, tester) ->
+    !!findResult(list, tester)
+  ###**
+  Consecutively calls the given function which each element
+  in the given array. Returns the first truthy return value.
+  Returned `undefined` iff the function does not return a truthy
+  value for any element in the array.
+  @function up.util.findResult
+  @param {Array} array
+  @param {Function(element): any} tester
+    A function that will be called with each element and (optional) iteration index.
+  @return {any|undefined}
   @experimental
   ###
-  any = (array, tester) ->
-    tester = listBlock(tester)
-    match = false
+  findResult = (array, tester) ->
+    tester = iteratee(tester)
     for element, index in array
-      if tester(element, index)
-        match = true
-        break
-    match
+      if result = tester(element, index)
+        return result
+    return undefined
   ###**
   Returns whether the given function returns a truthy value
-  for all elements in the given array.
+  for all elements in the given [array-like value](/up.util.isList).
-  @function up.util.all
-  @param {Array<T>} array
-  @param {Function(T, number): boolean} tester
+  @function up.util.every
+  @param {List} list
+  @param {Function(element, index): boolean} tester
     A function that will be called with each element and (optional) iteration index.
   @return {boolean}
   @experimental
   ###
-  all = (array, tester) ->
-    tester = listBlock(tester)
+  every = (list, tester) ->
+    tester = iteratee(tester)
     match = true
-    for element, index in array
+    for element, index in list
       unless tester(element, index)
         match = false
         break
@@ -801,7 +861,7 @@ up.util = (($) ->
   @stable
   ###
   compact = (array) ->
-    select array, isGiven
+    filterList array, isGiven
   ###**
   Returns the given array without duplicates.
@@ -821,16 +881,16 @@ up.util = (($) ->
   for which uniquness is computed.
   @function up.util.uniqBy
-  @param {Array<T>} array
-  @param {Function<T>: any} array
-  @return {Array<T>}
+  @param {Array} array
+  @param {Function(value): any} array
+  @return {Array}
   @experimental
   ###
   uniqBy = (array, mapper) ->
     return array if array.length < 2
-    mapper = listBlock(mapper)
+    mapper = iteratee(mapper)
     set = new Set()
-    select array, (elem, index) ->
+    filterList array, (elem, index) ->
       mapped = mapper(elem, index)
       if set.has(mapped)
         false
@@ -857,36 +917,36 @@ up.util = (($) ->
     set
   ###**
-  Returns all elements from the given array that return
+  Returns all elements from the given [array-like value](/up.util.isList) that return
   a truthy value when passed to the given function.
-  @function up.util.select
-  @param {Array<T>} array
-  @param {Function(T, number): boolean} tester
-  @return {Array<T>}
+  @function up.util.filter
+  @param {List} list
+  @param {Function(value, index): boolean} tester
+  @return {Array}
   @stable
   ###
-  select = (array, tester) ->
-    tester = listBlock(tester)
+  filterList = (list, tester) ->
+    tester = iteratee(tester)
     matches = []
-    each array, (element, index) ->
+    each list, (element, index) ->
       if tester(element, index)
         matches.push(element)
     matches
   ###**
-  Returns all elements from the given array that do not return
+  Returns all elements from the given [array-like value](/up.util.isList) that do not return
   a truthy value when passed to the given function.
   @function up.util.reject
-  @param {Array<T>} array
-  @param {Function(T, number): boolean} tester
-  @return {Array<T>}
+  @param {List} list
+  @param {Function(element, index): boolean} tester
+  @return {Array}
   @stable
   ###
-  reject = (array, tester) ->
-    tester = listBlock(tester)
-    select(array, (element, index) -> !tester(element, index))
+  reject = (list, tester) ->
+    tester = iteratee(tester)
+    filterList(list, (element, index) -> !tester(element, index))
   ###**
   Returns the intersection of the given two arrays.
@@ -897,74 +957,45 @@ up.util = (($) ->
   @internal
   ###
   intersect = (array1, array2) ->
-    select array1, (element) ->
+    filterList array1, (element) ->
       contains(array2, element)
-  addClass = (element, klassOrKlasses) ->
-    changeClassList(element, klassOrKlasses, 'add')
-  removeClass = (element, klassOrKlasses) ->
-    changeClassList(element, klassOrKlasses, 'remove')
-  changeClassList = (element, klassOrKlasses, fnName) ->
-    classList = getElement(element).classList
-    if isArray(klassOrKlasses)
-      each klassOrKlasses, (klass) ->
-        classList[fnName](klass)
-    else
-      classList[fnName](klassOrKlasses)
-  addTemporaryClass = (element, klassOrKlasses) ->
-    addClass(element, klassOrKlasses)
-    -> removeClass(element, klassOrKlasses)
-  hasClass = (element, klass) ->
-    classList = getElement(element).classList
-    classList.contains(klass)
-  ###**
-  Returns the first [present](/up.util.isPresent) element attribute
-  among the given list of attribute names.
-  @function up.util.presentAttr
-  @internal
-  ###
-  presentAttr = ($element, attrNames...) ->
-    values = ($element.attr(attrName) for attrName in attrNames)
-    detect(values, isPresent)
   ###**
   Waits for the given number of milliseconds, the runs the given callback.
-  Instead of `up.util.setTimer(0, fn)` you can also use [`up.util.nextFrame(fn)`](/up.util.nextFrame).
+  Instead of `up.util.timer(0, fn)` you can also use [`up.util.task(fn)`](/up.util.task).
-  @function up.util.setTimer
+  @function up.util.timer
   @param {number} millis
-  @param {Function} callback
+  @param {Function()} callback
   @stable
   ###
-  setTimer = (millis, callback) ->
+  scheduleTimer = (millis, callback) ->
     setTimeout(callback, millis)
   ###**
-  Schedules the given function to be called in the
-  next JavaScript execution frame.
+  Pushes the given function to the [JavaScript task queue](https://jakearchibald.com/2015/tasks-microtasks-queues-and-schedules/) (also "macrotask queue").
+  Equivalent to calling `setTimeout(fn, 0)`.
-  @function up.util.nextFrame
-  @param {Function} block
+  Also see `up.util.microtask()`.
+  @function up.util.task
+  @param {Function()} block
   @stable
   ###
-  nextFrame = (block) ->
+  queueTask = (block) ->
     setTimeout(block, 0)
   ###**
-  Queue a function to be executed in the next microtask.
+  Pushes the given function to the [JavaScript microtask queue](https://jakearchibald.com/2015/tasks-microtasks-queues-and-schedules/).
-  @function up.util.queueMicrotask
-  @param {Function} task
-  @internal
+  @function up.util.microtask
+  @param {Function()} task
+  @return {Promise}
+  @experimental
   ###
-  microtask = (task) ->
+  queueMicrotask = (task) ->
     Promise.resolve().then(task)
   ###**
@@ -977,202 +1008,6 @@ up.util = (($) ->
   last = (array) ->
     array[array.length - 1]
-  ###**
-  Measures the drawable area of the document.
-  @function up.util.clientSize
-  @internal
-  ###
-  clientSize = ->
-    element = document.documentElement
-    width: element.clientWidth
-    height: element.clientHeight
-  ###**
-  Returns the width of a scrollbar.
-  This only runs once per page load.
-  @function up.util.scrollbarWidth
-  @internal
-  ###
-  scrollbarWidth = memoize ->
-    # This is how Bootstrap does it also:
-    # https://github.com/twbs/bootstrap/blob/c591227602996c542b9fd0cb65cff3cc9519bdd5/dist/js/bootstrap.js#L1187
-    $outer = $('<div>')
-    outer = $outer.get(0)
-    $outer.attr('up-viewport', '')
-    writeInlineStyle outer,
-      position:  'absolute'
-      top:       '0'
-      left:      '0'
-      width:     '100px'
-      height:    '100px' # Firefox needs at least 100px to show a scrollbar
-      overflowY: 'scroll'
-    $outer.appendTo(document.body)
-    width = outer.offsetWidth - outer.clientWidth
-    $outer.remove()
-    width
-  ###**
-  Returns whether the given element is currently showing a vertical scrollbar.
-  @function up.util.documentHasVerticalScrollbar
-  @internal
-  ###
-  documentHasVerticalScrollbar = ->
-    body = document.body
-    $body = $(body)
-    html = document.documentElement
-    bodyOverflow = readComputedStyle($body, 'overflowY')
-    forcedScroll = (bodyOverflow == 'scroll')
-    forcedHidden = (bodyOverflow == 'hidden')
-    forcedScroll || (!forcedHidden && html.scrollHeight > html.clientHeight)
-  ###**
-  Temporarily sets the CSS for the given element.
-  @function up.util.writeTemporaryStyle
-  @param {jQuery} $element
-  @param {Object} css
-  @param {Function} [block]
-    If given, the CSS is set, the block is called and
-    the old CSS is restored.
-  @return {Function}
-    A function that restores the original CSS when called.
-  @internal
-  ###
-  writeTemporaryStyle = (elementOrSelector, newCss, block) ->
-    $element = $(elementOrSelector)
-    oldStyles = readInlineStyle($element, Object.keys(newCss))
-    restoreOldStyles = -> writeInlineStyle($element, oldStyles)
-    writeInlineStyle($element, newCss)
-    if block
-      # If a block was passed, we run the block and restore old styles.
-      block()
-      restoreOldStyles()
-    else
-      # If no block was passed, we return the restoration function.
-      restoreOldStyles
-  ###**
-  Forces a repaint of the given element.
-  @function up.util.forceRepaint
-  @internal
-  ###
-  forceRepaint = (element) ->
-    element = getElement(element)
-    element.offsetHeight
-  ###**
-  @function up.util.finishTransition
-  @internal
-  ###
-  concludeCssTransition = (element) ->
-    undo = writeTemporaryStyle(element, transition: 'none')
-    # Browsers need to paint at least one frame without a transition to stop the
-    # animation. In theory we could just wait until the next paint, but in case
-    # someone will set another transition after us, let's force a repaint here.
-    forceRepaint(element)
-    return undo
-  ###**
-  @internal
-  ###
-  margins = (selectorOrElement) ->
-    element = getElement(selectorOrElement)
-    top:    readComputedStyleNumber(element, 'marginTop')
-    right:  readComputedStyleNumber(element, 'marginRight')
-    bottom: readComputedStyleNumber(element, 'marginBottom')
-    left:   readComputedStyleNumber(element, 'marginLeft')
-  ###**
-  Measures the given element.
-  @function up.util.measure
-  @internal
-  ###
-  measure = ($element, opts) ->
-    opts = newOptions(opts, relative: false, inner: false, includeMargin: false)
-    if opts.relative
-      if opts.relative == true
-        coordinates = $element.position()
-      else
-        # A relative context element is given
-        $context = $(opts.relative)
-        elementCoords = $element.offset()
-        if $context.is(document)
-          # The document is always at the origin
-          coordinates = elementCoords
-        else
-          contextCoords = $context.offset()
-          coordinates =
-            left: elementCoords.left - contextCoords.left
-            top: elementCoords.top - contextCoords.top
-    else
-      coordinates = $element.offset()
-    box =
-      left: coordinates.left
-      top: coordinates.top
-    if opts.inner
-      box.width = $element.width()
-      box.height = $element.height()
-    else
-      box.width = $element.outerWidth()
-      box.height = $element.outerHeight()
-    if opts.includeMargin
-      mgs = margins($element)
-      box.left -= mgs.left
-      box.top -= mgs.top
-      box.height += mgs.top + mgs.bottom
-      box.width += mgs.left + mgs.right
-    box
-  ###**
-  Copies all attributes from the source element to the target element.
-  @function up.util.copyAttributes
-  @internal
-  ###
-  copyAttributes = ($source, $target) ->
-    for attr in $source.get(0).attributes
-      if attr.specified
-        $target.attr(attr.name, attr.value)
-  ###**
-  Looks for the given selector in the element and its descendants.
-  @function up.util.selectInSubtree
-  @internal
-  ###
-  selectInSubtree = ($element, selector) ->
-    # This implementation is faster than $element.find(selector).addBack(Seelctor)
-    $matches = $()
-    if $element.is(selector)
-      $matches = $matches.add($element)
-    $matches = $matches.add($element.find(selector))
-    $matches
-  ###**
-  Looks for the given selector in the element, its descendants and its ancestors.
-  @function up.util.selectInDynasty
-  @internal
-  ###
-  selectInDynasty = ($element, selector) ->
-    $subtree = selectInSubtree($element, selector)
-    $ancestors = $element.parents(selector)
-    $subtree.add($ancestors)
   ###**
   Returns whether the given keyboard event involved the ESC key.
@@ -1180,7 +1015,8 @@ up.util = (($) ->
   @internal
   ###
   escapePressed = (event) ->
-    event.keyCode == 27
+    key = event.key
+    key == 'Escape' || key == 'Esc'
   ###**
   Returns whether the given array or string contains the given element or substring.
@@ -1193,34 +1029,6 @@ up.util = (($) ->
   contains = (arrayOrString, elementOrSubstring) ->
     arrayOrString.indexOf(elementOrSubstring) >= 0
-  ###**
-  @function up.util.castedAttr
-  @internal
-  ###
-  castedAttr = ($element, attribute) ->
-    value = $element.attr(attribute)
-    switch value
-      when 'false' then false
-      when 'true', '', attribute then true
-      else value # other strings, undefined, null, ...
-  ###**
-  @function up.util.jsonAttr
-  @internal
-  ###
-  jsonAttr = (elementOrSelector, attribute) ->
-    if element = getElement(elementOrSelector)
-      # The document does not respond to #getAttribute()
-      json = element.getAttribute?(attribute)
-      if isString(json) && trim(json) != ''
-        JSON.parse(json)
-#  castsToTrue = (object) ->
-#    String(object) == "true"
-#
-#  castsToFalse = (object) ->
-#    String(object) == "false"
   ###**
   Returns a copy of the given object that only contains
   the given properties.
@@ -1278,31 +1086,11 @@ up.util = (($) ->
   Returns a promise that will never be resolved.
   @function up.util.unresolvablePromise
-  @experimental
+  @internal
   ###
   unresolvablePromise = ->
     new Promise(noop)
-  ###**
-  Returns an empty jQuery collection.
-  @function up.util.nullJQuery
-  @internal
-  ###
-  nullJQuery = ->
-    $()
-  ###**
-  On the given element, set attributes that are still missing.
-  @function up.util.setMissingAttrs
-  @internal
-  ###
-  setMissingAttrs = ($element, attrs) ->
-    for key, value of attrs
-      if isMissing($element.attr(key))
-        $element.attr(key, value)
   ###**
   Removes the given element from the given array.
@@ -1332,102 +1120,6 @@ up.util = (($) ->
     else
       value
-  ###**
-  @function up.util.config
-  @param {Object|Function} blueprint
-    Default configuration options.
-    Will be restored by calling `reset` on the returned object.
-  @return {Object}
-    An object with a `reset` function.
-  @internal
-  ###
-  config = (blueprint) ->
-    hash = openConfig(blueprint)
-    Object.preventExtensions(hash)
-    hash
-  ###**
-  @function up.util.openConfig
-  @internal
-  ###
-  openConfig = (blueprint = {}) ->
-    hash = {}
-    hash.reset = ->
-      opts = blueprint
-      opts = opts() if isFunction(opts)
-      assign(hash, opts)
-    hash.reset()
-    hash
-  ###**
-  @function up.util.unwrapElement
-  @internal
-  ###
-  unwrapElement = (wrapper) ->
-    wrapper = getElement(wrapper)
-    parent = wrapper.parentNode;
-    wrappedNodes = toArray(wrapper.childNodes)
-    each wrappedNodes, (wrappedNode) ->
-      parent.insertBefore(wrappedNode, wrapper)
-    parent.removeChild(wrapper)
-  ###**
-  @function up.util.offsetParent
-  @internal
-  ###
-  offsetParent = ($element) ->
-    $match = undefined
-    while ($element = $element.parent()) && $element.length
-      position = readComputedStyle($element, 'position')
-      if position == 'absolute' || position == 'relative' || $element.is('body')
-        $match = $element
-        break
-    $match
-  ###**
-  Returns if the given element has a `fixed` position.
-  @function up.util.isFixed
-  @internal
-  ###
-  isFixed = (element) ->
-    $element = $(element)
-    loop
-      position = readComputedStyle($element, 'position')
-      if position == 'fixed'
-        return true
-      else
-        $element = $element.parent()
-        if $element.length == 0 || $element.is(document)
-          return false
-  ###**
-  @function up.util.fixedToAbsolute
-  @internal
-  ###
-  fixedToAbsolute = (element, $viewport) ->
-    $element = $(element)
-    $futureOffsetParent = offsetParent($element)
-    # To get a fixed elements distance from the edge of the screen,
-    # use position(), not offset(). offset() would include the current
-    # scrollTop of the viewport.
-    elementCoords = $element.position()
-    futureParentCoords = $futureOffsetParent.offset()
-    writeInlineStyle $element,
-      position: 'absolute'
-      left: elementCoords.left - futureParentCoords.left
-      top: elementCoords.top - futureParentCoords.top + $viewport.scrollTop()
-      right: ''
-      bottom: ''
-#  argNames = (fun) ->
-#    code = fun.toString()
-#    pattern = new RegExp('\\(([^\\)]*)\\)')
-#    if match = code.match(pattern)
-#      match[1].split(/\s*,\s*/)
-#    else
-#      error('Could not parse argument names of %o', fun)
   ###**
   Throws a [JavaScript error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
   with the given message.
@@ -1461,9 +1153,9 @@ up.util = (($) ->
     up.log.error(messageArgs...)
-    whenReady().then -> up.toast.open(messageArgs, toastOptions)
+    up.event.onReady(-> up.toast.open(messageArgs, toastOptions))
-    asString = up.browser.sprintf(messageArgs...)
+    asString = up.log.sprintf(messageArgs...)
     throw new Error(asString)
   ESCAPE_HTML_ENTITY_MAP =
@@ -1478,11 +1170,19 @@ up.util = (($) ->
   @function up.util.escapeHtml
   @param {string} string
     The text that should be escaped
-  @experimental
+  @stable
   ###
   escapeHtml = (string) ->
     string.replace /[&<>"]/g, (char) -> ESCAPE_HTML_ENTITY_MAP[char]
+  ###**
+  @function up.util.escapeRegexp
+  @internal
+  ###
+  escapeRegexp = (string) ->
+    # From https://github.com/benjamingr/RegExp.escape
+    string.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&')
   pluckKey = (object, key) ->
     value = object[key]
     delete object[key]
@@ -1491,118 +1191,41 @@ up.util = (($) ->
   renameKey = (object, oldKey, newKey) ->
     object[newKey] = pluckKey(object, oldKey)
-  deprecateRenamedKey = (object, oldKey, newKey) ->
-    if isDefined(object[oldKey])
-      up.warn('Deprecated: Object key { %s } has been renamed to { %s } (found in %o)', oldKey, newKey, object)
-      renameKey(object, oldKey, newKey)
-  pluckData = (elementOrSelector, key) ->
-    $element = $(elementOrSelector)
-    value = $element.data(key)
-    $element.removeData(key)
-    value
-  extractOptions = (args) ->
+  extractLastArg = (args, tester) ->
     lastArg = last(args)
-    if isOptions(lastArg)
-      args.pop()
-    else
-      {}
+    if tester(lastArg)
+      return args.pop()
-  CASE_CONVERSION_GROUP = /[^\-\_]+?(?=[A-Z\-\_]|$)/g
+#  extractFirstArg = (args, tester) ->
+#    firstArg = args[0]
+#    if tester(firstArg)
+#      return args.shift()
-  convertCase = (string, separator, fn) ->
-    parts = string.match(CASE_CONVERSION_GROUP)
-    parts = map parts, fn
-    parts.join(separator)
+  extractCallback = (args) ->
+    extractLastArg(args, isFunction)
-  ###**
-  Returns a copy of the given string that is transformed to `kebab-case`.
-  @function up.util.kebabCase
-  @param {string} string
-  @return {string}
-  @internal
-  ###
-  kebabCase = (string) ->
-    convertCase string, '-', (part) -> part.toLowerCase()
-  ###**
-  Returns a copy of the given string that is transformed to `camelCase`.
-  @function up.util.camelCase
-  @param {string} string
-  @return {string}
-  @internal
-  ###
-  camelCase = (string) ->
-    convertCase string, '', (part, i) ->
-      if i == 0
-        part.toLowerCase()
-      else
-        part.charAt(0).toUpperCase() + part.substr(1).toLowerCase()
-  ###**
-  Returns a copy of the given object with all keys renamed
-  in `kebab-case`.
-  Does not change the given object.
-  @function up.util.kebabCaseKeys
-  @param {object} obj
-  @return {object}
-  @internal
-  ###
-  kebabCaseKeys = (obj) ->
-    copyWithRenamedKeys(obj, kebabCase)
-  ###**
-  Returns a copy of the given object with all keys renamed
-  in `camelCase`.
-  Does not change the given object.
-  @function up.util.camelCaseKeys
-  @param {object} obj
-  @return {object}
-  @internal
-  ###
-  camelCaseKeys = (obj) ->
-    copyWithRenamedKeys(obj, camelCase)
-#  lowerCaseKeys = (obj) ->
-#    copyWithRenamedKeys(obj, (key) -> key.toLowerCase())
-  copyWithRenamedKeys = (obj, keyTransformer) ->
-    result = {}
-    for k, v of obj
-      k = keyTransformer(k)
-      result[k] = v
-    result
-  opacity = (element) ->
-    readComputedStyleNumber(element, 'opacity')
-  whenReady = memoize ->
-    if $.isReady
-      Promise.resolve()
-    else
-      new Promise (resolve) -> $(resolve)
+  extractOptions = (args) ->
+    extractLastArg(args, isOptions) || {}
+  partial = (fn, fixedArgs...) ->
+    return (callArgs...) ->
+      fn.apply(this, fixedArgs.concat(callArgs))
+#function throttle(callback, limit) { // From https://jsfiddle.net/jonathansampson/m7G64/
+#  var wait = false                   // Initially, we're not waiting
+#  return function () {               // We return a throttled function
+#    if (!wait) {                     // If we're not waiting
+#      callback.call()                // Execute users function
+#      wait = true                    // Prevent future invocations
+#      setTimeout(function () {       // After a period of time
+#        wait = false                 // And allow future invocations
+#      }, limit)
+#    }
+#  }
+#}
   identity = (arg) -> arg
-  ###**
-  Returns whether the given element has been detached from the DOM
-  (or whether it was never attached).
-  @function up.util.isDetached
-  @internal
-  ###
-  isDetached = (element) ->
-    element = getElement(element)
-    # This is by far the fastest way to do this
-    not $.contains(document.documentElement, element)
 #  ###**
 #  ###
 #  parsePath = (input) ->
@@ -1637,66 +1260,19 @@ up.util = (($) ->
     preview.promise = deferred.promise()
     preview
-  ###**
-  A linear task queue whose (2..n)th tasks can be changed at any time.
-  @function up.util.DivertibleChain
-  @internal
-  ###
-  class DivertibleChain
-    constructor: ->
-      @reset()
-    reset: =>
-      @queue = []
-      @currentTask = undefined
-    promise: =>
-      lastTask = last(@allTasks())
-      lastTask?.promise || Promise.resolve()
-    allTasks: =>
-      tasks = []
-      tasks.push(@currentTask) if @currentTask
-      tasks = tasks.concat(@queue)
-      tasks
-    poke: =>
-      unless @currentTask # don't start a new task while we're still running one
-        if @currentTask = @queue.shift()
-          promise = @currentTask()
-          always promise, =>
-            @currentTask = undefined
-            @poke()
-    asap: (newTasks...) =>
-      @queue = map(newTasks, previewable)
-      @poke()
-      @promise()
-  ###**
-  @function up.util.submittedValue
-  @internal
-  ###
-  submittedValue = (fieldOrSelector) ->
-    $field = $(fieldOrSelector)
-    if $field.is('[type=checkbox], [type=radio]') && !$field.is(':checked')
-      undefined
-    else
-      $field.val()
   ###**
   @function up.util.sequence
-  @param {Array<Function>} functions...
-  @return {Function}
+  @param {Array<Function()>} functions
+  @return {Function()}
     A function that will call all `functions` if called.
   @internal
   ###
-  sequence = (functions...) ->
-    ->
-      map functions, (f) -> f()
+  sequence = (functions) ->
+    if functions.length == 1
+      return functions[0]
+    else
+      return -> map(functions, (f) -> f())
 #  ###**
 #  @function up.util.race
@@ -1708,17 +1284,6 @@ up.util = (($) ->
 #      promise.then -> raceDone.resolve()
 #    raceDone.promise()
-  ###**
-  @function up.util.promiseTimer
-  @internal
-  ###
-  promiseTimer = (ms) ->
-    timeout = undefined
-    promise = new Promise (resolve, reject) ->
-      timeout = setTimer(ms, resolve)
-    promise.cancel = -> clearTimeout(timeout)
-    promise
   ###**
   Returns `'left'` if the center of the given element is in the left 50% of the screen.
   Otherwise returns `'right'`.
@@ -1726,160 +1291,15 @@ up.util = (($) ->
   @function up.util.horizontalScreenHalf
   @internal
   ###
-  horizontalScreenHalf = ($element) ->
-    elementDims = measure($element)
-    screenDims = clientSize()
+  horizontalScreenHalf = (element) ->
+    elementDims = element.getBoundingClientRect()
     elementMid = elementDims.left + 0.5 * elementDims.width
-    screenMid = 0.5 * screenDims.width
+    screenMid = 0.5 * up.viewport.rootWidth()
     if elementMid < screenMid
       'left'
     else
       'right'
-  ###**
-  Like `$old.replaceWith($new)`, but keeps event handlers bound to `$old`.
-  Note that this is a memory leak unless you re-attach `$old` to the DOM aferwards.
-  @function up.util.detachWith
-  @internal
-  ###
-  detachWith = ($old, $new) ->
-    $insertion = $('<div></div>')
-    $insertion.insertAfter($old)
-    $old.detach()
-    $insertion.replaceWith($new)
-    $old
-  ###**
-  Hides the given element faster than `jQuery.fn.hide()`.
-  @function up.util.hide
-  @param {jQuery|Element} element
-  ###
-  hide = (element) ->
-    writeInlineStyle(element, display: 'none')
-  ###**
-  Gets the computed style(s) for the given element.
-  @function up.util.readComputedStyle
-  @param {jQuery|Element} element
-  @param {String|Array} propOrProps
-    One or more CSS property names in camelCase.
-  @return {string|object}
-  @internal
-  ###
-  readComputedStyle = (element, props) ->
-    element = getElement(element)
-    style = window.getComputedStyle(element)
-    extractFromStyleObject(style, props)
-  ###**
-  Gets a computed style value for the given element.
-  If a value is set, the value is parsed to a number before returning.
-  @function up.util.readComputedStyleNumber
-  @param {jQuery|Element} element
-  @param {String} prop
-    A CSS property name in camelCase.
-  @return {string|object}
-  @internal
-  ###
-  readComputedStyleNumber = (element, prop) ->
-    rawValue = readComputedStyle(element, prop)
-    if isGiven(rawValue)
-      parseFloat(rawValue)
-    else
-      undefined
-  ###**
-  Gets the given inline style(s) from the given element's `[style]` attribute.
-  @function up.util.readInlineStyle
-  @param {jQuery|Element} element
-  @param {String|Array} propOrProps
-    One or more CSS property names in camelCase.
-  @return {string|object}
-  @internal
-  ###
-  readInlineStyle = (element, props) ->
-    element = getElement(element)
-    style = element.style
-    extractFromStyleObject(style, props)
-  extractFromStyleObject = (style, keyOrKeys) ->
-    if isString(keyOrKeys)
-      style[keyOrKeys]
-    else # array
-      only(style, keyOrKeys...)
-  ###**
-  Merges the given inline style(s) into the given element's `[style]` attribute.
-  @function up.util.readInlineStyle
-  @param {jQuery|Element} element
-  @param {Object} props
-    One or more CSS properties with camelCase keys.
-  @return {string|object}
-  @internal
-  ###
-  writeInlineStyle = (element, props) ->
-    element = getElement(element)
-    style = element.style
-    for key, value of props
-      value = normalizeStyleValueForWrite(key, value)
-      style[key] = value
-  normalizeStyleValueForWrite = (key, value) ->
-    if isMissing(value)
-      value = ''
-    else if CSS_LENGTH_PROPS.has(key)
-      value = cssLength(value)
-    value
-  CSS_LENGTH_PROPS = arrayToSet [
-    'top', 'right', 'bottom', 'left',
-    'padding', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft',
-    'margin', 'marginTop', 'marginRight', 'marginBottom', 'marginLeft',
-    'width', 'height',
-    'maxWidth', 'maxHeight',
-    'minWidth', 'minHeight',
-  ]
-  ###**
-  Converts the given value to a CSS length value, adding a `px` unit if required.
-  @function up.util.cssLength
-  @internal
-  ###
-  cssLength = (obj) ->
-    if isNumber(obj) || (isString(obj) && /^\d+$/.test(obj))
-      obj.toString() + "px"
-    else
-      obj
-  ###**
-  Returns whether the given element has a CSS transition set.
-  @function up.util.hasCssTransition
-  @return {boolean}
-  @internal
-  ###
-  hasCssTransition = (elementOrStyleHash) ->
-    if isOptions(elementOrStyleHash)
-      style = elementOrStyleHash
-    else
-      element = getElement(element)
-      style = getComputedStyle(element)
-    prop = style.transitionProperty
-    duration = style.transitionDuration
-    # The default transition for elements is actually "all 0s ease 0s"
-    # instead of "none", although that has the same effect as "none".
-    noTransition = (prop == 'none' || (prop == 'all' && duration == 0))
-    not noTransition
   ###**
   Flattens the given `array` a single level deep.
@@ -1888,17 +1308,27 @@ up.util = (($) ->
     An array which might contain other arrays
   @return {Array}
     The flattened array
-  @internal
+  @experimental
   ###
   flatten = (array) ->
     flattened = []
     for object in array
-      if isArray(object)
-        flattened = flattened.concat(object)
+      if isList(object)
+        flattened.push(object...)
       else
         flattened.push(object)
     flattened
+  ###**
+  Maps each element using a mapping function,
+  then flattens the result into a new array.
+  @function up.util.flatMap
+  @param {Array} array
+  @param {Function(element)} mapping
+  @return {Array}
+  @experimental
+  ###
   flatMap = (array, block) ->
     flatten map(array, block)
@@ -1975,7 +1405,7 @@ up.util = (($) ->
       Promise.reject(error)
   sum = (list, block) ->
-    block = listBlock(block)
+    block = iteratee(block)
     totalValue = 0
     for entry in list
       entryValue = block(entry)
@@ -1983,34 +1413,126 @@ up.util = (($) ->
         totalValue += entryValue
     totalValue
+  isBasicObjectProperty = (k) ->
+    Object.prototype.hasOwnProperty(k)
   ###**
-  Returns whether the given element is a descendant of the `<body>` element.
+  Returns whether the two arguments are equal by value.
-  @function up.util.isBodyDescendant
-  @internal
-  ###
-  isBodyDescendant = (element) ->
-    $(element).parents('body').length > 0
+  \#\#\# Comparison protocol
-  isBasicObjectProperty = (k) ->
-    Object.prototype.hasOwnProperty(k)
+  - By default `up.util.isEqual()` can compare strings, numbers,
+    [array-like values](/up.util.isList), plain objects and `Date` objects.
+  - To make the copying protocol work with user-defined classes,
+    see `up.util.isEqual.key`.
+  - Objects without a defined comparison protocol are
+    defined by reference (`===`).
+  @function up.util.isEqual
+  @param {any} a
+  @param {any} b
+  @return {boolean}
+    Whether the arguments are equal by value.
+  @experimental
+  ###
   isEqual = (a, b) ->
+    a = a.valueOf() if a?.valueOf # Date, String objects, Number objects
+    b = b.valueOf() if b?.valueOf # Date, String objects, Number objects
     if typeof(a) != typeof(b)
       false
-    else if isArray(a)
-      a.length == b.length && all(a, (elem, index) -> isEqual(elem, b[index]))
-    else if isObject(a)
-      fail('isEqual cannot compare objects yet')
+    else if isList(a) && isList(b)
+      isEqualList(a, b)
+    else if isObject(a) && a[isEqual.key]
+      a[isEqual.key](b)
+    else if isOptions(a) && isOptions(b)
+      aKeys = Object.keys(a)
+      bKeys = Object.keys(b)
+      if isEqualList(aKeys, bKeys)
+        every aKeys, (aKey) -> isEqual(a[aKey], b[aKey])
+      else
+        false
     else
       a == b
-  splitValues = (string, separator = ' ') ->
-    values = string.split(separator)
-    values = map(values, trim)
-    values = select(values, isPresent)
+  ###**
+  This property contains the name of a method that user-defined classes
+  may implement to hook into the `up.util.isEqual()` protocol.
+  \#\#\# Example
+  We have a user-defined `Account` class that we want to use with `up.util.isEqual()`:
+  ```
+  class Account {
+    constructor(email) {
+      this.email = email
+    }
+    [up.util.isEqual.key](other) {
+      return this.email === other.email;
+    }
+  }
+  ```
+  Note that the protocol method is not actually named `'up.util.isEqual.key'`.
+  Instead it is named after the *value* of the `up.util.isEqual.key` property.
+  To do so, the code sample above is using a
+  [computed property name](https://medium.com/front-end-weekly/javascript-object-creation-356e504173a8)
+  in square brackets.
+  We may now use `Account` instances with `up.util.isEqual()`:
+  ```
+  one = new User('foo@foo.com')
+  two = new User('foo@foo.com')
+  three = new User('bar@bar.com')
+  isEqual = up.util.isEqual(one, two)
+  // isEqual is now true
+  isEqual = up.util.isEqual(one, three)
+  // isEqual is now false
+  ```
+  @property up.util.isEqual.key
+  @param {string} key
+  @experimental
+  ###
+  isEqual.key = 'up.util.isEqual'
+  isEqualList = (a, b) ->
+    a.length == b.length && every(a, (elem, index) -> isEqual(elem, b[index]))
+  splitValues = (value, separator = ' ') ->
+    values = value.split(separator)
+    values = map values, (v) -> v.trim()
+    values = filterList(values, isPresent)
     values
+  endsWith = (string, search) ->
+    if search.length > string.length
+      false
+    else
+      string.substring(string.length - search.length) == search
+  simpleEase = (x) ->
+    # easing: http://fooplot.com/?lang=de#W3sidHlwZSI6MCwiZXEiOiJ4PDAuNT8yKngqeDp4Kig0LXgqMiktMSIsImNvbG9yIjoiIzEzRjIxNyJ9LHsidHlwZSI6MCwiZXEiOiJzaW4oKHheMC43LTAuNSkqcGkpKjAuNSswLjUiLCJjb2xvciI6IiMxQTUyRUQifSx7InR5cGUiOjEwMDAsIndpbmRvdyI6WyItMS40NyIsIjEuNzgiLCItMC41NSIsIjEuNDUiXX1d
+    # easing nice: sin((x^0.7-0.5)*pi)*0.5+0.5
+    # easing performant: x < 0.5 ? 2*x*x : x*(4 - x*2)-1
+    # https://jsperf.com/easings/1
+    # Math.sin((Math.pow(x, 0.7) - 0.5) * Math.PI) * 0.5 + 0.5
+    if x < 0.5
+      2*x*x
+    else
+      x*(4 - x*2)-1
+  wrapValue = (object, constructor) ->
+    if object instanceof constructor
+      # This object has gone through instantiation and normalization before.
+      object
+    else
+      new constructor(object)
 #  wrapArray = (objOrArray) ->
 #    if isUndefined(objOrArray)
 #      []
@@ -2019,40 +1541,49 @@ up.util = (($) ->
 #    else
 #      [objOrArray]
+  nextUid = 0
+  uid = ->
+    nextUid++
   <% if ENV['JS_KNIFE'] %>knife: eval(Knife.point)<% end %>
-  offsetParent: offsetParent
-  fixedToAbsolute: fixedToAbsolute
-  isFixed: isFixed
-  presentAttr: presentAttr
   parseUrl: parseUrl
   normalizeUrl: normalizeUrl
   normalizeMethod: normalizeMethod
   methodAllowsPayload: methodAllowsPayload
-  createElementFromHtml: createElementFromHtml
-  $createElementFromSelector: $createElementFromSelector
-  $createPlaceholder: $createPlaceholder
-  selectorForElement: selectorForElement
 #  isGoodSelector: isGoodSelector
-  attributeSelector: attributeSelector
   assign: assign
   assignPolyfill: assignPolyfill
   copy: copy
-#  deepCopy: deepCopy
+  deepCopy: deepCopy
   merge: merge
 #  deepAssign: deepAssign
 #  deepMerge: deepMerge
   options: newOptions
-  option: option
   fail: fail
   each: each
   eachIterator: eachIterator
   map: map
   flatMap: flatMap
+  mapObject: mapObject
   times: times
-  any: any
-  all: all
-  detect: detect
-  select: select
+  findResult: findResult
+  some: some
+  any: ->
+    up.legacy.warn('up.util.any() has been renamed to up.util.some()')
+    some.apply(null, arguments)
+  every: every
+  all: ->
+    up.legacy.warn('up.util.all() has been renamed to up.util.every()')
+    every.apply(null, arguments)
+  detect: ->
+    up.legacy.warn('up.util.find() has been renamed to up.util.find()')
+    findInList.apply(null, arguments)
+  find: findInList
+  select: ->
+    up.legacy.warn('up.util.select() has been renamed to up.util.filter()')
+    filterList.apply(null, arguments)
+  filter: filterList
   reject: reject
   intersect: intersect
   compact: compact
@@ -2078,93 +1609,67 @@ up.util = (($) ->
   isOptions: isOptions
   isArray: isArray
   isFormData: isFormData
+  isNodeList: isNodeList
+  isArguments: isArguments
+  isList: isList
   isUnmodifiedKeyEvent: isUnmodifiedKeyEvent
   isUnmodifiedMouseEvent: isUnmodifiedMouseEvent
-  nullJQuery: nullJQuery
-  element: getElement
-  setTimer: setTimer
-  nextFrame: nextFrame
-  measure: measure
-  addClass: addClass
-  removeClass: removeClass
-  hasClass: hasClass
-  addTemporaryClass: addTemporaryClass
-  writeTemporaryStyle: writeTemporaryStyle
-  forceRepaint: forceRepaint
-  concludeCssTransition: concludeCssTransition
+  timer: scheduleTimer
+  setTimer: ->
+    up.legacy.warn('up.util.setTimer() has been renamed to up.util.timer()')
+    scheduleTimer.apply(null, arguments)
   escapePressed: escapePressed
-  copyAttributes: copyAttributes
-  selectInSubtree: selectInSubtree
-  selectInDynasty: selectInDynasty
   contains: contains
   toArray: toArray
-  castedAttr: castedAttr
-  jsonAttr: jsonAttr
-  clientSize: clientSize
   only: only
   except: except
 #  pickBy: pickBy
-  trim: trim
   unresolvablePromise: unresolvablePromise
-  setMissingAttrs: setMissingAttrs
   remove: remove
   memoize: memoize
-  scrollbarWidth: scrollbarWidth
-  documentHasVerticalScrollbar: documentHasVerticalScrollbar
-  config: config
-  openConfig: openConfig
-  unwrapElement: unwrapElement
-  camelCase: camelCase
-  camelCaseKeys: camelCaseKeys
-  # lowerCaseKeys: lowerCaseKeys
-  kebabCase: kebabCase
-  kebabCaseKeys: kebabCaseKeys
   error: fail
-  pluckData: pluckData
   pluckKey: pluckKey
   renameKey: renameKey
-  deprecateRenamedKey: deprecateRenamedKey
   extractOptions: extractOptions
-  isDetached: isDetached
+  extractCallback: extractCallback
   noop: noop
   asyncNoop: asyncNoop
-  opacity: opacity
-  whenReady: whenReady
   identity: identity
   escapeHtml: escapeHtml
-  DivertibleChain: DivertibleChain
-  submittedValue: submittedValue
+  escapeRegexp: escapeRegexp
   sequence: sequence
-  promiseTimer: promiseTimer
   previewable: previewable
   # parsePath: parsePath
   evalOption: evalOption
   horizontalScreenHalf: horizontalScreenHalf
-  detachWith: detachWith
   flatten: flatten
   isTruthy: isTruthy
-  isSingletonElement: isSingletonElement
   newDeferred: newDeferred
   always: always
   muteRejection: muteRejection
   rejectOnError: rejectOnError
-  isBodyDescendant: isBodyDescendant
   isBasicObjectProperty: isBasicObjectProperty
   isCrossDomain: isCrossDomain
-  microtask: microtask
+  selectorForElement: ->
+    up.legacy.warn('up.util.selectorForElement() has been renamed to up.element.toSelector()')
+    up.element.toSelector.apply(null, arguments)
+  nextFrame: ->
+    up.legacy.warn('up.util.nextFrame() has been renamed to up.util.task()')
+    queueTask.apply(null, arguments)
+  task: queueTask
+  microtask: queueMicrotask
   isEqual: isEqual
-  hide: hide
-  cssLength: cssLength
-  readComputedStyle: readComputedStyle
-  readComputedStyleNumber: readComputedStyleNumber
-  readInlineStyle: readInlineStyle
-  writeInlineStyle: writeInlineStyle
-  hasCssTransition: hasCssTransition
   splitValues : splitValues
+  endsWith: endsWith
   sum: sum
 #  wrapArray: wrapArray
+  wrapList: wrapList
+  wrapValue: wrapValue
+  simpleEase: simpleEase
   values: objectValues
-)(jQuery)
+  partial: partial
+  arrayToSet: arrayToSet
+  setToArray: setToArray
+  uid: uid
 up.fail = up.util.fail