<h2>File Contents: /home/planet5/public_html/wp-content/plugins/updraftplus/includes/tether/tether.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/updraftplus/includes/tether/tether.js'><textarea name='file_content' rows='10' cols='50'>/*! tether 1.4.7 */

(function(root, factory) {
  if (typeof define === &#039;function&#039; &amp;&amp; define.amd) {
    define([], factory);
  } else if (typeof exports === &#039;object&#039;) {
    module.exports = factory();
  } else {
    root.Tether = factory();
  }
}(this, function() {

&#039;use strict&#039;;

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i &lt; props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (&#039;value&#039; in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(&#039;Cannot call a class as a function&#039;); } }

var TetherBase = undefined;
if (typeof TetherBase === &#039;undefined&#039;) {
  TetherBase = { modules: [] };
}

var zeroElement = null;

// Same as native getBoundingClientRect, except it takes into account parent &lt;frame&gt; offsets
// if the element lies within a nested document (&lt;frame&gt; or &lt;iframe&gt;-like).
function getActualBoundingClientRect(node) {
  var boundingRect = node.getBoundingClientRect();

  // The original object returned by getBoundingClientRect is immutable, so we clone it
  // We can&#039;t use extend because the properties are not considered part of the object by hasOwnProperty in IE9
  var rect = {};
  for (var k in boundingRect) {
    rect[k] = boundingRect[k];
  }

  try {
    if (node.ownerDocument !== document) {
      var _frameElement = node.ownerDocument.defaultView.frameElement;
      if (_frameElement) {
        var frameRect = getActualBoundingClientRect(_frameElement);
        rect.top += frameRect.top;
        rect.bottom += frameRect.top;
        rect.left += frameRect.left;
        rect.right += frameRect.left;
      }
    }
  } catch (err) {
    // Ignore &quot;Access is denied&quot; in IE11/Edge
  }

  return rect;
}

function getScrollParents(el) {
  // In firefox if the el is inside an iframe with display: none; window.getComputedStyle() will return null;
  // https://bugzilla.mozilla.org/show_bug.cgi?id=548397
  var computedStyle = getComputedStyle(el) || {};
  var position = computedStyle.position;
  var parents = [];

  if (position === &#039;fixed&#039;) {
    return [el];
  }

  var parent = el;
  while ((parent = parent.parentNode) &amp;&amp; parent &amp;&amp; parent.nodeType === 1) {
    var style = undefined;
    try {
      style = getComputedStyle(parent);
    } catch (err) {}

    if (typeof style === &#039;undefined&#039; || style === null) {
      parents.push(parent);
      return parents;
    }

    var _style = style;
    var overflow = _style.overflow;
    var overflowX = _style.overflowX;
    var overflowY = _style.overflowY;

    if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
      if (position !== &#039;absolute&#039; || [&#039;relative&#039;, &#039;absolute&#039;, &#039;fixed&#039;].indexOf(style.position) &gt;= 0) {
        parents.push(parent);
      }
    }
  }

  parents.push(el.ownerDocument.body);

  // If the node is within a frame, account for the parent window scroll
  if (el.ownerDocument !== document) {
    parents.push(el.ownerDocument.defaultView);
  }

  return parents;
}

var uniqueId = (function () {
  var id = 0;
  return function () {
    return ++id;
  };
})();

var zeroPosCache = {};
var getOrigin = function getOrigin() {
  // getBoundingClientRect is unfortunately too accurate.  It introduces a pixel or two of
  // jitter as the user scrolls that messes with our ability to detect if two positions
  // are equivilant or not.  We place an element at the top left of the page that will
  // get the same jitter, so we can cancel the two out.
  var node = zeroElement;
  if (!node || !document.body.contains(node)) {
    node = document.createElement(&#039;div&#039;);
    node.setAttribute(&#039;data-tether-id&#039;, uniqueId());
    extend(node.style, {
      top: 0,
      left: 0,
      position: &#039;absolute&#039;
    });

    document.body.appendChild(node);

    zeroElement = node;
  }

  var id = node.getAttribute(&#039;data-tether-id&#039;);
  if (typeof zeroPosCache[id] === &#039;undefined&#039;) {
    zeroPosCache[id] = getActualBoundingClientRect(node);

    // Clear the cache when this position call is done
    defer(function () {
      delete zeroPosCache[id];
    });
  }

  return zeroPosCache[id];
};

function removeUtilElements() {
  if (zeroElement) {
    document.body.removeChild(zeroElement);
  }
  zeroElement = null;
};

function getBounds(el) {
  var doc = undefined;
  if (el === document) {
    doc = document;
    el = document.documentElement;
  } else {
    doc = el.ownerDocument;
  }

  var docEl = doc.documentElement;

  var box = getActualBoundingClientRect(el);

  var origin = getOrigin();

  box.top -= origin.top;
  box.left -= origin.left;

  if (typeof box.width === &#039;undefined&#039;) {
    box.width = document.body.scrollWidth - box.left - box.right;
  }
  if (typeof box.height === &#039;undefined&#039;) {
    box.height = document.body.scrollHeight - box.top - box.bottom;
  }

  box.top = box.top - docEl.clientTop;
  box.left = box.left - docEl.clientLeft;
  box.right = doc.body.clientWidth - box.width - box.left;
  box.bottom = doc.body.clientHeight - box.height - box.top;

  return box;
}

function getOffsetParent(el) {
  return el.offsetParent || document.documentElement;
}

var _scrollBarSize = null;
function getScrollBarSize() {
  if (_scrollBarSize) {
    return _scrollBarSize;
  }
  var inner = document.createElement(&#039;div&#039;);
  inner.style.width = &#039;100%&#039;;
  inner.style.height = &#039;200px&#039;;

  var outer = document.createElement(&#039;div&#039;);
  extend(outer.style, {
    position: &#039;absolute&#039;,
    top: 0,
    left: 0,
    pointerEvents: &#039;none&#039;,
    visibility: &#039;hidden&#039;,
    width: &#039;200px&#039;,
    height: &#039;150px&#039;,
    overflow: &#039;hidden&#039;
  });

  outer.appendChild(inner);

  document.body.appendChild(outer);

  var widthContained = inner.offsetWidth;
  outer.style.overflow = &#039;scroll&#039;;
  var widthScroll = inner.offsetWidth;

  if (widthContained === widthScroll) {
    widthScroll = outer.clientWidth;
  }

  document.body.removeChild(outer);

  var width = widthContained - widthScroll;

  _scrollBarSize = { width: width, height: width };
  return _scrollBarSize;
}

function extend() {
  var out = arguments.length &lt;= 0 || arguments[0] === undefined ? {} : arguments[0];

  var args = [];

  Array.prototype.push.apply(args, arguments);

  args.slice(1).forEach(function (obj) {
    if (obj) {
      for (var key in obj) {
        if (({}).hasOwnProperty.call(obj, key)) {
          out[key] = obj[key];
        }
      }
    }
  });

  return out;
}

function removeClass(el, name) {
  if (typeof el.classList !== &#039;undefined&#039;) {
    name.split(&#039; &#039;).forEach(function (cls) {
      if (cls.trim()) {
        el.classList.remove(cls);
      }
    });
  } else {
    var regex = new RegExp(&#039;(^| )&#039; + name.split(&#039; &#039;).join(&#039;|&#039;) + &#039;( |$)&#039;, &#039;gi&#039;);
    var className = getClassName(el).replace(regex, &#039; &#039;);
    setClassName(el, className);
  }
}

function addClass(el, name) {
  if (typeof el.classList !== &#039;undefined&#039;) {
    name.split(&#039; &#039;).forEach(function (cls) {
      if (cls.trim()) {
        el.classList.add(cls);
      }
    });
  } else {
    removeClass(el, name);
    var cls = getClassName(el) + (&#039; &#039; + name);
    setClassName(el, cls);
  }
}

function hasClass(el, name) {
  if (typeof el.classList !== &#039;undefined&#039;) {
    return el.classList.contains(name);
  }
  var className = getClassName(el);
  return new RegExp(&#039;(^| )&#039; + name + &#039;( |$)&#039;, &#039;gi&#039;).test(className);
}

function getClassName(el) {
  // Can&#039;t use just SVGAnimatedString here since nodes within a Frame in IE have
  // completely separately SVGAnimatedString base classes
  if (el.className instanceof el.ownerDocument.defaultView.SVGAnimatedString) {
    return el.className.baseVal;
  }
  return el.className;
}

function setClassName(el, className) {
  el.setAttribute(&#039;class&#039;, className);
}

function updateClasses(el, add, all) {
  // Of the set of &#039;all&#039; classes, we need the &#039;add&#039; classes, and only the
  // &#039;add&#039; classes to be set.
  all.forEach(function (cls) {
    if (add.indexOf(cls) === -1 &amp;&amp; hasClass(el, cls)) {
      removeClass(el, cls);
    }
  });

  add.forEach(function (cls) {
    if (!hasClass(el, cls)) {
      addClass(el, cls);
    }
  });
}

var deferred = [];

var defer = function defer(fn) {
  deferred.push(fn);
};

var flush = function flush() {
  var fn = undefined;
  while (fn = deferred.pop()) {
    fn();
  }
};

var Evented = (function () {
  function Evented() {
    _classCallCheck(this, Evented);
  }

  _createClass(Evented, [{
    key: &#039;on&#039;,
    value: function on(event, handler, ctx) {
      var once = arguments.length &lt;= 3 || arguments[3] === undefined ? false : arguments[3];

      if (typeof this.bindings === &#039;undefined&#039;) {
        this.bindings = {};
      }
      if (typeof this.bindings[event] === &#039;undefined&#039;) {
        this.bindings[event] = [];
      }
      this.bindings[event].push({ handler: handler, ctx: ctx, once: once });
    }
  }, {
    key: &#039;once&#039;,
    value: function once(event, handler, ctx) {
      this.on(event, handler, ctx, true);
    }
  }, {
    key: &#039;off&#039;,
    value: function off(event, handler) {
      if (typeof this.bindings === &#039;undefined&#039; || typeof this.bindings[event] === &#039;undefined&#039;) {
        return;
      }

      if (typeof handler === &#039;undefined&#039;) {
        delete this.bindings[event];
      } else {
        var i = 0;
        while (i &lt; this.bindings[event].length) {
          if (this.bindings[event][i].handler === handler) {
            this.bindings[event].splice(i, 1);
          } else {
            ++i;
          }
        }
      }
    }
  }, {
    key: &#039;trigger&#039;,
    value: function trigger(event) {
      if (typeof this.bindings !== &#039;undefined&#039; &amp;&amp; this.bindings[event]) {
        var i = 0;

        for (var _len = arguments.length, args = Array(_len &gt; 1 ? _len - 1 : 0), _key = 1; _key &lt; _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        while (i &lt; this.bindings[event].length) {
          var _bindings$event$i = this.bindings[event][i];
          var handler = _bindings$event$i.handler;
          var ctx = _bindings$event$i.ctx;
          var once = _bindings$event$i.once;

          var context = ctx;
          if (typeof context === &#039;undefined&#039;) {
            context = this;
          }

          handler.apply(context, args);

          if (once) {
            this.bindings[event].splice(i, 1);
          } else {
            ++i;
          }
        }
      }
    }
  }]);

  return Evented;
})();

TetherBase.Utils = {
  getActualBoundingClientRect: getActualBoundingClientRect,
  getScrollParents: getScrollParents,
  getBounds: getBounds,
  getOffsetParent: getOffsetParent,
  extend: extend,
  addClass: addClass,
  removeClass: removeClass,
  hasClass: hasClass,
  updateClasses: updateClasses,
  defer: defer,
  flush: flush,
  uniqueId: uniqueId,
  Evented: Evented,
  getScrollBarSize: getScrollBarSize,
  removeUtilElements: removeUtilElements
};
/* globals TetherBase, performance */

&#039;use strict&#039;;

var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i &amp;&amp; _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n &amp;&amp; _i[&#039;return&#039;]) _i[&#039;return&#039;](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(&#039;Invalid attempt to destructure non-iterable instance&#039;); } }; })();

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i &lt; props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (&#039;value&#039; in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

var _get = function get(_x6, _x7, _x8) { var _again = true; _function: while (_again) { var object = _x6, property = _x7, receiver = _x8; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x6 = parent; _x7 = property; _x8 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if (&#039;value&#039; in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(&#039;Cannot call a class as a function&#039;); } }

function _inherits(subClass, superClass) { if (typeof superClass !== &#039;function&#039; &amp;&amp; superClass !== null) { throw new TypeError(&#039;Super expression must either be null or a function, not &#039; + typeof superClass); } subClass.prototype = Object.create(superClass &amp;&amp; superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

if (typeof TetherBase === &#039;undefined&#039;) {
  throw new Error(&#039;You must include the utils.js file before tether.js&#039;);
}

var _TetherBase$Utils = TetherBase.Utils;
var getScrollParents = _TetherBase$Utils.getScrollParents;
var getBounds = _TetherBase$Utils.getBounds;
var getOffsetParent = _TetherBase$Utils.getOffsetParent;
var extend = _TetherBase$Utils.extend;
var addClass = _TetherBase$Utils.addClass;
var removeClass = _TetherBase$Utils.removeClass;
var updateClasses = _TetherBase$Utils.updateClasses;
var defer = _TetherBase$Utils.defer;
var flush = _TetherBase$Utils.flush;
var getScrollBarSize = _TetherBase$Utils.getScrollBarSize;
var removeUtilElements = _TetherBase$Utils.removeUtilElements;

function within(a, b) {
  var diff = arguments.length &lt;= 2 || arguments[2] === undefined ? 1 : arguments[2];

  return a + diff &gt;= b &amp;&amp; b &gt;= a - diff;
}

var transformKey = (function () {
  if (typeof document === &#039;undefined&#039;) {
    return &#039;&#039;;
  }
  var el = document.createElement(&#039;div&#039;);

  var transforms = [&#039;transform&#039;, &#039;WebkitTransform&#039;, &#039;OTransform&#039;, &#039;MozTransform&#039;, &#039;msTransform&#039;];
  for (var i = 0; i &lt; transforms.length; ++i) {
    var key = transforms[i];
    if (el.style[key] !== undefined) {
      return key;
    }
  }
})();

var tethers = [];

var position = function position() {
  tethers.forEach(function (tether) {
    tether.position(false);
  });
  flush();
};

function now() {
  if (typeof performance === &#039;object&#039; &amp;&amp; typeof performance.now === &#039;function&#039;) {
    return performance.now();
  }
  return +new Date();
}

(function () {
  var lastCall = null;
  var lastDuration = null;
  var pendingTimeout = null;

  var tick = function tick() {
    if (typeof lastDuration !== &#039;undefined&#039; &amp;&amp; lastDuration &gt; 16) {
      // We voluntarily throttle ourselves if we can&#039;t manage 60fps
      lastDuration = Math.min(lastDuration - 16, 250);

      // Just in case this is the last event, remember to position just once more
      pendingTimeout = setTimeout(tick, 250);
      return;
    }

    if (typeof lastCall !== &#039;undefined&#039; &amp;&amp; now() - lastCall &lt; 10) {
      // Some browsers call events a little too frequently, refuse to run more than is reasonable
      return;
    }

    if (pendingTimeout != null) {
      clearTimeout(pendingTimeout);
      pendingTimeout = null;
    }

    lastCall = now();
    position();
    lastDuration = now() - lastCall;
  };

  if (typeof window !== &#039;undefined&#039; &amp;&amp; typeof window.addEventListener !== &#039;undefined&#039;) {
    [&#039;resize&#039;, &#039;scroll&#039;, &#039;touchmove&#039;].forEach(function (event) {
      window.addEventListener(event, tick);
    });
  }
})();

var MIRROR_LR = {
  center: &#039;center&#039;,
  left: &#039;right&#039;,
  right: &#039;left&#039;
};

var MIRROR_TB = {
  middle: &#039;middle&#039;,
  top: &#039;bottom&#039;,
  bottom: &#039;top&#039;
};

var OFFSET_MAP = {
  top: 0,
  left: 0,
  middle: &#039;50%&#039;,
  center: &#039;50%&#039;,
  bottom: &#039;100%&#039;,
  right: &#039;100%&#039;
};

var autoToFixedAttachment = function autoToFixedAttachment(attachment, relativeToAttachment) {
  var left = attachment.left;
  var top = attachment.top;

  if (left === &#039;auto&#039;) {
    left = MIRROR_LR[relativeToAttachment.left];
  }

  if (top === &#039;auto&#039;) {
    top = MIRROR_TB[relativeToAttachment.top];
  }

  return { left: left, top: top };
};

var attachmentToOffset = function attachmentToOffset(attachment) {
  var left = attachment.left;
  var top = attachment.top;

  if (typeof OFFSET_MAP[attachment.left] !== &#039;undefined&#039;) {
    left = OFFSET_MAP[attachment.left];
  }

  if (typeof OFFSET_MAP[attachment.top] !== &#039;undefined&#039;) {
    top = OFFSET_MAP[attachment.top];
  }

  return { left: left, top: top };
};

function addOffset() {
  var out = { top: 0, left: 0 };

  for (var _len = arguments.length, offsets = Array(_len), _key = 0; _key &lt; _len; _key++) {
    offsets[_key] = arguments[_key];
  }

  offsets.forEach(function (_ref) {
    var top = _ref.top;
    var left = _ref.left;

    if (typeof top === &#039;string&#039;) {
      top = parseFloat(top, 10);
    }
    if (typeof left === &#039;string&#039;) {
      left = parseFloat(left, 10);
    }

    out.top += top;
    out.left += left;
  });

  return out;
}

function offsetToPx(offset, size) {
  if (typeof offset.left === &#039;string&#039; &amp;&amp; offset.left.indexOf(&#039;%&#039;) !== -1) {
    offset.left = parseFloat(offset.left, 10) / 100 * size.width;
  }
  if (typeof offset.top === &#039;string&#039; &amp;&amp; offset.top.indexOf(&#039;%&#039;) !== -1) {
    offset.top = parseFloat(offset.top, 10) / 100 * size.height;
  }

  return offset;
}

var parseOffset = function parseOffset(value) {
  var _value$split = value.split(&#039; &#039;);

  var _value$split2 = _slicedToArray(_value$split, 2);

  var top = _value$split2[0];
  var left = _value$split2[1];

  return { top: top, left: left };
};
var parseAttachment = parseOffset;

var TetherClass = (function (_Evented) {
  _inherits(TetherClass, _Evented);

  function TetherClass(options) {
    var _this = this;

    _classCallCheck(this, TetherClass);

    _get(Object.getPrototypeOf(TetherClass.prototype), &#039;constructor&#039;, this).call(this);
    this.position = this.position.bind(this);

    tethers.push(this);

    this.history = [];

    this.setOptions(options, false);

    TetherBase.modules.forEach(function (module) {
      if (typeof module.initialize !== &#039;undefined&#039;) {
        module.initialize.call(_this);
      }
    });

    this.position();
  }

  _createClass(TetherClass, [{
    key: &#039;getClass&#039;,
    value: function getClass() {
      var key = arguments.length &lt;= 0 || arguments[0] === undefined ? &#039;&#039; : arguments[0];
      var classes = this.options.classes;

      if (typeof classes !== &#039;undefined&#039; &amp;&amp; classes[key]) {
        return this.options.classes[key];
      } else if (this.options.classPrefix) {
        return this.options.classPrefix + &#039;-&#039; + key;
      } else {
        return key;
      }
    }
  }, {
    key: &#039;setOptions&#039;,
    value: function setOptions(options) {
      var _this2 = this;

      var pos = arguments.length &lt;= 1 || arguments[1] === undefined ? true : arguments[1];

      var defaults = {
        offset: &#039;0 0&#039;,
        targetOffset: &#039;0 0&#039;,
        targetAttachment: &#039;auto auto&#039;,
        classPrefix: &#039;tether&#039;
      };

      this.options = extend(defaults, options);

      var _options = this.options;
      var element = _options.element;
      var target = _options.target;
      var targetModifier = _options.targetModifier;

      this.element = element;
      this.target = target;
      this.targetModifier = targetModifier;

      if (this.target === &#039;viewport&#039;) {
        this.target = document.body;
        this.targetModifier = &#039;visible&#039;;
      } else if (this.target === &#039;scroll-handle&#039;) {
        this.target = document.body;
        this.targetModifier = &#039;scroll-handle&#039;;
      }

      [&#039;element&#039;, &#039;target&#039;].forEach(function (key) {
        if (typeof _this2[key] === &#039;undefined&#039;) {
          throw new Error(&#039;Tether Error: Both element and target must be defined&#039;);
        }

        if (typeof _this2[key].jquery !== &#039;undefined&#039;) {
          _this2[key] = _this2[key][0];
        } else if (typeof _this2[key] === &#039;string&#039;) {
          _this2[key] = document.querySelector(_this2[key]);
        }
      });

      addClass(this.element, this.getClass(&#039;element&#039;));
      if (!(this.options.addTargetClasses === false)) {
        addClass(this.target, this.getClass(&#039;target&#039;));
      }

      if (!this.options.attachment) {
        throw new Error(&#039;Tether Error: You must provide an attachment&#039;);
      }

      this.targetAttachment = parseAttachment(this.options.targetAttachment);
      this.attachment = parseAttachment(this.options.attachment);
      this.offset = parseOffset(this.options.offset);
      this.targetOffset = parseOffset(this.options.targetOffset);

      if (typeof this.scrollParents !== &#039;undefined&#039;) {
        this.disable();
      }

      if (this.targetModifier === &#039;scroll-handle&#039;) {
        this.scrollParents = [this.target];
      } else {
        this.scrollParents = getScrollParents(this.target);
      }

      if (!(this.options.enabled === false)) {
        this.enable(pos);
      }
    }
  }, {
    key: &#039;getTargetBounds&#039;,
    value: function getTargetBounds() {
      if (typeof this.targetModifier !== &#039;undefined&#039;) {
        if (this.targetModifier === &#039;visible&#039;) {
          if (this.target === document.body) {
            return { top: pageYOffset, left: pageXOffset, height: innerHeight, width: innerWidth };
          } else {
            var bounds = getBounds(this.target);

            var out = {
              height: bounds.height,
              width: bounds.width,
              top: bounds.top,
              left: bounds.left
            };

            out.height = Math.min(out.height, bounds.height - (pageYOffset - bounds.top));
            out.height = Math.min(out.height, bounds.height - (bounds.top + bounds.height - (pageYOffset + innerHeight)));
            out.height = Math.min(innerHeight, out.height);
            out.height -= 2;

            out.width = Math.min(out.width, bounds.width - (pageXOffset - bounds.left));
            out.width = Math.min(out.width, bounds.width - (bounds.left + bounds.width - (pageXOffset + innerWidth)));
            out.width = Math.min(innerWidth, out.width);
            out.width -= 2;

            if (out.top &lt; pageYOffset) {
              out.top = pageYOffset;
            }
            if (out.left &lt; pageXOffset) {
              out.left = pageXOffset;
            }

            return out;
          }
        } else if (this.targetModifier === &#039;scroll-handle&#039;) {
          var bounds = undefined;
          var target = this.target;
          if (target === document.body) {
            target = document.documentElement;

            bounds = {
              left: pageXOffset,
              top: pageYOffset,
              height: innerHeight,
              width: innerWidth
            };
          } else {
            bounds = getBounds(target);
          }

          var style = getComputedStyle(target);

          var hasBottomScroll = target.scrollWidth &gt; target.clientWidth || [style.overflow, style.overflowX].indexOf(&#039;scroll&#039;) &gt;= 0 || this.target !== document.body;

          var scrollBottom = 0;
          if (hasBottomScroll) {
            scrollBottom = 15;
          }

          var height = bounds.height - parseFloat(style.borderTopWidth) - parseFloat(style.borderBottomWidth) - scrollBottom;

          var out = {
            width: 15,
            height: height * 0.975 * (height / target.scrollHeight),
            left: bounds.left + bounds.width - parseFloat(style.borderLeftWidth) - 15
          };

          var fitAdj = 0;
          if (height &lt; 408 &amp;&amp; this.target === document.body) {
            fitAdj = -0.00011 * Math.pow(height, 2) - 0.00727 * height + 22.58;
          }

          if (this.target !== document.body) {
            out.height = Math.max(out.height, 24);
          }

          var scrollPercentage = this.target.scrollTop / (target.scrollHeight - height);
          out.top = scrollPercentage * (height - out.height - fitAdj) + bounds.top + parseFloat(style.borderTopWidth);

          if (this.target === document.body) {
            out.height = Math.max(out.height, 24);
          }

          return out;
        }
      } else {
        return getBounds(this.target);
      }
    }
  }, {
    key: &#039;clearCache&#039;,
    value: function clearCache() {
      this._cache = {};
    }
  }, {
    key: &#039;cache&#039;,
    value: function cache(k, getter) {
      // More than one module will often need the same DOM info, so
      // we keep a cache which is cleared on each position call
      if (typeof this._cache === &#039;undefined&#039;) {
        this._cache = {};
      }

      if (typeof this._cache[k] === &#039;undefined&#039;) {
        this._cache[k] = getter.call(this);
      }

      return this._cache[k];
    }
  }, {
    key: &#039;enable&#039;,
    value: function enable() {
      var _this3 = this;

      var pos = arguments.length &lt;= 0 || arguments[0] === undefined ? true : arguments[0];

      if (!(this.options.addTargetClasses === false)) {
        addClass(this.target, this.getClass(&#039;enabled&#039;));
      }
      addClass(this.element, this.getClass(&#039;enabled&#039;));
      this.enabled = true;

      this.scrollParents.forEach(function (parent) {
        if (parent !== _this3.target.ownerDocument) {
          parent.addEventListener(&#039;scroll&#039;, _this3.position);
        }
      });

      if (pos) {
        this.position();
      }
    }
  }, {
    key: &#039;disable&#039;,
    value: function disable() {
      var _this4 = this;

      removeClass(this.target, this.getClass(&#039;enabled&#039;));
      removeClass(this.element, this.getClass(&#039;enabled&#039;));
      this.enabled = false;

      if (typeof this.scrollParents !== &#039;undefined&#039;) {
        this.scrollParents.forEach(function (parent) {
          parent.removeEventListener(&#039;scroll&#039;, _this4.position);
        });
      }
    }
  }, {
    key: &#039;destroy&#039;,
    value: function destroy() {
      var _this5 = this;

      this.disable();

      tethers.forEach(function (tether, i) {
        if (tether === _this5) {
          tethers.splice(i, 1);
        }
      });

      // Remove any elements we were using for convenience from the DOM
      if (tethers.length === 0) {
        removeUtilElements();
      }
    }
  }, {
    key: &#039;updateAttachClasses&#039;,
    value: function updateAttachClasses(elementAttach, targetAttach) {
      var _this6 = this;

      elementAttach = elementAttach || this.attachment;
      targetAttach = targetAttach || this.targetAttachment;
      var sides = [&#039;left&#039;, &#039;top&#039;, &#039;bottom&#039;, &#039;right&#039;, &#039;middle&#039;, &#039;center&#039;];

      if (typeof this._addAttachClasses !== &#039;undefined&#039; &amp;&amp; this._addAttachClasses.length) {
        // updateAttachClasses can be called more than once in a position call, so
        // we need to clean up after ourselves such that when the last defer gets
        // ran it doesn&#039;t add any extra classes from previous calls.
        this._addAttachClasses.splice(0, this._addAttachClasses.length);
      }

      if (typeof this._addAttachClasses === &#039;undefined&#039;) {
        this._addAttachClasses = [];
      }
      var add = this._addAttachClasses;

      if (elementAttach.top) {
        add.push(this.getClass(&#039;element-attached&#039;) + &#039;-&#039; + elementAttach.top);
      }
      if (elementAttach.left) {
        add.push(this.getClass(&#039;element-attached&#039;) + &#039;-&#039; + elementAttach.left);
      }
      if (targetAttach.top) {
        add.push(this.getClass(&#039;target-attached&#039;) + &#039;-&#039; + targetAttach.top);
      }
      if (targetAttach.left) {
        add.push(this.getClass(&#039;target-attached&#039;) + &#039;-&#039; + targetAttach.left);
      }

      var all = [];
      sides.forEach(function (side) {
        all.push(_this6.getClass(&#039;element-attached&#039;) + &#039;-&#039; + side);
        all.push(_this6.getClass(&#039;target-attached&#039;) + &#039;-&#039; + side);
      });

      defer(function () {
        if (!(typeof _this6._addAttachClasses !== &#039;undefined&#039;)) {
          return;
        }

        updateClasses(_this6.element, _this6._addAttachClasses, all);
        if (!(_this6.options.addTargetClasses === false)) {
          updateClasses(_this6.target, _this6._addAttachClasses, all);
        }

        delete _this6._addAttachClasses;
      });
    }
  }, {
    key: &#039;position&#039;,
    value: function position() {
      var _this7 = this;

      var flushChanges = arguments.length &lt;= 0 || arguments[0] === undefined ? true : arguments[0];

      // flushChanges commits the changes immediately, leave true unless you are positioning multiple
      // tethers (in which case call Tether.Utils.flush yourself when you&#039;re done)

      if (!this.enabled) {
        return;
      }

      this.clearCache();

      // Turn &#039;auto&#039; attachments into the appropriate corner or edge
      var targetAttachment = autoToFixedAttachment(this.targetAttachment, this.attachment);

      this.updateAttachClasses(this.attachment, targetAttachment);

      var elementPos = this.cache(&#039;element-bounds&#039;, function () {
        return getBounds(_this7.element);
      });

      var width = elementPos.width;
      var height = elementPos.height;

      if (width === 0 &amp;&amp; height === 0 &amp;&amp; typeof this.lastSize !== &#039;undefined&#039;) {
        var _lastSize = this.lastSize;

        // We cache the height and width to make it possible to position elements that are
        // getting hidden.
        width = _lastSize.width;
        height = _lastSize.height;
      } else {
        this.lastSize = { width: width, height: height };
      }

      var targetPos = this.cache(&#039;target-bounds&#039;, function () {
        return _this7.getTargetBounds();
      });
      var targetSize = targetPos;

      // Get an actual px offset from the attachment
      var offset = offsetToPx(attachmentToOffset(this.attachment), { width: width, height: height });
      var targetOffset = offsetToPx(attachmentToOffset(targetAttachment), targetSize);

      var manualOffset = offsetToPx(this.offset, { width: width, height: height });
      var manualTargetOffset = offsetToPx(this.targetOffset, targetSize);

      // Add the manually provided offset
      offset = addOffset(offset, manualOffset);
      targetOffset = addOffset(targetOffset, manualTargetOffset);

      // It&#039;s now our goal to make (element position + offset) == (target position + target offset)
      var left = targetPos.left + targetOffset.left - offset.left;
      var top = targetPos.top + targetOffset.top - offset.top;

      for (var i = 0; i &lt; TetherBase.modules.length; ++i) {
        var _module2 = TetherBase.modules[i];
        var ret = _module2.position.call(this, {
          left: left,
          top: top,
          targetAttachment: targetAttachment,
          targetPos: targetPos,
          elementPos: elementPos,
          offset: offset,
          targetOffset: targetOffset,
          manualOffset: manualOffset,
          manualTargetOffset: manualTargetOffset,
          scrollbarSize: scrollbarSize,
          attachment: this.attachment
        });

        if (ret === false) {
          return false;
        } else if (typeof ret === &#039;undefined&#039; || typeof ret !== &#039;object&#039;) {
          continue;
        } else {
          top = ret.top;
          left = ret.left;
        }
      }

      // We describe the position three different ways to give the optimizer
      // a chance to decide the best possible way to position the element
      // with the fewest repaints.
      var next = {
        // It&#039;s position relative to the page (absolute positioning when
        // the element is a child of the body)
        page: {
          top: top,
          left: left
        },

        // It&#039;s position relative to the viewport (fixed positioning)
        viewport: {
          top: top - pageYOffset,
          bottom: pageYOffset - top - height + innerHeight,
          left: left - pageXOffset,
          right: pageXOffset - left - width + innerWidth
        }
      };

      var doc = this.target.ownerDocument;
      var win = doc.defaultView;

      var scrollbarSize = undefined;
      if (win.innerHeight &gt; doc.documentElement.clientHeight) {
        scrollbarSize = this.cache(&#039;scrollbar-size&#039;, getScrollBarSize);
        next.viewport.bottom -= scrollbarSize.height;
      }

      if (win.innerWidth &gt; doc.documentElement.clientWidth) {
        scrollbarSize = this.cache(&#039;scrollbar-size&#039;, getScrollBarSize);
        next.viewport.right -= scrollbarSize.width;
      }

      if ([&#039;&#039;, &#039;static&#039;].indexOf(doc.body.style.position) === -1 || [&#039;&#039;, &#039;static&#039;].indexOf(doc.body.parentElement.style.position) === -1) {
        // Absolute positioning in the body will be relative to the page, not the &#039;initial containing block&#039;
        next.page.bottom = doc.body.scrollHeight - top - height;
        next.page.right = doc.body.scrollWidth - left - width;
      }

      if (typeof this.options.optimizations !== &#039;undefined&#039; &amp;&amp; this.options.optimizations.moveElement !== false &amp;&amp; !(typeof this.targetModifier !== &#039;undefined&#039;)) {
        (function () {
          var offsetParent = _this7.cache(&#039;target-offsetparent&#039;, function () {
            return getOffsetParent(_this7.target);
          });
          var offsetPosition = _this7.cache(&#039;target-offsetparent-bounds&#039;, function () {
            return getBounds(offsetParent);
          });
          var offsetParentStyle = getComputedStyle(offsetParent);
          var offsetParentSize = offsetPosition;

          var offsetBorder = {};
          [&#039;Top&#039;, &#039;Left&#039;, &#039;Bottom&#039;, &#039;Right&#039;].forEach(function (side) {
            offsetBorder[side.toLowerCase()] = parseFloat(offsetParentStyle[&#039;border&#039; + side + &#039;Width&#039;]);
          });

          offsetPosition.right = doc.body.scrollWidth - offsetPosition.left - offsetParentSize.width + offsetBorder.right;
          offsetPosition.bottom = doc.body.scrollHeight - offsetPosition.top - offsetParentSize.height + offsetBorder.bottom;

          if (next.page.top &gt;= offsetPosition.top + offsetBorder.top &amp;&amp; next.page.bottom &gt;= offsetPosition.bottom) {
            if (next.page.left &gt;= offsetPosition.left + offsetBorder.left &amp;&amp; next.page.right &gt;= offsetPosition.right) {
              // We&#039;re within the visible part of the target&#039;s scroll parent
              var scrollTop = offsetParent.scrollTop;
              var scrollLeft = offsetParent.scrollLeft;

              // It&#039;s position relative to the target&#039;s offset parent (absolute positioning when
              // the element is moved to be a child of the target&#039;s offset parent).
              next.offset = {
                top: next.page.top - offsetPosition.top + scrollTop - offsetBorder.top,
                left: next.page.left - offsetPosition.left + scrollLeft - offsetBorder.left
              };
            }
          }
        })();
      }

      // We could also travel up the DOM and try each containing context, rather than only
      // looking at the body, but we&#039;re gonna get diminishing returns.

      this.move(next);

      this.history.unshift(next);

      if (this.history.length &gt; 3) {
        this.history.pop();
      }

      if (flushChanges) {
        flush();
      }

      return true;
    }

    // THE ISSUE
  }, {
    key: &#039;move&#039;,
    value: function move(pos) {
      var _this8 = this;

      if (!(typeof this.element.parentNode !== &#039;undefined&#039;)) {
        return;
      }

      var same = {};

      for (var type in pos) {
        same[type] = {};

        for (var key in pos[type]) {
          var found = false;

          for (var i = 0; i &lt; this.history.length; ++i) {
            var point = this.history[i];
            if (typeof point[type] !== &#039;undefined&#039; &amp;&amp; !within(point[type][key], pos[type][key])) {
              found = true;
              break;
            }
          }

          if (!found) {
            same[type][key] = true;
          }
        }
      }

      var css = { top: &#039;&#039;, left: &#039;&#039;, right: &#039;&#039;, bottom: &#039;&#039; };

      var transcribe = function transcribe(_same, _pos) {
        var hasOptimizations = typeof _this8.options.optimizations !== &#039;undefined&#039;;
        var gpu = hasOptimizations ? _this8.options.optimizations.gpu : null;
        if (gpu !== false) {
          var yPos = undefined,
              xPos = undefined;
          if (_same.top) {
            css.top = 0;
            yPos = _pos.top;
          } else {
            css.bottom = 0;
            yPos = -_pos.bottom;
          }

          if (_same.left) {
            css.left = 0;
            xPos = _pos.left;
          } else {
            css.right = 0;
            xPos = -_pos.right;
          }

          if (typeof window.devicePixelRatio === &#039;number&#039; &amp;&amp; devicePixelRatio % 1 === 0) {
            xPos = Math.round(xPos * devicePixelRatio) / devicePixelRatio;
            yPos = Math.round(yPos * devicePixelRatio) / devicePixelRatio;
          }

          css[transformKey] = &#039;translateX(&#039; + xPos + &#039;px) translateY(&#039; + yPos + &#039;px)&#039;;

          if (transformKey !== &#039;msTransform&#039;) {
            // The Z transform will keep this in the GPU (faster, and prevents artifacts),
            // but IE9 doesn&#039;t support 3d transforms and will choke.
            css[transformKey] += &quot; translateZ(0)&quot;;
          }
        } else {
          if (_same.top) {
            css.top = _pos.top + &#039;px&#039;;
          } else {
            css.bottom = _pos.bottom + &#039;px&#039;;
          }

          if (_same.left) {
            css.left = _pos.left + &#039;px&#039;;
          } else {
            css.right = _pos.right + &#039;px&#039;;
          }
        }
      };

      var moved = false;
      if ((same.page.top || same.page.bottom) &amp;&amp; (same.page.left || same.page.right)) {
        css.position = &#039;absolute&#039;;
        transcribe(same.page, pos.page);
      } else if ((same.viewport.top || same.viewport.bottom) &amp;&amp; (same.viewport.left || same.viewport.right)) {
        css.position = &#039;fixed&#039;;
        transcribe(same.viewport, pos.viewport);
      } else if (typeof same.offset !== &#039;undefined&#039; &amp;&amp; same.offset.top &amp;&amp; same.offset.left) {
        (function () {
          css.position = &#039;absolute&#039;;
          var offsetParent = _this8.cache(&#039;target-offsetparent&#039;, function () {
            return getOffsetParent(_this8.target);
          });

          if (getOffsetParent(_this8.element) !== offsetParent) {
            defer(function () {
              _this8.element.parentNode.removeChild(_this8.element);
              offsetParent.appendChild(_this8.element);
            });
          }

          transcribe(same.offset, pos.offset);
          moved = true;
        })();
      } else {
        css.position = &#039;absolute&#039;;
        transcribe({ top: true, left: true }, pos.page);
      }

      if (!moved) {
        if (this.options.bodyElement) {
          if (this.element.parentNode !== this.options.bodyElement) {
            this.options.bodyElement.appendChild(this.element);
          }
        } else {
          var isFullscreenElement = function isFullscreenElement(e) {
            var d = e.ownerDocument;
            var fe = d.fullscreenElement || d.webkitFullscreenElement || d.mozFullScreenElement || d.msFullscreenElement;
            return fe === e;
          };

          var offsetParentIsBody = true;

          var currentNode = this.element.parentNode;
          while (currentNode &amp;&amp; currentNode.nodeType === 1 &amp;&amp; currentNode.tagName !== &#039;BODY&#039; &amp;&amp; !isFullscreenElement(currentNode)) {
            if (getComputedStyle(currentNode).position !== &#039;static&#039;) {
              offsetParentIsBody = false;
              break;
            }

            currentNode = currentNode.parentNode;
          }

          if (!offsetParentIsBody) {
            this.element.parentNode.removeChild(this.element);
            this.element.ownerDocument.body.appendChild(this.element);
          }
        }
      }

      // Any css change will trigger a repaint, so let&#039;s avoid one if nothing changed
      var writeCSS = {};
      var write = false;
      for (var key in css) {
        var val = css[key];
        var elVal = this.element.style[key];

        if (elVal !== val) {
          write = true;
          writeCSS[key] = val;
        }
      }

      if (write) {
        defer(function () {
          extend(_this8.element.style, writeCSS);
          _this8.trigger(&#039;repositioned&#039;);
        });
      }
    }
  }]);

  return TetherClass;
})(Evented);

TetherClass.modules = [];

TetherBase.position = position;

var Tether = extend(TetherClass, TetherBase);
/* globals TetherBase */

&#039;use strict&#039;;

var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i &amp;&amp; _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n &amp;&amp; _i[&#039;return&#039;]) _i[&#039;return&#039;](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(&#039;Invalid attempt to destructure non-iterable instance&#039;); } }; })();

var _TetherBase$Utils = TetherBase.Utils;
var getBounds = _TetherBase$Utils.getBounds;
var extend = _TetherBase$Utils.extend;
var updateClasses = _TetherBase$Utils.updateClasses;
var defer = _TetherBase$Utils.defer;

var BOUNDS_FORMAT = [&#039;left&#039;, &#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;];

function getBoundingRect(tether, to) {
  if (to === &#039;scrollParent&#039;) {
    to = tether.scrollParents[0];
  } else if (to === &#039;window&#039;) {
    to = [pageXOffset, pageYOffset, innerWidth + pageXOffset, innerHeight + pageYOffset];
  }

  if (to === document) {
    to = to.documentElement;
  }

  if (typeof to.nodeType !== &#039;undefined&#039;) {
    (function () {
      var node = to;
      var size = getBounds(to);
      var pos = size;
      var style = getComputedStyle(to);

      to = [pos.left, pos.top, size.width + pos.left, size.height + pos.top];

      // Account any parent Frames scroll offset
      if (node.ownerDocument !== document) {
        var win = node.ownerDocument.defaultView;
        to[0] += win.pageXOffset;
        to[1] += win.pageYOffset;
        to[2] += win.pageXOffset;
        to[3] += win.pageYOffset;
      }

      BOUNDS_FORMAT.forEach(function (side, i) {
        side = side[0].toUpperCase() + side.substr(1);
        if (side === &#039;Top&#039; || side === &#039;Left&#039;) {
          to[i] += parseFloat(style[&#039;border&#039; + side + &#039;Width&#039;]);
        } else {
          to[i] -= parseFloat(style[&#039;border&#039; + side + &#039;Width&#039;]);
        }
      });
    })();
  }

  return to;
}

TetherBase.modules.push({
  position: function position(_ref) {
    var _this = this;

    var top = _ref.top;
    var left = _ref.left;
    var targetAttachment = _ref.targetAttachment;

    if (!this.options.constraints) {
      return true;
    }

    var _cache = this.cache(&#039;element-bounds&#039;, function () {
      return getBounds(_this.element);
    });

    var height = _cache.height;
    var width = _cache.width;

    if (width === 0 &amp;&amp; height === 0 &amp;&amp; typeof this.lastSize !== &#039;undefined&#039;) {
      var _lastSize = this.lastSize;

      // Handle the item getting hidden as a result of our positioning without glitching
      // the classes in and out
      width = _lastSize.width;
      height = _lastSize.height;
    }

    var targetSize = this.cache(&#039;target-bounds&#039;, function () {
      return _this.getTargetBounds();
    });

    var targetHeight = targetSize.height;
    var targetWidth = targetSize.width;

    var allClasses = [this.getClass(&#039;pinned&#039;), this.getClass(&#039;out-of-bounds&#039;)];

    this.options.constraints.forEach(function (constraint) {
      var outOfBoundsClass = constraint.outOfBoundsClass;
      var pinnedClass = constraint.pinnedClass;

      if (outOfBoundsClass) {
        allClasses.push(outOfBoundsClass);
      }
      if (pinnedClass) {
        allClasses.push(pinnedClass);
      }
    });

    allClasses.forEach(function (cls) {
      [&#039;left&#039;, &#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;].forEach(function (side) {
        allClasses.push(cls + &#039;-&#039; + side);
      });
    });

    var addClasses = [];

    var tAttachment = extend({}, targetAttachment);
    var eAttachment = extend({}, this.attachment);

    this.options.constraints.forEach(function (constraint) {
      var to = constraint.to;
      var attachment = constraint.attachment;
      var pin = constraint.pin;

      if (typeof attachment === &#039;undefined&#039;) {
        attachment = &#039;&#039;;
      }

      var changeAttachX = undefined,
          changeAttachY = undefined;
      if (attachment.indexOf(&#039; &#039;) &gt;= 0) {
        var _attachment$split = attachment.split(&#039; &#039;);

        var _attachment$split2 = _slicedToArray(_attachment$split, 2);

        changeAttachY = _attachment$split2[0];
        changeAttachX = _attachment$split2[1];
      } else {
        changeAttachX = changeAttachY = attachment;
      }

      var bounds = getBoundingRect(_this, to);

      if (changeAttachY === &#039;target&#039; || changeAttachY === &#039;both&#039;) {
        if (top &lt; bounds[1] &amp;&amp; tAttachment.top === &#039;top&#039;) {
          top += targetHeight;
          tAttachment.top = &#039;bottom&#039;;
        }

        if (top + height &gt; bounds[3] &amp;&amp; tAttachment.top === &#039;bottom&#039;) {
          top -= targetHeight;
          tAttachment.top = &#039;top&#039;;
        }
      }

      if (changeAttachY === &#039;together&#039;) {
        if (tAttachment.top === &#039;top&#039;) {
          if (eAttachment.top === &#039;bottom&#039; &amp;&amp; top &lt; bounds[1]) {
            top += targetHeight;
            tAttachment.top = &#039;bottom&#039;;

            top += height;
            eAttachment.top = &#039;top&#039;;
          } else if (eAttachment.top === &#039;top&#039; &amp;&amp; top + height &gt; bounds[3] &amp;&amp; top - (height - targetHeight) &gt;= bounds[1]) {
            top -= height - targetHeight;
            tAttachment.top = &#039;bottom&#039;;

            eAttachment.top = &#039;bottom&#039;;
          }
        }

        if (tAttachment.top === &#039;bottom&#039;) {
          if (eAttachment.top === &#039;top&#039; &amp;&amp; top + height &gt; bounds[3]) {
            top -= targetHeight;
            tAttachment.top = &#039;top&#039;;

            top -= height;
            eAttachment.top = &#039;bottom&#039;;
          } else if (eAttachment.top === &#039;bottom&#039; &amp;&amp; top &lt; bounds[1] &amp;&amp; top + (height * 2 - targetHeight) &lt;= bounds[3]) {
            top += height - targetHeight;
            tAttachment.top = &#039;top&#039;;

            eAttachment.top = &#039;top&#039;;
          }
        }

        if (tAttachment.top === &#039;middle&#039;) {
          if (top + height &gt; bounds[3] &amp;&amp; eAttachment.top === &#039;top&#039;) {
            top -= height;
            eAttachment.top = &#039;bottom&#039;;
          } else if (top &lt; bounds[1] &amp;&amp; eAttachment.top === &#039;bottom&#039;) {
            top += height;
            eAttachment.top = &#039;top&#039;;
          }
        }
      }

      if (changeAttachX === &#039;target&#039; || changeAttachX === &#039;both&#039;) {
        if (left &lt; bounds[0] &amp;&amp; tAttachment.left === &#039;left&#039;) {
          left += targetWidth;
          tAttachment.left = &#039;right&#039;;
        }

        if (left + width &gt; bounds[2] &amp;&amp; tAttachment.left === &#039;right&#039;) {
          left -= targetWidth;
          tAttachment.left = &#039;left&#039;;
        }
      }

      if (changeAttachX === &#039;together&#039;) {
        if (left &lt; bounds[0] &amp;&amp; tAttachment.left === &#039;left&#039;) {
          if (eAttachment.left === &#039;right&#039;) {
            left += targetWidth;
            tAttachment.left = &#039;right&#039;;

            left += width;
            eAttachment.left = &#039;left&#039;;
          } else if (eAttachment.left === &#039;left&#039;) {
            left += targetWidth;
            tAttachment.left = &#039;right&#039;;

            left -= width;
            eAttachment.left = &#039;right&#039;;
          }
        } else if (left + width &gt; bounds[2] &amp;&amp; tAttachment.left === &#039;right&#039;) {
          if (eAttachment.left === &#039;left&#039;) {
            left -= targetWidth;
            tAttachment.left = &#039;left&#039;;

            left -= width;
            eAttachment.left = &#039;right&#039;;
          } else if (eAttachment.left === &#039;right&#039;) {
            left -= targetWidth;
            tAttachment.left = &#039;left&#039;;

            left += width;
            eAttachment.left = &#039;left&#039;;
          }
        } else if (tAttachment.left === &#039;center&#039;) {
          if (left + width &gt; bounds[2] &amp;&amp; eAttachment.left === &#039;left&#039;) {
            left -= width;
            eAttachment.left = &#039;right&#039;;
          } else if (left &lt; bounds[0] &amp;&amp; eAttachment.left === &#039;right&#039;) {
            left += width;
            eAttachment.left = &#039;left&#039;;
          }
        }
      }

      if (changeAttachY === &#039;element&#039; || changeAttachY === &#039;both&#039;) {
        if (top &lt; bounds[1] &amp;&amp; eAttachment.top === &#039;bottom&#039;) {
          top += height;
          eAttachment.top = &#039;top&#039;;
        }

        if (top + height &gt; bounds[3] &amp;&amp; eAttachment.top === &#039;top&#039;) {
          top -= height;
          eAttachment.top = &#039;bottom&#039;;
        }
      }

      if (changeAttachX === &#039;element&#039; || changeAttachX === &#039;both&#039;) {
        if (left &lt; bounds[0]) {
          if (eAttachment.left === &#039;right&#039;) {
            left += width;
            eAttachment.left = &#039;left&#039;;
          } else if (eAttachment.left === &#039;center&#039;) {
            left += width / 2;
            eAttachment.left = &#039;left&#039;;
          }
        }

        if (left + width &gt; bounds[2]) {
          if (eAttachment.left === &#039;left&#039;) {
            left -= width;
            eAttachment.left = &#039;right&#039;;
          } else if (eAttachment.left === &#039;center&#039;) {
            left -= width / 2;
            eAttachment.left = &#039;right&#039;;
          }
        }
      }

      if (typeof pin === &#039;string&#039;) {
        pin = pin.split(&#039;,&#039;).map(function (p) {
          return p.trim();
        });
      } else if (pin === true) {
        pin = [&#039;top&#039;, &#039;left&#039;, &#039;right&#039;, &#039;bottom&#039;];
      }

      pin = pin || [];

      var pinned = [];
      var oob = [];

      if (top &lt; bounds[1]) {
        if (pin.indexOf(&#039;top&#039;) &gt;= 0) {
          top = bounds[1];
          pinned.push(&#039;top&#039;);
        } else {
          oob.push(&#039;top&#039;);
        }
      }

      if (top + height &gt; bounds[3]) {
        if (pin.indexOf(&#039;bottom&#039;) &gt;= 0) {
          top = bounds[3] - height;
          pinned.push(&#039;bottom&#039;);
        } else {
          oob.push(&#039;bottom&#039;);
        }
      }

      if (left &lt; bounds[0]) {
        if (pin.indexOf(&#039;left&#039;) &gt;= 0) {
          left = bounds[0];
          pinned.push(&#039;left&#039;);
        } else {
          oob.push(&#039;left&#039;);
        }
      }

      if (left + width &gt; bounds[2]) {
        if (pin.indexOf(&#039;right&#039;) &gt;= 0) {
          left = bounds[2] - width;
          pinned.push(&#039;right&#039;);
        } else {
          oob.push(&#039;right&#039;);
        }
      }

      if (pinned.length) {
        (function () {
          var pinnedClass = undefined;
          if (typeof _this.options.pinnedClass !== &#039;undefined&#039;) {
            pinnedClass = _this.options.pinnedClass;
          } else {
            pinnedClass = _this.getClass(&#039;pinned&#039;);
          }

          addClasses.push(pinnedClass);
          pinned.forEach(function (side) {
            addClasses.push(pinnedClass + &#039;-&#039; + side);
          });
        })();
      }

      if (oob.length) {
        (function () {
          var oobClass = undefined;
          if (typeof _this.options.outOfBoundsClass !== &#039;undefined&#039;) {
            oobClass = _this.options.outOfBoundsClass;
          } else {
            oobClass = _this.getClass(&#039;out-of-bounds&#039;);
          }

          addClasses.push(oobClass);
          oob.forEach(function (side) {
            addClasses.push(oobClass + &#039;-&#039; + side);
          });
        })();
      }

      if (pinned.indexOf(&#039;left&#039;) &gt;= 0 || pinned.indexOf(&#039;right&#039;) &gt;= 0) {
        eAttachment.left = tAttachment.left = false;
      }
      if (pinned.indexOf(&#039;top&#039;) &gt;= 0 || pinned.indexOf(&#039;bottom&#039;) &gt;= 0) {
        eAttachment.top = tAttachment.top = false;
      }

      if (tAttachment.top !== targetAttachment.top || tAttachment.left !== targetAttachment.left || eAttachment.top !== _this.attachment.top || eAttachment.left !== _this.attachment.left) {
        _this.updateAttachClasses(eAttachment, tAttachment);
        _this.trigger(&#039;update&#039;, {
          attachment: eAttachment,
          targetAttachment: tAttachment
        });
      }
    });

    defer(function () {
      if (!(_this.options.addTargetClasses === false)) {
        updateClasses(_this.target, addClasses, allClasses);
      }
      updateClasses(_this.element, addClasses, allClasses);
    });

    return { top: top, left: left };
  }
});
/* globals TetherBase */

&#039;use strict&#039;;

var _TetherBase$Utils = TetherBase.Utils;
var getBounds = _TetherBase$Utils.getBounds;
var updateClasses = _TetherBase$Utils.updateClasses;
var defer = _TetherBase$Utils.defer;

TetherBase.modules.push({
  position: function position(_ref) {
    var _this = this;

    var top = _ref.top;
    var left = _ref.left;

    var _cache = this.cache(&#039;element-bounds&#039;, function () {
      return getBounds(_this.element);
    });

    var height = _cache.height;
    var width = _cache.width;

    var targetPos = this.getTargetBounds();

    var bottom = top + height;
    var right = left + width;

    var abutted = [];
    if (top &lt;= targetPos.bottom &amp;&amp; bottom &gt;= targetPos.top) {
      [&#039;left&#039;, &#039;right&#039;].forEach(function (side) {
        var targetPosSide = targetPos[side];
        if (targetPosSide === left || targetPosSide === right) {
          abutted.push(side);
        }
      });
    }

    if (left &lt;= targetPos.right &amp;&amp; right &gt;= targetPos.left) {
      [&#039;top&#039;, &#039;bottom&#039;].forEach(function (side) {
        var targetPosSide = targetPos[side];
        if (targetPosSide === top || targetPosSide === bottom) {
          abutted.push(side);
        }
      });
    }

    var allClasses = [];
    var addClasses = [];

    var sides = [&#039;left&#039;, &#039;top&#039;, &#039;right&#039;, &#039;bottom&#039;];
    allClasses.push(this.getClass(&#039;abutted&#039;));
    sides.forEach(function (side) {
      allClasses.push(_this.getClass(&#039;abutted&#039;) + &#039;-&#039; + side);
    });

    if (abutted.length) {
      addClasses.push(this.getClass(&#039;abutted&#039;));
    }

    abutted.forEach(function (side) {
      addClasses.push(_this.getClass(&#039;abutted&#039;) + &#039;-&#039; + side);
    });

    defer(function () {
      if (!(_this.options.addTargetClasses === false)) {
        updateClasses(_this.target, addClasses, allClasses);
      }
      updateClasses(_this.element, addClasses, allClasses);
    });

    return true;
  }
});
/* globals TetherBase */

&#039;use strict&#039;;

var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i &amp;&amp; _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n &amp;&amp; _i[&#039;return&#039;]) _i[&#039;return&#039;](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(&#039;Invalid attempt to destructure non-iterable instance&#039;); } }; })();

TetherBase.modules.push({
  position: function position(_ref) {
    var top = _ref.top;
    var left = _ref.left;

    if (!this.options.shift) {
      return;
    }

    var shift = this.options.shift;
    if (typeof this.options.shift === &#039;function&#039;) {
      shift = this.options.shift.call(this, { top: top, left: left });
    }

    var shiftTop = undefined,
        shiftLeft = undefined;
    if (typeof shift === &#039;string&#039;) {
      shift = shift.split(&#039; &#039;);
      shift[1] = shift[1] || shift[0];

      var _shift = shift;

      var _shift2 = _slicedToArray(_shift, 2);

      shiftTop = _shift2[0];
      shiftLeft = _shift2[1];

      shiftTop = parseFloat(shiftTop, 10);
      shiftLeft = parseFloat(shiftLeft, 10);
    } else {
      shiftTop = shift.top;
      shiftLeft = shift.left;
    }

    top += shiftTop;
    left += shiftLeft;

    return { top: top, left: left };
  }
});
return Tether;

}));
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fupdraftplus%2Fincludes%2Ftether'>⬅ Back to Directory</a>