tether-rails 1.2.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml ADDED
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: 170c3d6cc2a69f59b36022f72980e9904f081a25
4
+ data.tar.gz: 76a8cda8ee5659d21c97e327848ae6e1d430ce53
5
+ SHA512:
6
+ metadata.gz: a0522e826ca9628b32209e7e96d78e7957ab98fa78828f4487379ef1caa9e77250377f4100fe259d21825acd3f15b7eac5f7b3ee9d09bf442d291f92d783a940
7
+ data.tar.gz: 099e8c0ff130d06f33387cf1dfd4c455a23cc312875105aad939a1aceefe10ceeff4f5fce4fdc07cbd5825b1182c934a40c2eb4474c3e0070b7b4a1a8f57e8de
data/.gitignore ADDED
@@ -0,0 +1,2 @@
1
+ .ruby-version
2
+ Gemfile.lock
data/README.md ADDED
@@ -0,0 +1,48 @@
1
+ # tether-rails
2
+
3
+ This gem wraps the [Tether](http://tether.io/docs/welcome/) JavaScript library so that it can be included easily in the Rails asset pipeline.
4
+
5
+
6
+ ## Installation and Usage
7
+
8
+ Include tether-rails application's Gemfile
9
+ ```ruby
10
+ gem 'tether-rails'
11
+ ```
12
+ and run `bundle install`
13
+
14
+ Then, add tether-rails to your `application.js` manifest
15
+ ```
16
+ //= require tether-rails
17
+ ```
18
+ and include the stylesheets in your `application.css` manifest
19
+ ```
20
+ *= require tether
21
+ ```
22
+
23
+ This gem also includes the CSS for `theme-basic`, `theme-arrows`, and `theme-arrows-dark`. You can include whichever files you need in your `application.css` with
24
+ ```
25
+ *= require tether-theme-basic
26
+ *= require tether-theme-arrows
27
+ *= require tether-theme-arrows-dark
28
+ ```
29
+
30
+
31
+ ## Versioning
32
+
33
+ The gem version will mirror the version of Tether that is included.
34
+
35
+
36
+ ## Contributing
37
+
38
+ If you need a newer version of Tether:
39
+
40
+ 1. Fork this repo.
41
+ 2. Update the vendored files with the newest release of [Tether](https://github.com/HubSpot/tether)
42
+ 3. Update `lib/tether-rails/version.rb` to match the version of Tether that you updated to.
43
+ 4. Push to your repo and create a pull request.
44
+
45
+
46
+ ## License
47
+
48
+ The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
@@ -0,0 +1,4 @@
1
+ require 'tether-rails/engine'
2
+
3
+ module TetherRails
4
+ end
@@ -0,0 +1,6 @@
1
+ require 'tether-rails/version'
2
+
3
+ module TetherRails
4
+ class Engine < ::Rails::Engine
5
+ end
6
+ end
@@ -0,0 +1,3 @@
1
+ module TetherRails
2
+ VERSION = '1.2.0'
3
+ end
@@ -0,0 +1,1726 @@
1
+ /*! tether 1.2.0 */
2
+
3
+ (function(root, factory) {
4
+ if (typeof define === 'function' && define.amd) {
5
+ define(factory);
6
+ } else if (typeof exports === 'object') {
7
+ module.exports = factory(require, exports, module);
8
+ } else {
9
+ root.Tether = factory();
10
+ }
11
+ }(this, function(require, exports, module) {
12
+
13
+ 'use strict';
14
+
15
+ var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' 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; }; })();
16
+
17
+ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
18
+
19
+ var TetherBase = undefined;
20
+ if (typeof TetherBase === 'undefined') {
21
+ TetherBase = { modules: [] };
22
+ }
23
+
24
+ function getScrollParent(el) {
25
+ // In firefox if the el is inside an iframe with display: none; window.getComputedStyle() will return null;
26
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=548397
27
+ var computedStyle = getComputedStyle(el) || {};
28
+ var position = computedStyle.position;
29
+
30
+ if (position === 'fixed') {
31
+ return el;
32
+ }
33
+
34
+ var parent = el;
35
+ while (parent = parent.parentNode) {
36
+ var style = undefined;
37
+ try {
38
+ style = getComputedStyle(parent);
39
+ } catch (err) {}
40
+
41
+ if (typeof style === 'undefined' || style === null) {
42
+ return parent;
43
+ }
44
+
45
+ var _style = style;
46
+ var overflow = _style.overflow;
47
+ var overflowX = _style.overflowX;
48
+ var overflowY = _style.overflowY;
49
+
50
+ if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) {
51
+ if (position !== 'absolute' || ['relative', 'absolute', 'fixed'].indexOf(style.position) >= 0) {
52
+ return parent;
53
+ }
54
+ }
55
+ }
56
+
57
+ return document.body;
58
+ }
59
+
60
+ var uniqueId = (function () {
61
+ var id = 0;
62
+ return function () {
63
+ return ++id;
64
+ };
65
+ })();
66
+
67
+ var zeroPosCache = {};
68
+ var getOrigin = function getOrigin(doc) {
69
+ // getBoundingClientRect is unfortunately too accurate. It introduces a pixel or two of
70
+ // jitter as the user scrolls that messes with our ability to detect if two positions
71
+ // are equivilant or not. We place an element at the top left of the page that will
72
+ // get the same jitter, so we can cancel the two out.
73
+ var node = doc._tetherZeroElement;
74
+ if (typeof node === 'undefined') {
75
+ node = doc.createElement('div');
76
+ node.setAttribute('data-tether-id', uniqueId());
77
+ extend(node.style, {
78
+ top: 0,
79
+ left: 0,
80
+ position: 'absolute'
81
+ });
82
+
83
+ doc.body.appendChild(node);
84
+
85
+ doc._tetherZeroElement = node;
86
+ }
87
+
88
+ var id = node.getAttribute('data-tether-id');
89
+ if (typeof zeroPosCache[id] === 'undefined') {
90
+ zeroPosCache[id] = {};
91
+
92
+ var rect = node.getBoundingClientRect();
93
+ for (var k in rect) {
94
+ // Can't use extend, as on IE9, elements don't resolve to be hasOwnProperty
95
+ zeroPosCache[id][k] = rect[k];
96
+ }
97
+
98
+ // Clear the cache when this position call is done
99
+ defer(function () {
100
+ delete zeroPosCache[id];
101
+ });
102
+ }
103
+
104
+ return zeroPosCache[id];
105
+ };
106
+
107
+ function getBounds(el) {
108
+ var doc = undefined;
109
+ if (el === document) {
110
+ doc = document;
111
+ el = document.documentElement;
112
+ } else {
113
+ doc = el.ownerDocument;
114
+ }
115
+
116
+ var docEl = doc.documentElement;
117
+
118
+ var box = {};
119
+ // The original object returned by getBoundingClientRect is immutable, so we clone it
120
+ // We can't use extend because the properties are not considered part of the object by hasOwnProperty in IE9
121
+ var rect = el.getBoundingClientRect();
122
+ for (var k in rect) {
123
+ box[k] = rect[k];
124
+ }
125
+
126
+ var origin = getOrigin(doc);
127
+
128
+ box.top -= origin.top;
129
+ box.left -= origin.left;
130
+
131
+ if (typeof box.width === 'undefined') {
132
+ box.width = document.body.scrollWidth - box.left - box.right;
133
+ }
134
+ if (typeof box.height === 'undefined') {
135
+ box.height = document.body.scrollHeight - box.top - box.bottom;
136
+ }
137
+
138
+ box.top = box.top - docEl.clientTop;
139
+ box.left = box.left - docEl.clientLeft;
140
+ box.right = doc.body.clientWidth - box.width - box.left;
141
+ box.bottom = doc.body.clientHeight - box.height - box.top;
142
+
143
+ return box;
144
+ }
145
+
146
+ function getOffsetParent(el) {
147
+ return el.offsetParent || document.documentElement;
148
+ }
149
+
150
+ function getScrollBarSize() {
151
+ var inner = document.createElement('div');
152
+ inner.style.width = '100%';
153
+ inner.style.height = '200px';
154
+
155
+ var outer = document.createElement('div');
156
+ extend(outer.style, {
157
+ position: 'absolute',
158
+ top: 0,
159
+ left: 0,
160
+ pointerEvents: 'none',
161
+ visibility: 'hidden',
162
+ width: '200px',
163
+ height: '150px',
164
+ overflow: 'hidden'
165
+ });
166
+
167
+ outer.appendChild(inner);
168
+
169
+ document.body.appendChild(outer);
170
+
171
+ var widthContained = inner.offsetWidth;
172
+ outer.style.overflow = 'scroll';
173
+ var widthScroll = inner.offsetWidth;
174
+
175
+ if (widthContained === widthScroll) {
176
+ widthScroll = outer.clientWidth;
177
+ }
178
+
179
+ document.body.removeChild(outer);
180
+
181
+ var width = widthContained - widthScroll;
182
+
183
+ return { width: width, height: width };
184
+ }
185
+
186
+ function extend() {
187
+ var out = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
188
+
189
+ var args = [];
190
+
191
+ Array.prototype.push.apply(args, arguments);
192
+
193
+ args.slice(1).forEach(function (obj) {
194
+ if (obj) {
195
+ for (var key in obj) {
196
+ if (({}).hasOwnProperty.call(obj, key)) {
197
+ out[key] = obj[key];
198
+ }
199
+ }
200
+ }
201
+ });
202
+
203
+ return out;
204
+ }
205
+
206
+ function removeClass(el, name) {
207
+ if (typeof el.classList !== 'undefined') {
208
+ name.split(' ').forEach(function (cls) {
209
+ if (cls.trim()) {
210
+ el.classList.remove(cls);
211
+ }
212
+ });
213
+ } else {
214
+ var regex = new RegExp('(^| )' + name.split(' ').join('|') + '( |$)', 'gi');
215
+ var className = getClassName(el).replace(regex, ' ');
216
+ setClassName(el, className);
217
+ }
218
+ }
219
+
220
+ function addClass(el, name) {
221
+ if (typeof el.classList !== 'undefined') {
222
+ name.split(' ').forEach(function (cls) {
223
+ if (cls.trim()) {
224
+ el.classList.add(cls);
225
+ }
226
+ });
227
+ } else {
228
+ removeClass(el, name);
229
+ var cls = getClassName(el) + (' ' + name);
230
+ setClassName(el, cls);
231
+ }
232
+ }
233
+
234
+ function hasClass(el, name) {
235
+ if (typeof el.classList !== 'undefined') {
236
+ return el.classList.contains(name);
237
+ }
238
+ var className = getClassName(el);
239
+ return new RegExp('(^| )' + name + '( |$)', 'gi').test(className);
240
+ }
241
+
242
+ function getClassName(el) {
243
+ if (el.className instanceof SVGAnimatedString) {
244
+ return el.className.baseVal;
245
+ }
246
+ return el.className;
247
+ }
248
+
249
+ function setClassName(el, className) {
250
+ el.setAttribute('class', className);
251
+ }
252
+
253
+ function updateClasses(el, add, all) {
254
+ // Of the set of 'all' classes, we need the 'add' classes, and only the
255
+ // 'add' classes to be set.
256
+ all.forEach(function (cls) {
257
+ if (add.indexOf(cls) === -1 && hasClass(el, cls)) {
258
+ removeClass(el, cls);
259
+ }
260
+ });
261
+
262
+ add.forEach(function (cls) {
263
+ if (!hasClass(el, cls)) {
264
+ addClass(el, cls);
265
+ }
266
+ });
267
+ }
268
+
269
+ var deferred = [];
270
+
271
+ var defer = function defer(fn) {
272
+ deferred.push(fn);
273
+ };
274
+
275
+ var flush = function flush() {
276
+ var fn = undefined;
277
+ while (fn = deferred.pop()) {
278
+ fn();
279
+ }
280
+ };
281
+
282
+ var Evented = (function () {
283
+ function Evented() {
284
+ _classCallCheck(this, Evented);
285
+ }
286
+
287
+ _createClass(Evented, [{
288
+ key: 'on',
289
+ value: function on(event, handler, ctx) {
290
+ var once = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];
291
+
292
+ if (typeof this.bindings === 'undefined') {
293
+ this.bindings = {};
294
+ }
295
+ if (typeof this.bindings[event] === 'undefined') {
296
+ this.bindings[event] = [];
297
+ }
298
+ this.bindings[event].push({ handler: handler, ctx: ctx, once: once });
299
+ }
300
+ }, {
301
+ key: 'once',
302
+ value: function once(event, handler, ctx) {
303
+ this.on(event, handler, ctx, true);
304
+ }
305
+ }, {
306
+ key: 'off',
307
+ value: function off(event, handler) {
308
+ if (typeof this.bindings !== 'undefined' && typeof this.bindings[event] !== 'undefined') {
309
+ return;
310
+ }
311
+
312
+ if (typeof handler === 'undefined') {
313
+ delete this.bindings[event];
314
+ } else {
315
+ var i = 0;
316
+ while (i < this.bindings[event].length) {
317
+ if (this.bindings[event][i].handler === handler) {
318
+ this.bindings[event].splice(i, 1);
319
+ } else {
320
+ ++i;
321
+ }
322
+ }
323
+ }
324
+ }
325
+ }, {
326
+ key: 'trigger',
327
+ value: function trigger(event) {
328
+ if (typeof this.bindings !== 'undefined' && this.bindings[event]) {
329
+ var i = 0;
330
+
331
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
332
+ args[_key - 1] = arguments[_key];
333
+ }
334
+
335
+ while (i < this.bindings[event].length) {
336
+ var _bindings$event$i = this.bindings[event][i];
337
+ var handler = _bindings$event$i.handler;
338
+ var ctx = _bindings$event$i.ctx;
339
+ var once = _bindings$event$i.once;
340
+
341
+ var context = ctx;
342
+ if (typeof context === 'undefined') {
343
+ context = this;
344
+ }
345
+
346
+ handler.apply(context, args);
347
+
348
+ if (once) {
349
+ this.bindings[event].splice(i, 1);
350
+ } else {
351
+ ++i;
352
+ }
353
+ }
354
+ }
355
+ }
356
+ }]);
357
+
358
+ return Evented;
359
+ })();
360
+
361
+ TetherBase.Utils = {
362
+ getScrollParent: getScrollParent,
363
+ getBounds: getBounds,
364
+ getOffsetParent: getOffsetParent,
365
+ extend: extend,
366
+ addClass: addClass,
367
+ removeClass: removeClass,
368
+ hasClass: hasClass,
369
+ updateClasses: updateClasses,
370
+ defer: defer,
371
+ flush: flush,
372
+ uniqueId: uniqueId,
373
+ Evented: Evented,
374
+ getScrollBarSize: getScrollBarSize
375
+ };
376
+ /* globals TetherBase, performance */
377
+
378
+ 'use strict';
379
+
380
+ 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 && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } 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('Invalid attempt to destructure non-iterable instance'); } }; })();
381
+
382
+ var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' 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; }; })();
383
+
384
+ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
385
+
386
+ if (typeof TetherBase === 'undefined') {
387
+ throw new Error('You must include the utils.js file before tether.js');
388
+ }
389
+
390
+ var _TetherBase$Utils = TetherBase.Utils;
391
+ var getScrollParent = _TetherBase$Utils.getScrollParent;
392
+ var getBounds = _TetherBase$Utils.getBounds;
393
+ var getOffsetParent = _TetherBase$Utils.getOffsetParent;
394
+ var extend = _TetherBase$Utils.extend;
395
+ var addClass = _TetherBase$Utils.addClass;
396
+ var removeClass = _TetherBase$Utils.removeClass;
397
+ var updateClasses = _TetherBase$Utils.updateClasses;
398
+ var defer = _TetherBase$Utils.defer;
399
+ var flush = _TetherBase$Utils.flush;
400
+ var getScrollBarSize = _TetherBase$Utils.getScrollBarSize;
401
+
402
+ function within(a, b) {
403
+ var diff = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];
404
+
405
+ return a + diff >= b && b >= a - diff;
406
+ }
407
+
408
+ var transformKey = (function () {
409
+ if (typeof document === 'undefined') {
410
+ return '';
411
+ }
412
+ var el = document.createElement('div');
413
+
414
+ var transforms = ['transform', 'webkitTransform', 'OTransform', 'MozTransform', 'msTransform'];
415
+ for (var i = 0; i < transforms.length; ++i) {
416
+ var key = transforms[i];
417
+ if (el.style[key] !== undefined) {
418
+ return key;
419
+ }
420
+ }
421
+ })();
422
+
423
+ var tethers = [];
424
+
425
+ var position = function position() {
426
+ tethers.forEach(function (tether) {
427
+ tether.position(false);
428
+ });
429
+ flush();
430
+ };
431
+
432
+ function now() {
433
+ if (typeof performance !== 'undefined' && typeof performance.now !== 'undefined') {
434
+ return performance.now();
435
+ }
436
+ return +new Date();
437
+ }
438
+
439
+ (function () {
440
+ var lastCall = null;
441
+ var lastDuration = null;
442
+ var pendingTimeout = null;
443
+
444
+ var tick = function tick() {
445
+ if (typeof lastDuration !== 'undefined' && lastDuration > 16) {
446
+ // We voluntarily throttle ourselves if we can't manage 60fps
447
+ lastDuration = Math.min(lastDuration - 16, 250);
448
+
449
+ // Just in case this is the last event, remember to position just once more
450
+ pendingTimeout = setTimeout(tick, 250);
451
+ return;
452
+ }
453
+
454
+ if (typeof lastCall !== 'undefined' && now() - lastCall < 10) {
455
+ // Some browsers call events a little too frequently, refuse to run more than is reasonable
456
+ return;
457
+ }
458
+
459
+ if (typeof pendingTimeout !== 'undefined') {
460
+ clearTimeout(pendingTimeout);
461
+ pendingTimeout = null;
462
+ }
463
+
464
+ lastCall = now();
465
+ position();
466
+ lastDuration = now() - lastCall;
467
+ };
468
+
469
+ if (typeof window !== 'undefined') {
470
+ ['resize', 'scroll', 'touchmove'].forEach(function (event) {
471
+ window.addEventListener(event, tick);
472
+ });
473
+ }
474
+ })();
475
+
476
+ var MIRROR_LR = {
477
+ center: 'center',
478
+ left: 'right',
479
+ right: 'left'
480
+ };
481
+
482
+ var MIRROR_TB = {
483
+ middle: 'middle',
484
+ top: 'bottom',
485
+ bottom: 'top'
486
+ };
487
+
488
+ var OFFSET_MAP = {
489
+ top: 0,
490
+ left: 0,
491
+ middle: '50%',
492
+ center: '50%',
493
+ bottom: '100%',
494
+ right: '100%'
495
+ };
496
+
497
+ var autoToFixedAttachment = function autoToFixedAttachment(attachment, relativeToAttachment) {
498
+ var left = attachment.left;
499
+ var top = attachment.top;
500
+
501
+ if (left === 'auto') {
502
+ left = MIRROR_LR[relativeToAttachment.left];
503
+ }
504
+
505
+ if (top === 'auto') {
506
+ top = MIRROR_TB[relativeToAttachment.top];
507
+ }
508
+
509
+ return { left: left, top: top };
510
+ };
511
+
512
+ var attachmentToOffset = function attachmentToOffset(attachment) {
513
+ var left = attachment.left;
514
+ var top = attachment.top;
515
+
516
+ if (typeof OFFSET_MAP[attachment.left] !== 'undefined') {
517
+ left = OFFSET_MAP[attachment.left];
518
+ }
519
+
520
+ if (typeof OFFSET_MAP[attachment.top] !== 'undefined') {
521
+ top = OFFSET_MAP[attachment.top];
522
+ }
523
+
524
+ return { left: left, top: top };
525
+ };
526
+
527
+ function addOffset() {
528
+ var out = { top: 0, left: 0 };
529
+
530
+ for (var _len = arguments.length, offsets = Array(_len), _key = 0; _key < _len; _key++) {
531
+ offsets[_key] = arguments[_key];
532
+ }
533
+
534
+ offsets.forEach(function (_ref) {
535
+ var top = _ref.top;
536
+ var left = _ref.left;
537
+
538
+ if (typeof top === 'string') {
539
+ top = parseFloat(top, 10);
540
+ }
541
+ if (typeof left === 'string') {
542
+ left = parseFloat(left, 10);
543
+ }
544
+
545
+ out.top += top;
546
+ out.left += left;
547
+ });
548
+
549
+ return out;
550
+ }
551
+
552
+ function offsetToPx(offset, size) {
553
+ if (typeof offset.left === 'string' && offset.left.indexOf('%') !== -1) {
554
+ offset.left = parseFloat(offset.left, 10) / 100 * size.width;
555
+ }
556
+ if (typeof offset.top === 'string' && offset.top.indexOf('%') !== -1) {
557
+ offset.top = parseFloat(offset.top, 10) / 100 * size.height;
558
+ }
559
+
560
+ return offset;
561
+ }
562
+
563
+ var parseOffset = function parseOffset(value) {
564
+ var _value$split = value.split(' ');
565
+
566
+ var _value$split2 = _slicedToArray(_value$split, 2);
567
+
568
+ var top = _value$split2[0];
569
+ var left = _value$split2[1];
570
+
571
+ return { top: top, left: left };
572
+ };
573
+ var parseAttachment = parseOffset;
574
+
575
+ var TetherClass = (function () {
576
+ function TetherClass(options) {
577
+ var _this = this;
578
+
579
+ _classCallCheck(this, TetherClass);
580
+
581
+ this.position = this.position.bind(this);
582
+
583
+ tethers.push(this);
584
+
585
+ this.history = [];
586
+
587
+ this.setOptions(options, false);
588
+
589
+ TetherBase.modules.forEach(function (module) {
590
+ if (typeof module.initialize !== 'undefined') {
591
+ module.initialize.call(_this);
592
+ }
593
+ });
594
+
595
+ this.position();
596
+ }
597
+
598
+ _createClass(TetherClass, [{
599
+ key: 'getClass',
600
+ value: function getClass() {
601
+ var key = arguments.length <= 0 || arguments[0] === undefined ? '' : arguments[0];
602
+ var classes = this.options.classes;
603
+
604
+ if (typeof classes !== 'undefined' && classes[key]) {
605
+ return this.options.classes[key];
606
+ } else if (this.options.classPrefix) {
607
+ return this.options.classPrefix + '-' + key;
608
+ } else {
609
+ return key;
610
+ }
611
+ }
612
+ }, {
613
+ key: 'setOptions',
614
+ value: function setOptions(options) {
615
+ var _this2 = this;
616
+
617
+ var pos = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];
618
+
619
+ var defaults = {
620
+ offset: '0 0',
621
+ targetOffset: '0 0',
622
+ targetAttachment: 'auto auto',
623
+ classPrefix: 'tether'
624
+ };
625
+
626
+ this.options = extend(defaults, options);
627
+
628
+ var _options = this.options;
629
+ var element = _options.element;
630
+ var target = _options.target;
631
+ var targetModifier = _options.targetModifier;
632
+
633
+ this.element = element;
634
+ this.target = target;
635
+ this.targetModifier = targetModifier;
636
+
637
+ if (this.target === 'viewport') {
638
+ this.target = document.body;
639
+ this.targetModifier = 'visible';
640
+ } else if (this.target === 'scroll-handle') {
641
+ this.target = document.body;
642
+ this.targetModifier = 'scroll-handle';
643
+ }
644
+
645
+ ['element', 'target'].forEach(function (key) {
646
+ if (typeof _this2[key] === 'undefined') {
647
+ throw new Error('Tether Error: Both element and target must be defined');
648
+ }
649
+
650
+ if (typeof _this2[key].jquery !== 'undefined') {
651
+ _this2[key] = _this2[key][0];
652
+ } else if (typeof _this2[key] === 'string') {
653
+ _this2[key] = document.querySelector(_this2[key]);
654
+ }
655
+ });
656
+
657
+ addClass(this.element, this.getClass('element'));
658
+ if (!(this.options.addTargetClasses === false)) {
659
+ addClass(this.target, this.getClass('target'));
660
+ }
661
+
662
+ if (!this.options.attachment) {
663
+ throw new Error('Tether Error: You must provide an attachment');
664
+ }
665
+
666
+ this.targetAttachment = parseAttachment(this.options.targetAttachment);
667
+ this.attachment = parseAttachment(this.options.attachment);
668
+ this.offset = parseOffset(this.options.offset);
669
+ this.targetOffset = parseOffset(this.options.targetOffset);
670
+
671
+ if (typeof this.scrollParent !== 'undefined') {
672
+ this.disable();
673
+ }
674
+
675
+ if (this.targetModifier === 'scroll-handle') {
676
+ this.scrollParent = this.target;
677
+ } else {
678
+ this.scrollParent = getScrollParent(this.target);
679
+ }
680
+
681
+ if (!(this.options.enabled === false)) {
682
+ this.enable(pos);
683
+ }
684
+ }
685
+ }, {
686
+ key: 'getTargetBounds',
687
+ value: function getTargetBounds() {
688
+ if (typeof this.targetModifier !== 'undefined') {
689
+ if (this.targetModifier === 'visible') {
690
+ if (this.target === document.body) {
691
+ return { top: pageYOffset, left: pageXOffset, height: innerHeight, width: innerWidth };
692
+ } else {
693
+ var bounds = getBounds(this.target);
694
+
695
+ var out = {
696
+ height: bounds.height,
697
+ width: bounds.width,
698
+ top: bounds.top,
699
+ left: bounds.left
700
+ };
701
+
702
+ out.height = Math.min(out.height, bounds.height - (pageYOffset - bounds.top));
703
+ out.height = Math.min(out.height, bounds.height - (bounds.top + bounds.height - (pageYOffset + innerHeight)));
704
+ out.height = Math.min(innerHeight, out.height);
705
+ out.height -= 2;
706
+
707
+ out.width = Math.min(out.width, bounds.width - (pageXOffset - bounds.left));
708
+ out.width = Math.min(out.width, bounds.width - (bounds.left + bounds.width - (pageXOffset + innerWidth)));
709
+ out.width = Math.min(innerWidth, out.width);
710
+ out.width -= 2;
711
+
712
+ if (out.top < pageYOffset) {
713
+ out.top = pageYOffset;
714
+ }
715
+ if (out.left < pageXOffset) {
716
+ out.left = pageXOffset;
717
+ }
718
+
719
+ return out;
720
+ }
721
+ } else if (this.targetModifier === 'scroll-handle') {
722
+ var bounds = undefined;
723
+ var target = this.target;
724
+ if (target === document.body) {
725
+ target = document.documentElement;
726
+
727
+ bounds = {
728
+ left: pageXOffset,
729
+ top: pageYOffset,
730
+ height: innerHeight,
731
+ width: innerWidth
732
+ };
733
+ } else {
734
+ bounds = getBounds(target);
735
+ }
736
+
737
+ var style = getComputedStyle(target);
738
+
739
+ var hasBottomScroll = target.scrollWidth > target.clientWidth || [style.overflow, style.overflowX].indexOf('scroll') >= 0 || this.target !== document.body;
740
+
741
+ var scrollBottom = 0;
742
+ if (hasBottomScroll) {
743
+ scrollBottom = 15;
744
+ }
745
+
746
+ var height = bounds.height - parseFloat(style.borderTopWidth) - parseFloat(style.borderBottomWidth) - scrollBottom;
747
+
748
+ var out = {
749
+ width: 15,
750
+ height: height * 0.975 * (height / target.scrollHeight),
751
+ left: bounds.left + bounds.width - parseFloat(style.borderLeftWidth) - 15
752
+ };
753
+
754
+ var fitAdj = 0;
755
+ if (height < 408 && this.target === document.body) {
756
+ fitAdj = -0.00011 * Math.pow(height, 2) - 0.00727 * height + 22.58;
757
+ }
758
+
759
+ if (this.target !== document.body) {
760
+ out.height = Math.max(out.height, 24);
761
+ }
762
+
763
+ var scrollPercentage = this.target.scrollTop / (target.scrollHeight - height);
764
+ out.top = scrollPercentage * (height - out.height - fitAdj) + bounds.top + parseFloat(style.borderTopWidth);
765
+
766
+ if (this.target === document.body) {
767
+ out.height = Math.max(out.height, 24);
768
+ }
769
+
770
+ return out;
771
+ }
772
+ } else {
773
+ return getBounds(this.target);
774
+ }
775
+ }
776
+ }, {
777
+ key: 'clearCache',
778
+ value: function clearCache() {
779
+ this._cache = {};
780
+ }
781
+ }, {
782
+ key: 'cache',
783
+ value: function cache(k, getter) {
784
+ // More than one module will often need the same DOM info, so
785
+ // we keep a cache which is cleared on each position call
786
+ if (typeof this._cache === 'undefined') {
787
+ this._cache = {};
788
+ }
789
+
790
+ if (typeof this._cache[k] === 'undefined') {
791
+ this._cache[k] = getter.call(this);
792
+ }
793
+
794
+ return this._cache[k];
795
+ }
796
+ }, {
797
+ key: 'enable',
798
+ value: function enable() {
799
+ var pos = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];
800
+
801
+ if (!(this.options.addTargetClasses === false)) {
802
+ addClass(this.target, this.getClass('enabled'));
803
+ }
804
+ addClass(this.element, this.getClass('enabled'));
805
+ this.enabled = true;
806
+
807
+ if (this.scrollParent !== document) {
808
+ this.scrollParent.addEventListener('scroll', this.position);
809
+ }
810
+
811
+ if (pos) {
812
+ this.position();
813
+ }
814
+ }
815
+ }, {
816
+ key: 'disable',
817
+ value: function disable() {
818
+ removeClass(this.target, this.getClass('enabled'));
819
+ removeClass(this.element, this.getClass('enabled'));
820
+ this.enabled = false;
821
+
822
+ if (typeof this.scrollParent !== 'undefined') {
823
+ this.scrollParent.removeEventListener('scroll', this.position);
824
+ }
825
+ }
826
+ }, {
827
+ key: 'destroy',
828
+ value: function destroy() {
829
+ var _this3 = this;
830
+
831
+ this.disable();
832
+
833
+ tethers.forEach(function (tether, i) {
834
+ if (tether === _this3) {
835
+ tethers.splice(i, 1);
836
+ return;
837
+ }
838
+ });
839
+ }
840
+ }, {
841
+ key: 'updateAttachClasses',
842
+ value: function updateAttachClasses(elementAttach, targetAttach) {
843
+ var _this4 = this;
844
+
845
+ elementAttach = elementAttach || this.attachment;
846
+ targetAttach = targetAttach || this.targetAttachment;
847
+ var sides = ['left', 'top', 'bottom', 'right', 'middle', 'center'];
848
+
849
+ if (typeof this._addAttachClasses !== 'undefined' && this._addAttachClasses.length) {
850
+ // updateAttachClasses can be called more than once in a position call, so
851
+ // we need to clean up after ourselves such that when the last defer gets
852
+ // ran it doesn't add any extra classes from previous calls.
853
+ this._addAttachClasses.splice(0, this._addAttachClasses.length);
854
+ }
855
+
856
+ if (typeof this._addAttachClasses === 'undefined') {
857
+ this._addAttachClasses = [];
858
+ }
859
+ var add = this._addAttachClasses;
860
+
861
+ if (elementAttach.top) {
862
+ add.push(this.getClass('element-attached') + '-' + elementAttach.top);
863
+ }
864
+ if (elementAttach.left) {
865
+ add.push(this.getClass('element-attached') + '-' + elementAttach.left);
866
+ }
867
+ if (targetAttach.top) {
868
+ add.push(this.getClass('target-attached') + '-' + targetAttach.top);
869
+ }
870
+ if (targetAttach.left) {
871
+ add.push(this.getClass('target-attached') + '-' + targetAttach.left);
872
+ }
873
+
874
+ var all = [];
875
+ sides.forEach(function (side) {
876
+ all.push(_this4.getClass('element-attached') + '-' + side);
877
+ all.push(_this4.getClass('target-attached') + '-' + side);
878
+ });
879
+
880
+ defer(function () {
881
+ if (!(typeof _this4._addAttachClasses !== 'undefined')) {
882
+ return;
883
+ }
884
+
885
+ updateClasses(_this4.element, _this4._addAttachClasses, all);
886
+ if (!(_this4.options.addTargetClasses === false)) {
887
+ updateClasses(_this4.target, _this4._addAttachClasses, all);
888
+ }
889
+
890
+ delete _this4._addAttachClasses;
891
+ });
892
+ }
893
+ }, {
894
+ key: 'position',
895
+ value: function position() {
896
+ var _this5 = this;
897
+
898
+ var flushChanges = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];
899
+
900
+ // flushChanges commits the changes immediately, leave true unless you are positioning multiple
901
+ // tethers (in which case call Tether.Utils.flush yourself when you're done)
902
+
903
+ if (!this.enabled) {
904
+ return;
905
+ }
906
+
907
+ this.clearCache();
908
+
909
+ // Turn 'auto' attachments into the appropriate corner or edge
910
+ var targetAttachment = autoToFixedAttachment(this.targetAttachment, this.attachment);
911
+
912
+ this.updateAttachClasses(this.attachment, targetAttachment);
913
+
914
+ var elementPos = this.cache('element-bounds', function () {
915
+ return getBounds(_this5.element);
916
+ });
917
+
918
+ var width = elementPos.width;
919
+ var height = elementPos.height;
920
+
921
+ if (width === 0 && height === 0 && typeof this.lastSize !== 'undefined') {
922
+ var _lastSize = this.lastSize;
923
+
924
+ // We cache the height and width to make it possible to position elements that are
925
+ // getting hidden.
926
+ width = _lastSize.width;
927
+ height = _lastSize.height;
928
+ } else {
929
+ this.lastSize = { width: width, height: height };
930
+ }
931
+
932
+ var targetPos = this.cache('target-bounds', function () {
933
+ return _this5.getTargetBounds();
934
+ });
935
+ var targetSize = targetPos;
936
+
937
+ // Get an actual px offset from the attachment
938
+ var offset = offsetToPx(attachmentToOffset(this.attachment), { width: width, height: height });
939
+ var targetOffset = offsetToPx(attachmentToOffset(targetAttachment), targetSize);
940
+
941
+ var manualOffset = offsetToPx(this.offset, { width: width, height: height });
942
+ var manualTargetOffset = offsetToPx(this.targetOffset, targetSize);
943
+
944
+ // Add the manually provided offset
945
+ offset = addOffset(offset, manualOffset);
946
+ targetOffset = addOffset(targetOffset, manualTargetOffset);
947
+
948
+ // It's now our goal to make (element position + offset) == (target position + target offset)
949
+ var left = targetPos.left + targetOffset.left - offset.left;
950
+ var top = targetPos.top + targetOffset.top - offset.top;
951
+
952
+ for (var i = 0; i < TetherBase.modules.length; ++i) {
953
+ var _module2 = TetherBase.modules[i];
954
+ var ret = _module2.position.call(this, {
955
+ left: left,
956
+ top: top,
957
+ targetAttachment: targetAttachment,
958
+ targetPos: targetPos,
959
+ elementPos: elementPos,
960
+ offset: offset,
961
+ targetOffset: targetOffset,
962
+ manualOffset: manualOffset,
963
+ manualTargetOffset: manualTargetOffset,
964
+ scrollbarSize: scrollbarSize,
965
+ attachment: this.attachment
966
+ });
967
+
968
+ if (ret === false) {
969
+ return false;
970
+ } else if (typeof ret === 'undefined' || typeof ret !== 'object') {
971
+ continue;
972
+ } else {
973
+ top = ret.top;
974
+ left = ret.left;
975
+ }
976
+ }
977
+
978
+ // We describe the position three different ways to give the optimizer
979
+ // a chance to decide the best possible way to position the element
980
+ // with the fewest repaints.
981
+ var next = {
982
+ // It's position relative to the page (absolute positioning when
983
+ // the element is a child of the body)
984
+ page: {
985
+ top: top,
986
+ left: left
987
+ },
988
+
989
+ // It's position relative to the viewport (fixed positioning)
990
+ viewport: {
991
+ top: top - pageYOffset,
992
+ bottom: pageYOffset - top - height + innerHeight,
993
+ left: left - pageXOffset,
994
+ right: pageXOffset - left - width + innerWidth
995
+ }
996
+ };
997
+
998
+ var scrollbarSize = undefined;
999
+ if (document.body.scrollWidth > window.innerWidth) {
1000
+ scrollbarSize = this.cache('scrollbar-size', getScrollBarSize);
1001
+ next.viewport.bottom -= scrollbarSize.height;
1002
+ }
1003
+
1004
+ if (document.body.scrollHeight > window.innerHeight) {
1005
+ scrollbarSize = this.cache('scrollbar-size', getScrollBarSize);
1006
+ next.viewport.right -= scrollbarSize.width;
1007
+ }
1008
+
1009
+ if (['', 'static'].indexOf(document.body.style.position) === -1 || ['', 'static'].indexOf(document.body.parentElement.style.position) === -1) {
1010
+ // Absolute positioning in the body will be relative to the page, not the 'initial containing block'
1011
+ next.page.bottom = document.body.scrollHeight - top - height;
1012
+ next.page.right = document.body.scrollWidth - left - width;
1013
+ }
1014
+
1015
+ if (typeof this.options.optimizations !== 'undefined' && this.options.optimizations.moveElement !== false && !(typeof this.targetModifier !== 'undefined')) {
1016
+ (function () {
1017
+ var offsetParent = _this5.cache('target-offsetparent', function () {
1018
+ return getOffsetParent(_this5.target);
1019
+ });
1020
+ var offsetPosition = _this5.cache('target-offsetparent-bounds', function () {
1021
+ return getBounds(offsetParent);
1022
+ });
1023
+ var offsetParentStyle = getComputedStyle(offsetParent);
1024
+ var offsetParentSize = offsetPosition;
1025
+
1026
+ var offsetBorder = {};
1027
+ ['Top', 'Left', 'Bottom', 'Right'].forEach(function (side) {
1028
+ offsetBorder[side.toLowerCase()] = parseFloat(offsetParentStyle['border' + side + 'Width']);
1029
+ });
1030
+
1031
+ offsetPosition.right = document.body.scrollWidth - offsetPosition.left - offsetParentSize.width + offsetBorder.right;
1032
+ offsetPosition.bottom = document.body.scrollHeight - offsetPosition.top - offsetParentSize.height + offsetBorder.bottom;
1033
+
1034
+ if (next.page.top >= offsetPosition.top + offsetBorder.top && next.page.bottom >= offsetPosition.bottom) {
1035
+ if (next.page.left >= offsetPosition.left + offsetBorder.left && next.page.right >= offsetPosition.right) {
1036
+ // We're within the visible part of the target's scroll parent
1037
+ var scrollTop = offsetParent.scrollTop;
1038
+ var scrollLeft = offsetParent.scrollLeft;
1039
+
1040
+ // It's position relative to the target's offset parent (absolute positioning when
1041
+ // the element is moved to be a child of the target's offset parent).
1042
+ next.offset = {
1043
+ top: next.page.top - offsetPosition.top + scrollTop - offsetBorder.top,
1044
+ left: next.page.left - offsetPosition.left + scrollLeft - offsetBorder.left
1045
+ };
1046
+ }
1047
+ }
1048
+ })();
1049
+ }
1050
+
1051
+ // We could also travel up the DOM and try each containing context, rather than only
1052
+ // looking at the body, but we're gonna get diminishing returns.
1053
+
1054
+ this.move(next);
1055
+
1056
+ this.history.unshift(next);
1057
+
1058
+ if (this.history.length > 3) {
1059
+ this.history.pop();
1060
+ }
1061
+
1062
+ if (flushChanges) {
1063
+ flush();
1064
+ }
1065
+
1066
+ return true;
1067
+ }
1068
+
1069
+ // THE ISSUE
1070
+ }, {
1071
+ key: 'move',
1072
+ value: function move(pos) {
1073
+ var _this6 = this;
1074
+
1075
+ if (!(typeof this.element.parentNode !== 'undefined')) {
1076
+ return;
1077
+ }
1078
+
1079
+ var same = {};
1080
+
1081
+ for (var type in pos) {
1082
+ same[type] = {};
1083
+
1084
+ for (var key in pos[type]) {
1085
+ var found = false;
1086
+
1087
+ for (var i = 0; i < this.history.length; ++i) {
1088
+ var point = this.history[i];
1089
+ if (typeof point[type] !== 'undefined' && !within(point[type][key], pos[type][key])) {
1090
+ found = true;
1091
+ break;
1092
+ }
1093
+ }
1094
+
1095
+ if (!found) {
1096
+ same[type][key] = true;
1097
+ }
1098
+ }
1099
+ }
1100
+
1101
+ var css = { top: '', left: '', right: '', bottom: '' };
1102
+
1103
+ var transcribe = function transcribe(_same, _pos) {
1104
+ var hasOptimizations = typeof _this6.options.optimizations !== 'undefined';
1105
+ var gpu = hasOptimizations ? _this6.options.optimizations.gpu : null;
1106
+ if (gpu !== false) {
1107
+ var yPos = undefined,
1108
+ xPos = undefined;
1109
+ if (_same.top) {
1110
+ css.top = 0;
1111
+ yPos = _pos.top;
1112
+ } else {
1113
+ css.bottom = 0;
1114
+ yPos = -_pos.bottom;
1115
+ }
1116
+
1117
+ if (_same.left) {
1118
+ css.left = 0;
1119
+ xPos = _pos.left;
1120
+ } else {
1121
+ css.right = 0;
1122
+ xPos = -_pos.right;
1123
+ }
1124
+
1125
+ css[transformKey] = 'translateX(' + Math.round(xPos) + 'px) translateY(' + Math.round(yPos) + 'px)';
1126
+
1127
+ if (transformKey !== 'msTransform') {
1128
+ // The Z transform will keep this in the GPU (faster, and prevents artifacts),
1129
+ // but IE9 doesn't support 3d transforms and will choke.
1130
+ css[transformKey] += " translateZ(0)";
1131
+ }
1132
+ } else {
1133
+ if (_same.top) {
1134
+ css.top = _pos.top + 'px';
1135
+ } else {
1136
+ css.bottom = _pos.bottom + 'px';
1137
+ }
1138
+
1139
+ if (_same.left) {
1140
+ css.left = _pos.left + 'px';
1141
+ } else {
1142
+ css.right = _pos.right + 'px';
1143
+ }
1144
+ }
1145
+ };
1146
+
1147
+ var moved = false;
1148
+ if ((same.page.top || same.page.bottom) && (same.page.left || same.page.right)) {
1149
+ css.position = 'absolute';
1150
+ transcribe(same.page, pos.page);
1151
+ } else if ((same.viewport.top || same.viewport.bottom) && (same.viewport.left || same.viewport.right)) {
1152
+ css.position = 'fixed';
1153
+ transcribe(same.viewport, pos.viewport);
1154
+ } else if (typeof same.offset !== 'undefined' && same.offset.top && same.offset.left) {
1155
+ (function () {
1156
+ css.position = 'absolute';
1157
+ var offsetParent = _this6.cache('target-offsetparent', function () {
1158
+ return getOffsetParent(_this6.target);
1159
+ });
1160
+
1161
+ if (getOffsetParent(_this6.element) !== offsetParent) {
1162
+ defer(function () {
1163
+ _this6.element.parentNode.removeChild(_this6.element);
1164
+ offsetParent.appendChild(_this6.element);
1165
+ });
1166
+ }
1167
+
1168
+ transcribe(same.offset, pos.offset);
1169
+ moved = true;
1170
+ })();
1171
+ } else {
1172
+ css.position = 'absolute';
1173
+ transcribe({ top: true, left: true }, pos.page);
1174
+ }
1175
+
1176
+ if (!moved) {
1177
+ var offsetParentIsBody = true;
1178
+ var currentNode = this.element.parentNode;
1179
+ while (currentNode && currentNode.tagName !== 'BODY') {
1180
+ if (getComputedStyle(currentNode).position !== 'static') {
1181
+ offsetParentIsBody = false;
1182
+ break;
1183
+ }
1184
+
1185
+ currentNode = currentNode.parentNode;
1186
+ }
1187
+
1188
+ if (!offsetParentIsBody) {
1189
+ this.element.parentNode.removeChild(this.element);
1190
+ document.body.appendChild(this.element);
1191
+ }
1192
+ }
1193
+
1194
+ // Any css change will trigger a repaint, so let's avoid one if nothing changed
1195
+ var writeCSS = {};
1196
+ var write = false;
1197
+ for (var key in css) {
1198
+ var val = css[key];
1199
+ var elVal = this.element.style[key];
1200
+
1201
+ if (elVal !== '' && val !== '' && ['top', 'left', 'bottom', 'right'].indexOf(key) >= 0) {
1202
+ elVal = parseFloat(elVal);
1203
+ val = parseFloat(val);
1204
+ }
1205
+
1206
+ if (elVal !== val) {
1207
+ write = true;
1208
+ writeCSS[key] = val;
1209
+ }
1210
+ }
1211
+
1212
+ if (write) {
1213
+ defer(function () {
1214
+ extend(_this6.element.style, writeCSS);
1215
+ });
1216
+ }
1217
+ }
1218
+ }]);
1219
+
1220
+ return TetherClass;
1221
+ })();
1222
+
1223
+ TetherClass.modules = [];
1224
+
1225
+ TetherBase.position = position;
1226
+
1227
+ var Tether = extend(TetherClass, TetherBase);
1228
+ /* globals TetherBase */
1229
+
1230
+ 'use strict';
1231
+
1232
+ 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 && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } 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('Invalid attempt to destructure non-iterable instance'); } }; })();
1233
+
1234
+ var _TetherBase$Utils = TetherBase.Utils;
1235
+ var getBounds = _TetherBase$Utils.getBounds;
1236
+ var extend = _TetherBase$Utils.extend;
1237
+ var updateClasses = _TetherBase$Utils.updateClasses;
1238
+ var defer = _TetherBase$Utils.defer;
1239
+
1240
+ var BOUNDS_FORMAT = ['left', 'top', 'right', 'bottom'];
1241
+
1242
+ function getBoundingRect(tether, to) {
1243
+ if (to === 'scrollParent') {
1244
+ to = tether.scrollParent;
1245
+ } else if (to === 'window') {
1246
+ to = [pageXOffset, pageYOffset, innerWidth + pageXOffset, innerHeight + pageYOffset];
1247
+ }
1248
+
1249
+ if (to === document) {
1250
+ to = to.documentElement;
1251
+ }
1252
+
1253
+ if (typeof to.nodeType !== 'undefined') {
1254
+ (function () {
1255
+ var size = getBounds(to);
1256
+ var pos = size;
1257
+ var style = getComputedStyle(to);
1258
+
1259
+ to = [pos.left, pos.top, size.width + pos.left, size.height + pos.top];
1260
+
1261
+ BOUNDS_FORMAT.forEach(function (side, i) {
1262
+ side = side[0].toUpperCase() + side.substr(1);
1263
+ if (side === 'Top' || side === 'Left') {
1264
+ to[i] += parseFloat(style['border' + side + 'Width']);
1265
+ } else {
1266
+ to[i] -= parseFloat(style['border' + side + 'Width']);
1267
+ }
1268
+ });
1269
+ })();
1270
+ }
1271
+
1272
+ return to;
1273
+ }
1274
+
1275
+ TetherBase.modules.push({
1276
+ position: function position(_ref) {
1277
+ var _this = this;
1278
+
1279
+ var top = _ref.top;
1280
+ var left = _ref.left;
1281
+ var targetAttachment = _ref.targetAttachment;
1282
+
1283
+ if (!this.options.constraints) {
1284
+ return true;
1285
+ }
1286
+
1287
+ var _cache = this.cache('element-bounds', function () {
1288
+ return getBounds(_this.element);
1289
+ });
1290
+
1291
+ var height = _cache.height;
1292
+ var width = _cache.width;
1293
+
1294
+ if (width === 0 && height === 0 && typeof this.lastSize !== 'undefined') {
1295
+ var _lastSize = this.lastSize;
1296
+
1297
+ // Handle the item getting hidden as a result of our positioning without glitching
1298
+ // the classes in and out
1299
+ width = _lastSize.width;
1300
+ height = _lastSize.height;
1301
+ }
1302
+
1303
+ var targetSize = this.cache('target-bounds', function () {
1304
+ return _this.getTargetBounds();
1305
+ });
1306
+
1307
+ var targetHeight = targetSize.height;
1308
+ var targetWidth = targetSize.width;
1309
+
1310
+ var allClasses = [this.getClass('pinned'), this.getClass('out-of-bounds')];
1311
+
1312
+ this.options.constraints.forEach(function (constraint) {
1313
+ var outOfBoundsClass = constraint.outOfBoundsClass;
1314
+ var pinnedClass = constraint.pinnedClass;
1315
+
1316
+ if (outOfBoundsClass) {
1317
+ allClasses.push(outOfBoundsClass);
1318
+ }
1319
+ if (pinnedClass) {
1320
+ allClasses.push(pinnedClass);
1321
+ }
1322
+ });
1323
+
1324
+ allClasses.forEach(function (cls) {
1325
+ ['left', 'top', 'right', 'bottom'].forEach(function (side) {
1326
+ allClasses.push(cls + '-' + side);
1327
+ });
1328
+ });
1329
+
1330
+ var addClasses = [];
1331
+
1332
+ var tAttachment = extend({}, targetAttachment);
1333
+ var eAttachment = extend({}, this.attachment);
1334
+
1335
+ this.options.constraints.forEach(function (constraint) {
1336
+ var to = constraint.to;
1337
+ var attachment = constraint.attachment;
1338
+ var pin = constraint.pin;
1339
+
1340
+ if (typeof attachment === 'undefined') {
1341
+ attachment = '';
1342
+ }
1343
+
1344
+ var changeAttachX = undefined,
1345
+ changeAttachY = undefined;
1346
+ if (attachment.indexOf(' ') >= 0) {
1347
+ var _attachment$split = attachment.split(' ');
1348
+
1349
+ var _attachment$split2 = _slicedToArray(_attachment$split, 2);
1350
+
1351
+ changeAttachY = _attachment$split2[0];
1352
+ changeAttachX = _attachment$split2[1];
1353
+ } else {
1354
+ changeAttachX = changeAttachY = attachment;
1355
+ }
1356
+
1357
+ var bounds = getBoundingRect(_this, to);
1358
+
1359
+ if (changeAttachY === 'target' || changeAttachY === 'both') {
1360
+ if (top < bounds[1] && tAttachment.top === 'top') {
1361
+ top += targetHeight;
1362
+ tAttachment.top = 'bottom';
1363
+ }
1364
+
1365
+ if (top + height > bounds[3] && tAttachment.top === 'bottom') {
1366
+ top -= targetHeight;
1367
+ tAttachment.top = 'top';
1368
+ }
1369
+ }
1370
+
1371
+ if (changeAttachY === 'together') {
1372
+ if (top < bounds[1] && tAttachment.top === 'top') {
1373
+ if (eAttachment.top === 'bottom') {
1374
+ top += targetHeight;
1375
+ tAttachment.top = 'bottom';
1376
+
1377
+ top += height;
1378
+ eAttachment.top = 'top';
1379
+ } else if (eAttachment.top === 'top') {
1380
+ top += targetHeight;
1381
+ tAttachment.top = 'bottom';
1382
+
1383
+ top -= height;
1384
+ eAttachment.top = 'bottom';
1385
+ }
1386
+ }
1387
+
1388
+ if (top + height > bounds[3] && tAttachment.top === 'bottom') {
1389
+ if (eAttachment.top === 'top') {
1390
+ top -= targetHeight;
1391
+ tAttachment.top = 'top';
1392
+
1393
+ top -= height;
1394
+ eAttachment.top = 'bottom';
1395
+ } else if (eAttachment.top === 'bottom') {
1396
+ top -= targetHeight;
1397
+ tAttachment.top = 'top';
1398
+
1399
+ top += height;
1400
+ eAttachment.top = 'top';
1401
+ }
1402
+ }
1403
+
1404
+ if (tAttachment.top === 'middle') {
1405
+ if (top + height > bounds[3] && eAttachment.top === 'top') {
1406
+ top -= height;
1407
+ eAttachment.top = 'bottom';
1408
+ } else if (top < bounds[1] && eAttachment.top === 'bottom') {
1409
+ top += height;
1410
+ eAttachment.top = 'top';
1411
+ }
1412
+ }
1413
+ }
1414
+
1415
+ if (changeAttachX === 'target' || changeAttachX === 'both') {
1416
+ if (left < bounds[0] && tAttachment.left === 'left') {
1417
+ left += targetWidth;
1418
+ tAttachment.left = 'right';
1419
+ }
1420
+
1421
+ if (left + width > bounds[2] && tAttachment.left === 'right') {
1422
+ left -= targetWidth;
1423
+ tAttachment.left = 'left';
1424
+ }
1425
+ }
1426
+
1427
+ if (changeAttachX === 'together') {
1428
+ if (left < bounds[0] && tAttachment.left === 'left') {
1429
+ if (eAttachment.left === 'right') {
1430
+ left += targetWidth;
1431
+ tAttachment.left = 'right';
1432
+
1433
+ left += width;
1434
+ eAttachment.left = 'left';
1435
+ } else if (eAttachment.left === 'left') {
1436
+ left += targetWidth;
1437
+ tAttachment.left = 'right';
1438
+
1439
+ left -= width;
1440
+ eAttachment.left = 'right';
1441
+ }
1442
+ } else if (left + width > bounds[2] && tAttachment.left === 'right') {
1443
+ if (eAttachment.left === 'left') {
1444
+ left -= targetWidth;
1445
+ tAttachment.left = 'left';
1446
+
1447
+ left -= width;
1448
+ eAttachment.left = 'right';
1449
+ } else if (eAttachment.left === 'right') {
1450
+ left -= targetWidth;
1451
+ tAttachment.left = 'left';
1452
+
1453
+ left += width;
1454
+ eAttachment.left = 'left';
1455
+ }
1456
+ } else if (tAttachment.left === 'center') {
1457
+ if (left + width > bounds[2] && eAttachment.left === 'left') {
1458
+ left -= width;
1459
+ eAttachment.left = 'right';
1460
+ } else if (left < bounds[0] && eAttachment.left === 'right') {
1461
+ left += width;
1462
+ eAttachment.left = 'left';
1463
+ }
1464
+ }
1465
+ }
1466
+
1467
+ if (changeAttachY === 'element' || changeAttachY === 'both') {
1468
+ if (top < bounds[1] && eAttachment.top === 'bottom') {
1469
+ top += height;
1470
+ eAttachment.top = 'top';
1471
+ }
1472
+
1473
+ if (top + height > bounds[3] && eAttachment.top === 'top') {
1474
+ top -= height;
1475
+ eAttachment.top = 'bottom';
1476
+ }
1477
+ }
1478
+
1479
+ if (changeAttachX === 'element' || changeAttachX === 'both') {
1480
+ if (left < bounds[0]) {
1481
+ if (eAttachment.left === 'right') {
1482
+ left += width;
1483
+ eAttachment.left = 'left';
1484
+ } else if (eAttachment.left === 'center') {
1485
+ left += width / 2;
1486
+ eAttachment.left = 'left';
1487
+ }
1488
+ }
1489
+
1490
+ if (left + width > bounds[2]) {
1491
+ if (eAttachment.left === 'left') {
1492
+ left -= width;
1493
+ eAttachment.left = 'right';
1494
+ } else if (eAttachment.left === 'center') {
1495
+ left -= width / 2;
1496
+ eAttachment.left = 'right';
1497
+ }
1498
+ }
1499
+ }
1500
+
1501
+ if (typeof pin === 'string') {
1502
+ pin = pin.split(',').map(function (p) {
1503
+ return p.trim();
1504
+ });
1505
+ } else if (pin === true) {
1506
+ pin = ['top', 'left', 'right', 'bottom'];
1507
+ }
1508
+
1509
+ pin = pin || [];
1510
+
1511
+ var pinned = [];
1512
+ var oob = [];
1513
+
1514
+ if (top < bounds[1]) {
1515
+ if (pin.indexOf('top') >= 0) {
1516
+ top = bounds[1];
1517
+ pinned.push('top');
1518
+ } else {
1519
+ oob.push('top');
1520
+ }
1521
+ }
1522
+
1523
+ if (top + height > bounds[3]) {
1524
+ if (pin.indexOf('bottom') >= 0) {
1525
+ top = bounds[3] - height;
1526
+ pinned.push('bottom');
1527
+ } else {
1528
+ oob.push('bottom');
1529
+ }
1530
+ }
1531
+
1532
+ if (left < bounds[0]) {
1533
+ if (pin.indexOf('left') >= 0) {
1534
+ left = bounds[0];
1535
+ pinned.push('left');
1536
+ } else {
1537
+ oob.push('left');
1538
+ }
1539
+ }
1540
+
1541
+ if (left + width > bounds[2]) {
1542
+ if (pin.indexOf('right') >= 0) {
1543
+ left = bounds[2] - width;
1544
+ pinned.push('right');
1545
+ } else {
1546
+ oob.push('right');
1547
+ }
1548
+ }
1549
+
1550
+ if (pinned.length) {
1551
+ (function () {
1552
+ var pinnedClass = undefined;
1553
+ if (typeof _this.options.pinnedClass !== 'undefined') {
1554
+ pinnedClass = _this.options.pinnedClass;
1555
+ } else {
1556
+ pinnedClass = _this.getClass('pinned');
1557
+ }
1558
+
1559
+ addClasses.push(pinnedClass);
1560
+ pinned.forEach(function (side) {
1561
+ addClasses.push(pinnedClass + '-' + side);
1562
+ });
1563
+ })();
1564
+ }
1565
+
1566
+ if (oob.length) {
1567
+ (function () {
1568
+ var oobClass = undefined;
1569
+ if (typeof _this.options.outOfBoundsClass !== 'undefined') {
1570
+ oobClass = _this.options.outOfBoundsClass;
1571
+ } else {
1572
+ oobClass = _this.getClass('out-of-bounds');
1573
+ }
1574
+
1575
+ addClasses.push(oobClass);
1576
+ oob.forEach(function (side) {
1577
+ addClasses.push(oobClass + '-' + side);
1578
+ });
1579
+ })();
1580
+ }
1581
+
1582
+ if (pinned.indexOf('left') >= 0 || pinned.indexOf('right') >= 0) {
1583
+ eAttachment.left = tAttachment.left = false;
1584
+ }
1585
+ if (pinned.indexOf('top') >= 0 || pinned.indexOf('bottom') >= 0) {
1586
+ eAttachment.top = tAttachment.top = false;
1587
+ }
1588
+
1589
+ if (tAttachment.top !== targetAttachment.top || tAttachment.left !== targetAttachment.left || eAttachment.top !== _this.attachment.top || eAttachment.left !== _this.attachment.left) {
1590
+ _this.updateAttachClasses(eAttachment, tAttachment);
1591
+ }
1592
+ });
1593
+
1594
+ defer(function () {
1595
+ if (!(_this.options.addTargetClasses === false)) {
1596
+ updateClasses(_this.target, addClasses, allClasses);
1597
+ }
1598
+ updateClasses(_this.element, addClasses, allClasses);
1599
+ });
1600
+
1601
+ return { top: top, left: left };
1602
+ }
1603
+ });
1604
+ /* globals TetherBase */
1605
+
1606
+ 'use strict';
1607
+
1608
+ var _TetherBase$Utils = TetherBase.Utils;
1609
+ var getBounds = _TetherBase$Utils.getBounds;
1610
+ var updateClasses = _TetherBase$Utils.updateClasses;
1611
+ var defer = _TetherBase$Utils.defer;
1612
+
1613
+ TetherBase.modules.push({
1614
+ position: function position(_ref) {
1615
+ var _this = this;
1616
+
1617
+ var top = _ref.top;
1618
+ var left = _ref.left;
1619
+
1620
+ var _cache = this.cache('element-bounds', function () {
1621
+ return getBounds(_this.element);
1622
+ });
1623
+
1624
+ var height = _cache.height;
1625
+ var width = _cache.width;
1626
+
1627
+ var targetPos = this.getTargetBounds();
1628
+
1629
+ var bottom = top + height;
1630
+ var right = left + width;
1631
+
1632
+ var abutted = [];
1633
+ if (top <= targetPos.bottom && bottom >= targetPos.top) {
1634
+ ['left', 'right'].forEach(function (side) {
1635
+ var targetPosSide = targetPos[side];
1636
+ if (targetPosSide === left || targetPosSide === right) {
1637
+ abutted.push(side);
1638
+ }
1639
+ });
1640
+ }
1641
+
1642
+ if (left <= targetPos.right && right >= targetPos.left) {
1643
+ ['top', 'bottom'].forEach(function (side) {
1644
+ var targetPosSide = targetPos[side];
1645
+ if (targetPosSide === top || targetPosSide === bottom) {
1646
+ abutted.push(side);
1647
+ }
1648
+ });
1649
+ }
1650
+
1651
+ var allClasses = [];
1652
+ var addClasses = [];
1653
+
1654
+ var sides = ['left', 'top', 'right', 'bottom'];
1655
+ allClasses.push(this.getClass('abutted'));
1656
+ sides.forEach(function (side) {
1657
+ allClasses.push(_this.getClass('abutted') + '-' + side);
1658
+ });
1659
+
1660
+ if (abutted.length) {
1661
+ addClasses.push(this.getClass('abutted'));
1662
+ }
1663
+
1664
+ abutted.forEach(function (side) {
1665
+ addClasses.push(_this.getClass('abutted') + '-' + side);
1666
+ });
1667
+
1668
+ defer(function () {
1669
+ if (!(_this.options.addTargetClasses === false)) {
1670
+ updateClasses(_this.target, addClasses, allClasses);
1671
+ }
1672
+ updateClasses(_this.element, addClasses, allClasses);
1673
+ });
1674
+
1675
+ return true;
1676
+ }
1677
+ });
1678
+ /* globals TetherBase */
1679
+
1680
+ 'use strict';
1681
+
1682
+ 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 && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } 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('Invalid attempt to destructure non-iterable instance'); } }; })();
1683
+
1684
+ TetherBase.modules.push({
1685
+ position: function position(_ref) {
1686
+ var top = _ref.top;
1687
+ var left = _ref.left;
1688
+
1689
+ if (!this.options.shift) {
1690
+ return;
1691
+ }
1692
+
1693
+ var shift = this.options.shift;
1694
+ if (typeof this.options.shift === 'function') {
1695
+ shift = this.options.shift.call(this, { top: top, left: left });
1696
+ }
1697
+
1698
+ var shiftTop = undefined,
1699
+ shiftLeft = undefined;
1700
+ if (typeof shift === 'string') {
1701
+ shift = shift.split(' ');
1702
+ shift[1] = shift[1] || shift[0];
1703
+
1704
+ var _shift = shift;
1705
+
1706
+ var _shift2 = _slicedToArray(_shift, 2);
1707
+
1708
+ shiftTop = _shift2[0];
1709
+ shiftLeft = _shift2[1];
1710
+
1711
+ shiftTop = parseFloat(shiftTop, 10);
1712
+ shiftLeft = parseFloat(shiftLeft, 10);
1713
+ } else {
1714
+ shiftTop = shift.top;
1715
+ shiftLeft = shift.left;
1716
+ }
1717
+
1718
+ top += shiftTop;
1719
+ left += shiftLeft;
1720
+
1721
+ return { top: top, left: left };
1722
+ }
1723
+ });
1724
+ return Tether;
1725
+
1726
+ }));