sql-jarvis 2.1 → 2.1.5

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: c6ac3baeeb351f06d68988d5f2828002dcbc4edb6c07fb841bf2c316655398f4
4
- data.tar.gz: 9d898978f1b770f769393cb2db0e6803392a15a9df23e5318a76263f77701b7f
3
+ metadata.gz: bd81a249e949ad7c6fe925701c4221f5d7466aa1a3503b2f3444ceda82282e2f
4
+ data.tar.gz: aa56786392647652e110c5405f5aa67660f29fa822da7c7f09df88fdeacad836
5
5
  SHA512:
6
- metadata.gz: 56535c70ff300b1d818abf4d868002b00aec750ca5b569a0774d8944892599a4335d728f8115bd6d543029cc774e4337a0d9d1272f7733ba4000b02a261d1617
7
- data.tar.gz: 5e7af8d4b27e85f9e14a2e502a6d72657499717cc981a9edec88c60732a662d84af73a8a6830eed0da5f8b938b58081163f0a2fdd8f8b3ce0a74f1ca190fe97c
6
+ metadata.gz: d4c04a6cda8473b157f6605bd2187ef52383e8d2cfb9661f657095bbc22e9653c7570302b756a932d165970f11b466c811244560ccc2eb5355da5dc01606dcff
7
+ data.tar.gz: 66d479f3aada4eae9e7656e030b805aefb9ed14fb2b04445793899c084a381e39917dcad6ac725ffb012acd1bdaccc1c8c4ea6a418924396224a0dc26b8ce83f
@@ -5,1536 +5,1536 @@
5
5
  */
6
6
 
7
7
  (function sortableModule(factory) {
8
- "use strict";
9
-
10
- if (typeof define === "function" && define.amd) {
11
- define(factory);
12
- }
13
- else if (typeof module != "undefined" && typeof module.exports != "undefined") {
14
- module.exports = factory();
15
- }
16
- else {
17
- /* jshint sub:true */
18
- window["Sortable"] = factory();
19
- }
8
+ "use strict";
9
+
10
+ if (typeof define === "function" && define.amd) {
11
+ define(factory);
12
+ }
13
+ else if (typeof module != "undefined" && typeof module.exports != "undefined") {
14
+ module.exports = factory();
15
+ }
16
+ else {
17
+ /* jshint sub:true */
18
+ window["Sortable"] = factory();
19
+ }
20
20
  })(function sortableFactory() {
21
- "use strict";
21
+ "use strict";
22
22
 
23
- if (typeof window === "undefined" || !window.document) {
24
- return function sortableError() {
25
- throw new Error("Sortable.js requires a window with a document");
26
- };
27
- }
28
-
29
- var dragEl,
30
- parentEl,
31
- ghostEl,
32
- cloneEl,
33
- rootEl,
34
- nextEl,
35
- lastDownEl,
36
-
37
- scrollEl,
38
- scrollParentEl,
39
- scrollCustomFn,
40
-
41
- lastEl,
42
- lastCSS,
43
- lastParentCSS,
44
-
45
- oldIndex,
46
- newIndex,
47
-
48
- activeGroup,
49
- putSortable,
50
-
51
- autoScroll = {},
52
-
53
- tapEvt,
54
- touchEvt,
55
-
56
- moved,
57
-
58
- /** @const */
59
- R_SPACE = /\s+/g,
60
- R_FLOAT = /left|right|inline/,
61
-
62
- expando = 'Sortable' + (new Date).getTime(),
63
-
64
- win = window,
65
- document = win.document,
66
- parseInt = win.parseInt,
67
- setTimeout = win.setTimeout,
68
-
69
- $ = win.jQuery || win.Zepto,
70
- Polymer = win.Polymer,
71
-
72
- captureMode = false,
73
- passiveMode = false,
74
-
75
- supportDraggable = ('draggable' in document.createElement('div')),
76
- supportCssPointerEvents = (function (el) {
77
- // false when IE11
78
- if (!!navigator.userAgent.match(/(?:Trident.*rv[ :]?11\.|msie)/i)) {
79
- return false;
80
- }
81
- el = document.createElement('x');
82
- el.style.cssText = 'pointer-events:auto';
83
- return el.style.pointerEvents === 'auto';
84
- })(),
85
-
86
- _silent = false,
87
-
88
- abs = Math.abs,
89
- min = Math.min,
90
-
91
- savedInputChecked = [],
92
- touchDragOverListeners = [],
93
-
94
- _autoScroll = _throttle(function (/**Event*/evt, /**Object*/options, /**HTMLElement*/rootEl) {
95
- // Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
96
- if (rootEl && options.scroll) {
97
- var _this = rootEl[expando],
98
- el,
99
- rect,
100
- sens = options.scrollSensitivity,
101
- speed = options.scrollSpeed,
102
-
103
- x = evt.clientX,
104
- y = evt.clientY,
105
-
106
- winWidth = window.innerWidth,
107
- winHeight = window.innerHeight,
108
-
109
- vx,
110
- vy,
111
-
112
- scrollOffsetX,
113
- scrollOffsetY
114
- ;
115
-
116
- // Delect scrollEl
117
- if (scrollParentEl !== rootEl) {
118
- scrollEl = options.scroll;
119
- scrollParentEl = rootEl;
120
- scrollCustomFn = options.scrollFn;
121
-
122
- if (scrollEl === true) {
123
- scrollEl = rootEl;
124
-
125
- do {
126
- if ((scrollEl.offsetWidth < scrollEl.scrollWidth) ||
127
- (scrollEl.offsetHeight < scrollEl.scrollHeight)
128
- ) {
129
- break;
130
- }
131
- /* jshint boss:true */
132
- } while (scrollEl = scrollEl.parentNode);
133
- }
134
- }
135
-
136
- if (scrollEl) {
137
- el = scrollEl;
138
- rect = scrollEl.getBoundingClientRect();
139
- vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
140
- vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens);
141
- }
142
-
143
-
144
- if (!(vx || vy)) {
145
- vx = (winWidth - x <= sens) - (x <= sens);
146
- vy = (winHeight - y <= sens) - (y <= sens);
147
-
148
- /* jshint expr:true */
149
- (vx || vy) && (el = win);
150
- }
151
-
152
-
153
- if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
154
- autoScroll.el = el;
155
- autoScroll.vx = vx;
156
- autoScroll.vy = vy;
157
-
158
- clearInterval(autoScroll.pid);
159
-
160
- if (el) {
161
- autoScroll.pid = setInterval(function () {
162
- scrollOffsetY = vy ? vy * speed : 0;
163
- scrollOffsetX = vx ? vx * speed : 0;
164
-
165
- if ('function' === typeof(scrollCustomFn)) {
166
- return scrollCustomFn.call(_this, scrollOffsetX, scrollOffsetY, evt);
167
- }
168
-
169
- if (el === win) {
170
- win.scrollTo(win.pageXOffset + scrollOffsetX, win.pageYOffset + scrollOffsetY);
171
- } else {
172
- el.scrollTop += scrollOffsetY;
173
- el.scrollLeft += scrollOffsetX;
174
- }
175
- }, 24);
176
- }
177
- }
178
- }
179
- }, 30),
180
-
181
- _prepareGroup = function (options) {
182
- function toFn(value, pull) {
183
- if (value === void 0 || value === true) {
184
- value = group.name;
185
- }
186
-
187
- if (typeof value === 'function') {
188
- return value;
189
- } else {
190
- return function (to, from) {
191
- var fromGroup = from.options.group.name;
192
-
193
- return pull
194
- ? value
195
- : value && (value.join
196
- ? value.indexOf(fromGroup) > -1
197
- : (fromGroup == value)
198
- );
199
- };
200
- }
201
- }
202
-
203
- var group = {};
204
- var originalGroup = options.group;
205
-
206
- if (!originalGroup || typeof originalGroup != 'object') {
207
- originalGroup = {name: originalGroup};
208
- }
209
-
210
- group.name = originalGroup.name;
211
- group.checkPull = toFn(originalGroup.pull, true);
212
- group.checkPut = toFn(originalGroup.put);
213
- group.revertClone = originalGroup.revertClone;
214
-
215
- options.group = group;
216
- }
217
- ;
218
-
219
- // Detect support a passive mode
220
- try {
221
- window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
222
- get: function () {
223
- // `false`, because everything starts to work incorrectly and instead of d'n'd,
224
- // begins the page has scrolled.
225
- passiveMode = false;
226
- captureMode = {
227
- capture: false,
228
- passive: passiveMode
229
- };
230
- }
231
- }));
232
- } catch (err) {}
233
-
234
- /**
235
- * @class Sortable
236
- * @param {HTMLElement} el
237
- * @param {Object} [options]
238
- */
239
- function Sortable(el, options) {
240
- if (!(el && el.nodeType && el.nodeType === 1)) {
241
- throw 'Sortable: `el` must be HTMLElement, and not ' + {}.toString.call(el);
242
- }
243
-
244
- this.el = el; // root element
245
- this.options = options = _extend({}, options);
246
-
247
-
248
- // Export instance
249
- el[expando] = this;
250
-
251
- // Default options
252
- var defaults = {
253
- group: Math.random(),
254
- sort: true,
255
- disabled: false,
256
- store: null,
257
- handle: null,
258
- scroll: true,
259
- scrollSensitivity: 30,
260
- scrollSpeed: 10,
261
- draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
262
- ghostClass: 'sortable-ghost',
263
- chosenClass: 'sortable-chosen',
264
- dragClass: 'sortable-drag',
265
- ignore: 'a, img',
266
- filter: null,
267
- preventOnFilter: true,
268
- animation: 0,
269
- setData: function (dataTransfer, dragEl) {
270
- dataTransfer.setData('Text', dragEl.textContent);
271
- },
272
- dropBubble: false,
273
- dragoverBubble: false,
274
- dataIdAttr: 'data-id',
275
- delay: 0,
276
- forceFallback: false,
277
- fallbackClass: 'sortable-fallback',
278
- fallbackOnBody: false,
279
- fallbackTolerance: 0,
280
- fallbackOffset: {x: 0, y: 0},
281
- supportPointer: Sortable.supportPointer !== false
282
- };
283
-
284
-
285
- // Set default options
286
- for (var name in defaults) {
287
- !(name in options) && (options[name] = defaults[name]);
288
- }
289
-
290
- _prepareGroup(options);
291
-
292
- // Bind all private methods
293
- for (var fn in this) {
294
- if (fn.charAt(0) === '_' && typeof this[fn] === 'function') {
295
- this[fn] = this[fn].bind(this);
296
- }
297
- }
298
-
299
- // Setup drag mode
300
- this.nativeDraggable = options.forceFallback ? false : supportDraggable;
301
-
302
- // Bind events
303
- _on(el, 'mousedown', this._onTapStart);
304
- _on(el, 'touchstart', this._onTapStart);
305
- options.supportPointer && _on(el, 'pointerdown', this._onTapStart);
306
-
307
- if (this.nativeDraggable) {
308
- _on(el, 'dragover', this);
309
- _on(el, 'dragenter', this);
310
- }
311
-
312
- touchDragOverListeners.push(this._onDragOver);
313
-
314
- // Restore sorting
315
- options.store && this.sort(options.store.get(this));
316
- }
317
-
318
-
319
- Sortable.prototype = /** @lends Sortable.prototype */ {
320
- constructor: Sortable,
321
-
322
- _onTapStart: function (/** Event|TouchEvent */evt) {
323
- var _this = this,
324
- el = this.el,
325
- options = this.options,
326
- preventOnFilter = options.preventOnFilter,
327
- type = evt.type,
328
- touch = evt.touches && evt.touches[0],
329
- target = (touch || evt).target,
330
- originalTarget = evt.target.shadowRoot && (evt.path && evt.path[0]) || target,
331
- filter = options.filter,
332
- startIndex;
333
-
334
- _saveInputCheckedState(el);
335
-
336
-
337
- // Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group.
338
- if (dragEl) {
339
- return;
340
- }
341
-
342
- if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) {
343
- return; // only left button or enabled
344
- }
345
-
346
- // cancel dnd if original target is content editable
347
- if (originalTarget.isContentEditable) {
348
- return;
349
- }
350
-
351
- target = _closest(target, options.draggable, el);
352
-
353
- if (!target) {
354
- return;
355
- }
356
-
357
- if (lastDownEl === target) {
358
- // Ignoring duplicate `down`
359
- return;
360
- }
361
-
362
- // Get the index of the dragged element within its parent
363
- startIndex = _index(target, options.draggable);
364
-
365
- // Check filter
366
- if (typeof filter === 'function') {
367
- if (filter.call(this, evt, target, this)) {
368
- _dispatchEvent(_this, originalTarget, 'filter', target, el, el, startIndex);
369
- preventOnFilter && evt.preventDefault();
370
- return; // cancel dnd
371
- }
372
- }
373
- else if (filter) {
374
- filter = filter.split(',').some(function (criteria) {
375
- criteria = _closest(originalTarget, criteria.trim(), el);
376
-
377
- if (criteria) {
378
- _dispatchEvent(_this, criteria, 'filter', target, el, el, startIndex);
379
- return true;
380
- }
381
- });
382
-
383
- if (filter) {
384
- preventOnFilter && evt.preventDefault();
385
- return; // cancel dnd
386
- }
387
- }
388
-
389
- if (options.handle && !_closest(originalTarget, options.handle, el)) {
390
- return;
391
- }
392
-
393
- // Prepare `dragstart`
394
- this._prepareDragStart(evt, touch, target, startIndex);
395
- },
396
-
397
- _prepareDragStart: function (/** Event */evt, /** Touch */touch, /** HTMLElement */target, /** Number */startIndex) {
398
- var _this = this,
399
- el = _this.el,
400
- options = _this.options,
401
- ownerDocument = el.ownerDocument,
402
- dragStartFn;
403
-
404
- if (target && !dragEl && (target.parentNode === el)) {
405
- tapEvt = evt;
406
-
407
- rootEl = el;
408
- dragEl = target;
409
- parentEl = dragEl.parentNode;
410
- nextEl = dragEl.nextSibling;
411
- lastDownEl = target;
412
- activeGroup = options.group;
413
- oldIndex = startIndex;
414
-
415
- this._lastX = (touch || evt).clientX;
416
- this._lastY = (touch || evt).clientY;
417
-
418
- dragEl.style['will-change'] = 'all';
419
-
420
- dragStartFn = function () {
421
- // Delayed drag has been triggered
422
- // we can re-enable the events: touchmove/mousemove
423
- _this._disableDelayedDrag();
424
-
425
- // Make the element draggable
426
- dragEl.draggable = _this.nativeDraggable;
427
-
428
- // Chosen item
429
- _toggleClass(dragEl, options.chosenClass, true);
430
-
431
- // Bind the events: dragstart/dragend
432
- _this._triggerDragStart(evt, touch);
433
-
434
- // Drag start event
435
- _dispatchEvent(_this, rootEl, 'choose', dragEl, rootEl, rootEl, oldIndex);
436
- };
437
-
438
- // Disable "draggable"
439
- options.ignore.split(',').forEach(function (criteria) {
440
- _find(dragEl, criteria.trim(), _disableDraggable);
441
- });
442
-
443
- _on(ownerDocument, 'mouseup', _this._onDrop);
444
- _on(ownerDocument, 'touchend', _this._onDrop);
445
- _on(ownerDocument, 'touchcancel', _this._onDrop);
446
- _on(ownerDocument, 'selectstart', _this);
447
- options.supportPointer && _on(ownerDocument, 'pointercancel', _this._onDrop);
448
-
449
- if (options.delay) {
450
- // If the user moves the pointer or let go the click or touch
451
- // before the delay has been reached:
452
- // disable the delayed drag
453
- _on(ownerDocument, 'mouseup', _this._disableDelayedDrag);
454
- _on(ownerDocument, 'touchend', _this._disableDelayedDrag);
455
- _on(ownerDocument, 'touchcancel', _this._disableDelayedDrag);
456
- _on(ownerDocument, 'mousemove', _this._disableDelayedDrag);
457
- _on(ownerDocument, 'touchmove', _this._disableDelayedDrag);
458
- options.supportPointer && _on(ownerDocument, 'pointermove', _this._disableDelayedDrag);
459
-
460
- _this._dragStartTimer = setTimeout(dragStartFn, options.delay);
461
- } else {
462
- dragStartFn();
463
- }
464
-
465
-
466
- }
467
- },
468
-
469
- _disableDelayedDrag: function () {
470
- var ownerDocument = this.el.ownerDocument;
471
-
472
- clearTimeout(this._dragStartTimer);
473
- _off(ownerDocument, 'mouseup', this._disableDelayedDrag);
474
- _off(ownerDocument, 'touchend', this._disableDelayedDrag);
475
- _off(ownerDocument, 'touchcancel', this._disableDelayedDrag);
476
- _off(ownerDocument, 'mousemove', this._disableDelayedDrag);
477
- _off(ownerDocument, 'touchmove', this._disableDelayedDrag);
478
- _off(ownerDocument, 'pointermove', this._disableDelayedDrag);
479
- },
480
-
481
- _triggerDragStart: function (/** Event */evt, /** Touch */touch) {
482
- touch = touch || (evt.pointerType == 'touch' ? evt : null);
483
-
484
- if (touch) {
485
- // Touch device support
486
- tapEvt = {
487
- target: dragEl,
488
- clientX: touch.clientX,
489
- clientY: touch.clientY
490
- };
491
-
492
- this._onDragStart(tapEvt, 'touch');
493
- }
494
- else if (!this.nativeDraggable) {
495
- this._onDragStart(tapEvt, true);
496
- }
497
- else {
498
- _on(dragEl, 'dragend', this);
499
- _on(rootEl, 'dragstart', this._onDragStart);
500
- }
501
-
502
- try {
503
- if (document.selection) {
504
- // Timeout neccessary for IE9
505
- _nextTick(function () {
506
- document.selection.empty();
507
- });
508
- } else {
509
- window.getSelection().removeAllRanges();
510
- }
511
- } catch (err) {
512
- }
513
- },
514
-
515
- _dragStarted: function () {
516
- if (rootEl && dragEl) {
517
- var options = this.options;
518
-
519
- // Apply effect
520
- _toggleClass(dragEl, options.ghostClass, true);
521
- _toggleClass(dragEl, options.dragClass, false);
522
-
523
- Sortable.active = this;
524
-
525
- // Drag start event
526
- _dispatchEvent(this, rootEl, 'start', dragEl, rootEl, rootEl, oldIndex);
527
- } else {
528
- this._nulling();
529
- }
530
- },
531
-
532
- _emulateDragOver: function () {
533
- if (touchEvt) {
534
- if (this._lastX === touchEvt.clientX && this._lastY === touchEvt.clientY) {
535
- return;
536
- }
537
-
538
- this._lastX = touchEvt.clientX;
539
- this._lastY = touchEvt.clientY;
540
-
541
- if (!supportCssPointerEvents) {
542
- _css(ghostEl, 'display', 'none');
543
- }
544
-
545
- var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
546
- var parent = target;
547
- var i = touchDragOverListeners.length;
548
-
549
- if (target && target.shadowRoot) {
550
- target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
551
- parent = target;
552
- }
553
-
554
- if (parent) {
555
- do {
556
- if (parent[expando]) {
557
- while (i--) {
558
- touchDragOverListeners[i]({
559
- clientX: touchEvt.clientX,
560
- clientY: touchEvt.clientY,
561
- target: target,
562
- rootEl: parent
563
- });
564
- }
565
-
566
- break;
567
- }
568
-
569
- target = parent; // store last element
570
- }
571
- /* jshint boss:true */
572
- while (parent = parent.parentNode);
573
- }
574
-
575
- if (!supportCssPointerEvents) {
576
- _css(ghostEl, 'display', '');
577
- }
578
- }
579
- },
580
-
581
-
582
- _onTouchMove: function (/**TouchEvent*/evt) {
583
- if (tapEvt) {
584
- var options = this.options,
585
- fallbackTolerance = options.fallbackTolerance,
586
- fallbackOffset = options.fallbackOffset,
587
- touch = evt.touches ? evt.touches[0] : evt,
588
- dx = (touch.clientX - tapEvt.clientX) + fallbackOffset.x,
589
- dy = (touch.clientY - tapEvt.clientY) + fallbackOffset.y,
590
- translate3d = evt.touches ? 'translate3d(' + dx + 'px,' + dy + 'px,0)' : 'translate(' + dx + 'px,' + dy + 'px)';
591
-
592
- // only set the status to dragging, when we are actually dragging
593
- if (!Sortable.active) {
594
- if (fallbackTolerance &&
595
- min(abs(touch.clientX - this._lastX), abs(touch.clientY - this._lastY)) < fallbackTolerance
596
- ) {
597
- return;
598
- }
599
-
600
- this._dragStarted();
601
- }
602
-
603
- // as well as creating the ghost element on the document body
604
- this._appendGhost();
605
-
606
- moved = true;
607
- touchEvt = touch;
608
-
609
- _css(ghostEl, 'webkitTransform', translate3d);
610
- _css(ghostEl, 'mozTransform', translate3d);
611
- _css(ghostEl, 'msTransform', translate3d);
612
- _css(ghostEl, 'transform', translate3d);
613
-
614
- evt.preventDefault();
615
- }
616
- },
617
-
618
- _appendGhost: function () {
619
- if (!ghostEl) {
620
- var rect = dragEl.getBoundingClientRect(),
621
- css = _css(dragEl),
622
- options = this.options,
623
- ghostRect;
624
-
625
- ghostEl = dragEl.cloneNode(true);
626
-
627
- _toggleClass(ghostEl, options.ghostClass, false);
628
- _toggleClass(ghostEl, options.fallbackClass, true);
629
- _toggleClass(ghostEl, options.dragClass, true);
630
-
631
- _css(ghostEl, 'top', rect.top - parseInt(css.marginTop, 10));
632
- _css(ghostEl, 'left', rect.left - parseInt(css.marginLeft, 10));
633
- _css(ghostEl, 'width', rect.width);
634
- _css(ghostEl, 'height', rect.height);
635
- _css(ghostEl, 'opacity', '0.8');
636
- _css(ghostEl, 'position', 'fixed');
637
- _css(ghostEl, 'zIndex', '100000');
638
- _css(ghostEl, 'pointerEvents', 'none');
639
-
640
- options.fallbackOnBody && document.body.appendChild(ghostEl) || rootEl.appendChild(ghostEl);
641
-
642
- // Fixing dimensions.
643
- ghostRect = ghostEl.getBoundingClientRect();
644
- _css(ghostEl, 'width', rect.width * 2 - ghostRect.width);
645
- _css(ghostEl, 'height', rect.height * 2 - ghostRect.height);
646
- }
647
- },
648
-
649
- _onDragStart: function (/**Event*/evt, /**boolean*/useFallback) {
650
- var _this = this;
651
- var dataTransfer = evt.dataTransfer;
652
- var options = _this.options;
653
-
654
- _this._offUpEvents();
655
-
656
- if (activeGroup.checkPull(_this, _this, dragEl, evt)) {
657
- cloneEl = _clone(dragEl);
658
-
659
- cloneEl.draggable = false;
660
- cloneEl.style['will-change'] = '';
661
-
662
- _css(cloneEl, 'display', 'none');
663
- _toggleClass(cloneEl, _this.options.chosenClass, false);
664
-
665
- // #1143: IFrame support workaround
666
- _this._cloneId = _nextTick(function () {
667
- rootEl.insertBefore(cloneEl, dragEl);
668
- _dispatchEvent(_this, rootEl, 'clone', dragEl);
669
- });
670
- }
671
-
672
- _toggleClass(dragEl, options.dragClass, true);
673
-
674
- if (useFallback) {
675
- if (useFallback === 'touch') {
676
- // Bind touch events
677
- _on(document, 'touchmove', _this._onTouchMove);
678
- _on(document, 'touchend', _this._onDrop);
679
- _on(document, 'touchcancel', _this._onDrop);
680
-
681
- if (options.supportPointer) {
682
- _on(document, 'pointermove', _this._onTouchMove);
683
- _on(document, 'pointerup', _this._onDrop);
684
- }
685
- } else {
686
- // Old brwoser
687
- _on(document, 'mousemove', _this._onTouchMove);
688
- _on(document, 'mouseup', _this._onDrop);
689
- }
690
-
691
- _this._loopId = setInterval(_this._emulateDragOver, 50);
692
- }
693
- else {
694
- if (dataTransfer) {
695
- dataTransfer.effectAllowed = 'move';
696
- options.setData && options.setData.call(_this, dataTransfer, dragEl);
697
- }
698
-
699
- _on(document, 'drop', _this);
700
-
701
- // #1143: Бывает элемент с IFrame внутри блокирует `drop`,
702
- // поэтому если вызвался `mouseover`, значит надо отменять весь d'n'd.
703
- // Breaking Chrome 62+
704
- // _on(document, 'mouseover', _this);
705
-
706
- _this._dragStartId = _nextTick(_this._dragStarted);
707
- }
708
- },
709
-
710
- _onDragOver: function (/**Event*/evt) {
711
- var el = this.el,
712
- target,
713
- dragRect,
714
- targetRect,
715
- revert,
716
- options = this.options,
717
- group = options.group,
718
- activeSortable = Sortable.active,
719
- isOwner = (activeGroup === group),
720
- isMovingBetweenSortable = false,
721
- canSort = options.sort;
722
-
723
- if (evt.preventDefault !== void 0) {
724
- evt.preventDefault();
725
- !options.dragoverBubble && evt.stopPropagation();
726
- }
727
-
728
- if (dragEl.animated) {
729
- return;
730
- }
731
-
732
- moved = true;
733
-
734
- if (activeSortable && !options.disabled &&
735
- (isOwner
736
- ? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
737
- : (
738
- putSortable === this ||
739
- (
740
- (activeSortable.lastPullMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) &&
741
- group.checkPut(this, activeSortable, dragEl, evt)
742
- )
743
- )
744
- ) &&
745
- (evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
746
- ) {
747
- // Smart auto-scrolling
748
- _autoScroll(evt, options, this.el);
749
-
750
- if (_silent) {
751
- return;
752
- }
753
-
754
- target = _closest(evt.target, options.draggable, el);
755
- dragRect = dragEl.getBoundingClientRect();
756
-
757
- if (putSortable !== this) {
758
- putSortable = this;
759
- isMovingBetweenSortable = true;
760
- }
761
-
762
- if (revert) {
763
- _cloneHide(activeSortable, true);
764
- parentEl = rootEl; // actualization
765
-
766
- if (cloneEl || nextEl) {
767
- rootEl.insertBefore(dragEl, cloneEl || nextEl);
768
- }
769
- else if (!canSort) {
770
- rootEl.appendChild(dragEl);
771
- }
772
-
773
- return;
774
- }
775
-
776
-
777
- if ((el.children.length === 0) || (el.children[0] === ghostEl) ||
778
- (el === evt.target) && (_ghostIsLast(el, evt))
779
- ) {
780
- //assign target only if condition is true
781
- if (el.children.length !== 0 && el.children[0] !== ghostEl && el === evt.target) {
782
- target = el.lastElementChild;
783
- }
784
-
785
- if (target) {
786
- if (target.animated) {
787
- return;
788
- }
789
-
790
- targetRect = target.getBoundingClientRect();
791
- }
792
-
793
- _cloneHide(activeSortable, isOwner);
794
-
795
- if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt) !== false) {
796
- if (!dragEl.contains(el)) {
797
- el.appendChild(dragEl);
798
- parentEl = el; // actualization
799
- }
800
-
801
- this._animate(dragRect, dragEl);
802
- target && this._animate(targetRect, target);
803
- }
804
- }
805
- else if (target && !target.animated && target !== dragEl && (target.parentNode[expando] !== void 0)) {
806
- if (lastEl !== target) {
807
- lastEl = target;
808
- lastCSS = _css(target);
809
- lastParentCSS = _css(target.parentNode);
810
- }
811
-
812
- targetRect = target.getBoundingClientRect();
813
-
814
- var width = targetRect.right - targetRect.left,
815
- height = targetRect.bottom - targetRect.top,
816
- floating = R_FLOAT.test(lastCSS.cssFloat + lastCSS.display)
817
- || (lastParentCSS.display == 'flex' && lastParentCSS['flex-direction'].indexOf('row') === 0),
818
- isWide = (target.offsetWidth > dragEl.offsetWidth),
819
- isLong = (target.offsetHeight > dragEl.offsetHeight),
820
- halfway = (floating ? (evt.clientX - targetRect.left) / width : (evt.clientY - targetRect.top) / height) > 0.5,
821
- nextSibling = target.nextElementSibling,
822
- after = false
823
- ;
824
-
825
- if (floating) {
826
- var elTop = dragEl.offsetTop,
827
- tgTop = target.offsetTop;
828
-
829
- if (elTop === tgTop) {
830
- after = (target.previousElementSibling === dragEl) && !isWide || halfway && isWide;
831
- }
832
- else if (target.previousElementSibling === dragEl || dragEl.previousElementSibling === target) {
833
- after = (evt.clientY - targetRect.top) / height > 0.5;
834
- } else {
835
- after = tgTop > elTop;
836
- }
837
- } else if (!isMovingBetweenSortable) {
838
- after = (nextSibling !== dragEl) && !isLong || halfway && isLong;
839
- }
840
-
841
- var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after);
842
-
843
- if (moveVector !== false) {
844
- if (moveVector === 1 || moveVector === -1) {
845
- after = (moveVector === 1);
846
- }
847
-
848
- _silent = true;
849
- setTimeout(_unsilent, 30);
850
-
851
- _cloneHide(activeSortable, isOwner);
852
-
853
- if (!dragEl.contains(el)) {
854
- if (after && !nextSibling) {
855
- el.appendChild(dragEl);
856
- } else {
857
- target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
858
- }
859
- }
860
-
861
- parentEl = dragEl.parentNode; // actualization
862
-
863
- this._animate(dragRect, dragEl);
864
- this._animate(targetRect, target);
865
- }
866
- }
867
- }
868
- },
869
-
870
- _animate: function (prevRect, target) {
871
- var ms = this.options.animation;
872
-
873
- if (ms) {
874
- var currentRect = target.getBoundingClientRect();
875
-
876
- if (prevRect.nodeType === 1) {
877
- prevRect = prevRect.getBoundingClientRect();
878
- }
879
-
880
- _css(target, 'transition', 'none');
881
- _css(target, 'transform', 'translate3d('
882
- + (prevRect.left - currentRect.left) + 'px,'
883
- + (prevRect.top - currentRect.top) + 'px,0)'
884
- );
885
-
886
- target.offsetWidth; // repaint
887
-
888
- _css(target, 'transition', 'all ' + ms + 'ms');
889
- _css(target, 'transform', 'translate3d(0,0,0)');
890
-
891
- clearTimeout(target.animated);
892
- target.animated = setTimeout(function () {
893
- _css(target, 'transition', '');
894
- _css(target, 'transform', '');
895
- target.animated = false;
896
- }, ms);
897
- }
898
- },
899
-
900
- _offUpEvents: function () {
901
- var ownerDocument = this.el.ownerDocument;
902
-
903
- _off(document, 'touchmove', this._onTouchMove);
904
- _off(document, 'pointermove', this._onTouchMove);
905
- _off(ownerDocument, 'mouseup', this._onDrop);
906
- _off(ownerDocument, 'touchend', this._onDrop);
907
- _off(ownerDocument, 'pointerup', this._onDrop);
908
- _off(ownerDocument, 'touchcancel', this._onDrop);
909
- _off(ownerDocument, 'pointercancel', this._onDrop);
910
- _off(ownerDocument, 'selectstart', this);
911
- },
912
-
913
- _onDrop: function (/**Event*/evt) {
914
- var el = this.el,
915
- options = this.options;
916
-
917
- clearInterval(this._loopId);
918
- clearInterval(autoScroll.pid);
919
- clearTimeout(this._dragStartTimer);
920
-
921
- _cancelNextTick(this._cloneId);
922
- _cancelNextTick(this._dragStartId);
923
-
924
- // Unbind events
925
- _off(document, 'mouseover', this);
926
- _off(document, 'mousemove', this._onTouchMove);
927
-
928
- if (this.nativeDraggable) {
929
- _off(document, 'drop', this);
930
- _off(el, 'dragstart', this._onDragStart);
931
- }
932
-
933
- this._offUpEvents();
934
-
935
- if (evt) {
936
- if (moved) {
937
- evt.preventDefault();
938
- !options.dropBubble && evt.stopPropagation();
939
- }
940
-
941
- ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl);
942
-
943
- if (rootEl === parentEl || Sortable.active.lastPullMode !== 'clone') {
944
- // Remove clone
945
- cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl);
946
- }
947
-
948
- if (dragEl) {
949
- if (this.nativeDraggable) {
950
- _off(dragEl, 'dragend', this);
951
- }
952
-
953
- _disableDraggable(dragEl);
954
- dragEl.style['will-change'] = '';
955
-
956
- // Remove class's
957
- _toggleClass(dragEl, this.options.ghostClass, false);
958
- _toggleClass(dragEl, this.options.chosenClass, false);
959
-
960
- // Drag stop event
961
- _dispatchEvent(this, rootEl, 'unchoose', dragEl, parentEl, rootEl, oldIndex);
962
-
963
- if (rootEl !== parentEl) {
964
- newIndex = _index(dragEl, options.draggable);
965
-
966
- if (newIndex >= 0) {
967
- // Add event
968
- _dispatchEvent(null, parentEl, 'add', dragEl, parentEl, rootEl, oldIndex, newIndex);
969
-
970
- // Remove event
971
- _dispatchEvent(this, rootEl, 'remove', dragEl, parentEl, rootEl, oldIndex, newIndex);
972
-
973
- // drag from one list and drop into another
974
- _dispatchEvent(null, parentEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
975
- _dispatchEvent(this, rootEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
976
- }
977
- }
978
- else {
979
- if (dragEl.nextSibling !== nextEl) {
980
- // Get the index of the dragged element within its parent
981
- newIndex = _index(dragEl, options.draggable);
982
-
983
- if (newIndex >= 0) {
984
- // drag & drop within the same list
985
- _dispatchEvent(this, rootEl, 'update', dragEl, parentEl, rootEl, oldIndex, newIndex);
986
- _dispatchEvent(this, rootEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
987
- }
988
- }
989
- }
990
-
991
- if (Sortable.active) {
992
- /* jshint eqnull:true */
993
- if (newIndex == null || newIndex === -1) {
994
- newIndex = oldIndex;
995
- }
996
-
997
- _dispatchEvent(this, rootEl, 'end', dragEl, parentEl, rootEl, oldIndex, newIndex);
998
-
999
- // Save sorting
1000
- this.save();
1001
- }
1002
- }
1003
-
1004
- }
1005
-
1006
- this._nulling();
1007
- },
1008
-
1009
- _nulling: function() {
1010
- rootEl =
1011
- dragEl =
1012
- parentEl =
1013
- ghostEl =
1014
- nextEl =
1015
- cloneEl =
1016
- lastDownEl =
1017
-
1018
- scrollEl =
1019
- scrollParentEl =
1020
-
1021
- tapEvt =
1022
- touchEvt =
1023
-
1024
- moved =
1025
- newIndex =
1026
-
1027
- lastEl =
1028
- lastCSS =
1029
-
1030
- putSortable =
1031
- activeGroup =
1032
- Sortable.active = null;
1033
-
1034
- savedInputChecked.forEach(function (el) {
1035
- el.checked = true;
1036
- });
1037
- savedInputChecked.length = 0;
1038
- },
1039
-
1040
- handleEvent: function (/**Event*/evt) {
1041
- switch (evt.type) {
1042
- case 'drop':
1043
- case 'dragend':
1044
- this._onDrop(evt);
1045
- break;
1046
-
1047
- case 'dragover':
1048
- case 'dragenter':
1049
- if (dragEl) {
1050
- this._onDragOver(evt);
1051
- _globalDragOver(evt);
1052
- }
1053
- break;
1054
-
1055
- case 'mouseover':
1056
- this._onDrop(evt);
1057
- break;
1058
-
1059
- case 'selectstart':
1060
- evt.preventDefault();
1061
- break;
1062
- }
1063
- },
1064
-
1065
-
1066
- /**
1067
- * Serializes the item into an array of string.
1068
- * @returns {String[]}
1069
- */
1070
- toArray: function () {
1071
- var order = [],
1072
- el,
1073
- children = this.el.children,
1074
- i = 0,
1075
- n = children.length,
1076
- options = this.options;
1077
-
1078
- for (; i < n; i++) {
1079
- el = children[i];
1080
- if (_closest(el, options.draggable, this.el)) {
1081
- order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
1082
- }
1083
- }
1084
-
1085
- return order;
1086
- },
1087
-
1088
-
1089
- /**
1090
- * Sorts the elements according to the array.
1091
- * @param {String[]} order order of the items
1092
- */
1093
- sort: function (order) {
1094
- var items = {}, rootEl = this.el;
1095
-
1096
- this.toArray().forEach(function (id, i) {
1097
- var el = rootEl.children[i];
1098
-
1099
- if (_closest(el, this.options.draggable, rootEl)) {
1100
- items[id] = el;
1101
- }
1102
- }, this);
1103
-
1104
- order.forEach(function (id) {
1105
- if (items[id]) {
1106
- rootEl.removeChild(items[id]);
1107
- rootEl.appendChild(items[id]);
1108
- }
1109
- });
1110
- },
1111
-
1112
-
1113
- /**
1114
- * Save the current sorting
1115
- */
1116
- save: function () {
1117
- var store = this.options.store;
1118
- store && store.set(this);
1119
- },
1120
-
1121
-
1122
- /**
1123
- * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
1124
- * @param {HTMLElement} el
1125
- * @param {String} [selector] default: `options.draggable`
1126
- * @returns {HTMLElement|null}
1127
- */
1128
- closest: function (el, selector) {
1129
- return _closest(el, selector || this.options.draggable, this.el);
1130
- },
1131
-
1132
-
1133
- /**
1134
- * Set/get option
1135
- * @param {string} name
1136
- * @param {*} [value]
1137
- * @returns {*}
1138
- */
1139
- option: function (name, value) {
1140
- var options = this.options;
1141
-
1142
- if (value === void 0) {
1143
- return options[name];
1144
- } else {
1145
- options[name] = value;
1146
-
1147
- if (name === 'group') {
1148
- _prepareGroup(options);
1149
- }
1150
- }
1151
- },
1152
-
1153
-
1154
- /**
1155
- * Destroy
1156
- */
1157
- destroy: function () {
1158
- var el = this.el;
1159
-
1160
- el[expando] = null;
1161
-
1162
- _off(el, 'mousedown', this._onTapStart);
1163
- _off(el, 'touchstart', this._onTapStart);
1164
- _off(el, 'pointerdown', this._onTapStart);
1165
-
1166
- if (this.nativeDraggable) {
1167
- _off(el, 'dragover', this);
1168
- _off(el, 'dragenter', this);
1169
- }
1170
-
1171
- // Remove draggable attributes
1172
- Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
1173
- el.removeAttribute('draggable');
1174
- });
1175
-
1176
- touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);
1177
-
1178
- this._onDrop();
1179
-
1180
- this.el = el = null;
1181
- }
1182
- };
1183
-
1184
-
1185
- function _cloneHide(sortable, state) {
1186
- if (sortable.lastPullMode !== 'clone') {
1187
- state = true;
1188
- }
1189
-
1190
- if (cloneEl && (cloneEl.state !== state)) {
1191
- _css(cloneEl, 'display', state ? 'none' : '');
1192
-
1193
- if (!state) {
1194
- if (cloneEl.state) {
1195
- if (sortable.options.group.revertClone) {
1196
- rootEl.insertBefore(cloneEl, nextEl);
1197
- sortable._animate(dragEl, cloneEl);
1198
- } else {
1199
- rootEl.insertBefore(cloneEl, dragEl);
1200
- }
1201
- }
1202
- }
1203
-
1204
- cloneEl.state = state;
1205
- }
1206
- }
23
+ if (typeof window === "undefined" || !window.document) {
24
+ return function sortableError() {
25
+ throw new Error("Sortable.js requires a window with a document");
26
+ };
27
+ }
28
+
29
+ var dragEl,
30
+ parentEl,
31
+ ghostEl,
32
+ cloneEl,
33
+ rootEl,
34
+ nextEl,
35
+ lastDownEl,
36
+
37
+ scrollEl,
38
+ scrollParentEl,
39
+ scrollCustomFn,
40
+
41
+ lastEl,
42
+ lastCSS,
43
+ lastParentCSS,
44
+
45
+ oldIndex,
46
+ newIndex,
47
+
48
+ activeGroup,
49
+ putSortable,
50
+
51
+ autoScroll = {},
52
+
53
+ tapEvt,
54
+ touchEvt,
55
+
56
+ moved,
57
+
58
+ /** @const */
59
+ R_SPACE = /\s+/g,
60
+ R_FLOAT = /left|right|inline/,
61
+
62
+ expando = 'Sortable' + (new Date).getTime(),
63
+
64
+ win = window,
65
+ document = win.document,
66
+ parseInt = win.parseInt,
67
+ setTimeout = win.setTimeout,
68
+
69
+ $ = win.jQuery || win.Zepto,
70
+ Polymer = win.Polymer,
71
+
72
+ captureMode = false,
73
+ passiveMode = false,
74
+
75
+ supportDraggable = ('draggable' in document.createElement('div')),
76
+ supportCssPointerEvents = (function (el) {
77
+ // false when IE11
78
+ if (!!navigator.userAgent.match(/(?:Trident.*rv[ :]?11\.|msie)/i)) {
79
+ return false;
80
+ }
81
+ el = document.createElement('x');
82
+ el.style.cssText = 'pointer-events:auto';
83
+ return el.style.pointerEvents === 'auto';
84
+ })(),
85
+
86
+ _silent = false,
87
+
88
+ abs = Math.abs,
89
+ min = Math.min,
90
+
91
+ savedInputChecked = [],
92
+ touchDragOverListeners = [],
93
+
94
+ _autoScroll = _throttle(function (/**Event*/evt, /**Object*/options, /**HTMLElement*/rootEl) {
95
+ // Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
96
+ if (rootEl && options.scroll) {
97
+ var _this = rootEl[expando],
98
+ el,
99
+ rect,
100
+ sens = options.scrollSensitivity,
101
+ speed = options.scrollSpeed,
102
+
103
+ x = evt.clientX,
104
+ y = evt.clientY,
105
+
106
+ winWidth = window.innerWidth,
107
+ winHeight = window.innerHeight,
108
+
109
+ vx,
110
+ vy,
111
+
112
+ scrollOffsetX,
113
+ scrollOffsetY
114
+ ;
115
+
116
+ // Delect scrollEl
117
+ if (scrollParentEl !== rootEl) {
118
+ scrollEl = options.scroll;
119
+ scrollParentEl = rootEl;
120
+ scrollCustomFn = options.scrollFn;
121
+
122
+ if (scrollEl === true) {
123
+ scrollEl = rootEl;
124
+
125
+ do {
126
+ if ((scrollEl.offsetWidth < scrollEl.scrollWidth) ||
127
+ (scrollEl.offsetHeight < scrollEl.scrollHeight)
128
+ ) {
129
+ break;
130
+ }
131
+ /* jshint boss:true */
132
+ } while (scrollEl = scrollEl.parentNode);
133
+ }
134
+ }
135
+
136
+ if (scrollEl) {
137
+ el = scrollEl;
138
+ rect = scrollEl.getBoundingClientRect();
139
+ vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
140
+ vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens);
141
+ }
142
+
143
+
144
+ if (!(vx || vy)) {
145
+ vx = (winWidth - x <= sens) - (x <= sens);
146
+ vy = (winHeight - y <= sens) - (y <= sens);
147
+
148
+ /* jshint expr:true */
149
+ (vx || vy) && (el = win);
150
+ }
151
+
152
+
153
+ if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
154
+ autoScroll.el = el;
155
+ autoScroll.vx = vx;
156
+ autoScroll.vy = vy;
157
+
158
+ clearInterval(autoScroll.pid);
159
+
160
+ if (el) {
161
+ autoScroll.pid = setInterval(function () {
162
+ scrollOffsetY = vy ? vy * speed : 0;
163
+ scrollOffsetX = vx ? vx * speed : 0;
164
+
165
+ if ('function' === typeof(scrollCustomFn)) {
166
+ return scrollCustomFn.call(_this, scrollOffsetX, scrollOffsetY, evt);
167
+ }
168
+
169
+ if (el === win) {
170
+ win.scrollTo(win.pageXOffset + scrollOffsetX, win.pageYOffset + scrollOffsetY);
171
+ } else {
172
+ el.scrollTop += scrollOffsetY;
173
+ el.scrollLeft += scrollOffsetX;
174
+ }
175
+ }, 24);
176
+ }
177
+ }
178
+ }
179
+ }, 30),
180
+
181
+ _prepareGroup = function (options) {
182
+ function toFn(value, pull) {
183
+ if (value === void 0 || value === true) {
184
+ value = group.name;
185
+ }
186
+
187
+ if (typeof value === 'function') {
188
+ return value;
189
+ } else {
190
+ return function (to, from) {
191
+ var fromGroup = from.options.group.name;
192
+
193
+ return pull
194
+ ? value
195
+ : value && (value.join
196
+ ? value.indexOf(fromGroup) > -1
197
+ : (fromGroup == value)
198
+ );
199
+ };
200
+ }
201
+ }
202
+
203
+ var group = {};
204
+ var originalGroup = options.group;
205
+
206
+ if (!originalGroup || typeof originalGroup != 'object') {
207
+ originalGroup = {name: originalGroup};
208
+ }
209
+
210
+ group.name = originalGroup.name;
211
+ group.checkPull = toFn(originalGroup.pull, true);
212
+ group.checkPut = toFn(originalGroup.put);
213
+ group.revertClone = originalGroup.revertClone;
214
+
215
+ options.group = group;
216
+ }
217
+ ;
218
+
219
+ // Detect support a passive mode
220
+ try {
221
+ window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
222
+ get: function () {
223
+ // `false`, because everything starts to work incorrectly and instead of d'n'd,
224
+ // begins the page has scrolled.
225
+ passiveMode = false;
226
+ captureMode = {
227
+ capture: false,
228
+ passive: passiveMode
229
+ };
230
+ }
231
+ }));
232
+ } catch (err) {}
233
+
234
+ /**
235
+ * @class Sortable
236
+ * @param {HTMLElement} el
237
+ * @param {Object} [options]
238
+ */
239
+ function Sortable(el, options) {
240
+ if (!(el && el.nodeType && el.nodeType === 1)) {
241
+ throw 'Sortable: `el` must be HTMLElement, and not ' + {}.toString.call(el);
242
+ }
243
+
244
+ this.el = el; // root element
245
+ this.options = options = _extend({}, options);
246
+
247
+
248
+ // Export instance
249
+ el[expando] = this;
250
+
251
+ // Default options
252
+ var defaults = {
253
+ group: Math.random(),
254
+ sort: true,
255
+ disabled: false,
256
+ store: null,
257
+ handle: null,
258
+ scroll: true,
259
+ scrollSensitivity: 30,
260
+ scrollSpeed: 10,
261
+ draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
262
+ ghostClass: 'sortable-ghost',
263
+ chosenClass: 'sortable-chosen',
264
+ dragClass: 'sortable-drag',
265
+ ignore: 'a, img',
266
+ filter: null,
267
+ preventOnFilter: true,
268
+ animation: 0,
269
+ setData: function (dataTransfer, dragEl) {
270
+ dataTransfer.setData('Text', dragEl.textContent);
271
+ },
272
+ dropBubble: false,
273
+ dragoverBubble: false,
274
+ dataIdAttr: 'data-id',
275
+ delay: 0,
276
+ forceFallback: false,
277
+ fallbackClass: 'sortable-fallback',
278
+ fallbackOnBody: false,
279
+ fallbackTolerance: 0,
280
+ fallbackOffset: {x: 0, y: 0},
281
+ supportPointer: Sortable.supportPointer !== false
282
+ };
283
+
284
+
285
+ // Set default options
286
+ for (var name in defaults) {
287
+ !(name in options) && (options[name] = defaults[name]);
288
+ }
289
+
290
+ _prepareGroup(options);
291
+
292
+ // Bind all private methods
293
+ for (var fn in this) {
294
+ if (fn.charAt(0) === '_' && typeof this[fn] === 'function') {
295
+ this[fn] = this[fn].bind(this);
296
+ }
297
+ }
298
+
299
+ // Setup drag mode
300
+ this.nativeDraggable = options.forceFallback ? false : supportDraggable;
301
+
302
+ // Bind events
303
+ _on(el, 'mousedown', this._onTapStart);
304
+ _on(el, 'touchstart', this._onTapStart);
305
+ options.supportPointer && _on(el, 'pointerdown', this._onTapStart);
306
+
307
+ if (this.nativeDraggable) {
308
+ _on(el, 'dragover', this);
309
+ _on(el, 'dragenter', this);
310
+ }
311
+
312
+ touchDragOverListeners.push(this._onDragOver);
313
+
314
+ // Restore sorting
315
+ options.store && this.sort(options.store.get(this));
316
+ }
317
+
318
+
319
+ Sortable.prototype = /** @lends Sortable.prototype */ {
320
+ constructor: Sortable,
321
+
322
+ _onTapStart: function (/** Event|TouchEvent */evt) {
323
+ var _this = this,
324
+ el = this.el,
325
+ options = this.options,
326
+ preventOnFilter = options.preventOnFilter,
327
+ type = evt.type,
328
+ touch = evt.touches && evt.touches[0],
329
+ target = (touch || evt).target,
330
+ originalTarget = evt.target.shadowRoot && (evt.path && evt.path[0]) || target,
331
+ filter = options.filter,
332
+ startIndex;
333
+
334
+ _saveInputCheckedState(el);
335
+
336
+
337
+ // Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group.
338
+ if (dragEl) {
339
+ return;
340
+ }
341
+
342
+ if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) {
343
+ return; // only left button or enabled
344
+ }
345
+
346
+ // cancel dnd if original target is content editable
347
+ if (originalTarget.isContentEditable) {
348
+ return;
349
+ }
350
+
351
+ target = _closest(target, options.draggable, el);
352
+
353
+ if (!target) {
354
+ return;
355
+ }
356
+
357
+ if (lastDownEl === target) {
358
+ // Ignoring duplicate `down`
359
+ return;
360
+ }
361
+
362
+ // Get the index of the dragged element within its parent
363
+ startIndex = _index(target, options.draggable);
364
+
365
+ // Check filter
366
+ if (typeof filter === 'function') {
367
+ if (filter.call(this, evt, target, this)) {
368
+ _dispatchEvent(_this, originalTarget, 'filter', target, el, el, startIndex);
369
+ preventOnFilter && evt.preventDefault();
370
+ return; // cancel dnd
371
+ }
372
+ }
373
+ else if (filter) {
374
+ filter = filter.split(',').some(function (criteria) {
375
+ criteria = _closest(originalTarget, criteria.trim(), el);
376
+
377
+ if (criteria) {
378
+ _dispatchEvent(_this, criteria, 'filter', target, el, el, startIndex);
379
+ return true;
380
+ }
381
+ });
382
+
383
+ if (filter) {
384
+ preventOnFilter && evt.preventDefault();
385
+ return; // cancel dnd
386
+ }
387
+ }
388
+
389
+ if (options.handle && !_closest(originalTarget, options.handle, el)) {
390
+ return;
391
+ }
392
+
393
+ // Prepare `dragstart`
394
+ this._prepareDragStart(evt, touch, target, startIndex);
395
+ },
396
+
397
+ _prepareDragStart: function (/** Event */evt, /** Touch */touch, /** HTMLElement */target, /** Number */startIndex) {
398
+ var _this = this,
399
+ el = _this.el,
400
+ options = _this.options,
401
+ ownerDocument = el.ownerDocument,
402
+ dragStartFn;
403
+
404
+ if (target && !dragEl && (target.parentNode === el)) {
405
+ tapEvt = evt;
406
+
407
+ rootEl = el;
408
+ dragEl = target;
409
+ parentEl = dragEl.parentNode;
410
+ nextEl = dragEl.nextSibling;
411
+ lastDownEl = target;
412
+ activeGroup = options.group;
413
+ oldIndex = startIndex;
414
+
415
+ this._lastX = (touch || evt).clientX;
416
+ this._lastY = (touch || evt).clientY;
417
+
418
+ dragEl.style['will-change'] = 'all';
419
+
420
+ dragStartFn = function () {
421
+ // Delayed drag has been triggered
422
+ // we can re-enable the events: touchmove/mousemove
423
+ _this._disableDelayedDrag();
424
+
425
+ // Make the element draggable
426
+ dragEl.draggable = _this.nativeDraggable;
427
+
428
+ // Chosen item
429
+ _toggleClass(dragEl, options.chosenClass, true);
430
+
431
+ // Bind the events: dragstart/dragend
432
+ _this._triggerDragStart(evt, touch);
433
+
434
+ // Drag start event
435
+ _dispatchEvent(_this, rootEl, 'choose', dragEl, rootEl, rootEl, oldIndex);
436
+ };
437
+
438
+ // Disable "draggable"
439
+ options.ignore.split(',').forEach(function (criteria) {
440
+ _find(dragEl, criteria.trim(), _disableDraggable);
441
+ });
442
+
443
+ _on(ownerDocument, 'mouseup', _this._onDrop);
444
+ _on(ownerDocument, 'touchend', _this._onDrop);
445
+ _on(ownerDocument, 'touchcancel', _this._onDrop);
446
+ _on(ownerDocument, 'selectstart', _this);
447
+ options.supportPointer && _on(ownerDocument, 'pointercancel', _this._onDrop);
448
+
449
+ if (options.delay) {
450
+ // If the user moves the pointer or let go the click or touch
451
+ // before the delay has been reached:
452
+ // disable the delayed drag
453
+ _on(ownerDocument, 'mouseup', _this._disableDelayedDrag);
454
+ _on(ownerDocument, 'touchend', _this._disableDelayedDrag);
455
+ _on(ownerDocument, 'touchcancel', _this._disableDelayedDrag);
456
+ _on(ownerDocument, 'mousemove', _this._disableDelayedDrag);
457
+ _on(ownerDocument, 'touchmove', _this._disableDelayedDrag);
458
+ options.supportPointer && _on(ownerDocument, 'pointermove', _this._disableDelayedDrag);
459
+
460
+ _this._dragStartTimer = setTimeout(dragStartFn, options.delay);
461
+ } else {
462
+ dragStartFn();
463
+ }
464
+
465
+
466
+ }
467
+ },
468
+
469
+ _disableDelayedDrag: function () {
470
+ var ownerDocument = this.el.ownerDocument;
471
+
472
+ clearTimeout(this._dragStartTimer);
473
+ _off(ownerDocument, 'mouseup', this._disableDelayedDrag);
474
+ _off(ownerDocument, 'touchend', this._disableDelayedDrag);
475
+ _off(ownerDocument, 'touchcancel', this._disableDelayedDrag);
476
+ _off(ownerDocument, 'mousemove', this._disableDelayedDrag);
477
+ _off(ownerDocument, 'touchmove', this._disableDelayedDrag);
478
+ _off(ownerDocument, 'pointermove', this._disableDelayedDrag);
479
+ },
480
+
481
+ _triggerDragStart: function (/** Event */evt, /** Touch */touch) {
482
+ touch = touch || (evt.pointerType == 'touch' ? evt : null);
483
+
484
+ if (touch) {
485
+ // Touch device support
486
+ tapEvt = {
487
+ target: dragEl,
488
+ clientX: touch.clientX,
489
+ clientY: touch.clientY
490
+ };
491
+
492
+ this._onDragStart(tapEvt, 'touch');
493
+ }
494
+ else if (!this.nativeDraggable) {
495
+ this._onDragStart(tapEvt, true);
496
+ }
497
+ else {
498
+ _on(dragEl, 'dragend', this);
499
+ _on(rootEl, 'dragstart', this._onDragStart);
500
+ }
501
+
502
+ try {
503
+ if (document.selection) {
504
+ // Timeout neccessary for IE9
505
+ _nextTick(function () {
506
+ document.selection.empty();
507
+ });
508
+ } else {
509
+ window.getSelection().removeAllRanges();
510
+ }
511
+ } catch (err) {
512
+ }
513
+ },
514
+
515
+ _dragStarted: function () {
516
+ if (rootEl && dragEl) {
517
+ var options = this.options;
518
+
519
+ // Apply effect
520
+ _toggleClass(dragEl, options.ghostClass, true);
521
+ _toggleClass(dragEl, options.dragClass, false);
522
+
523
+ Sortable.active = this;
524
+
525
+ // Drag start event
526
+ _dispatchEvent(this, rootEl, 'start', dragEl, rootEl, rootEl, oldIndex);
527
+ } else {
528
+ this._nulling();
529
+ }
530
+ },
531
+
532
+ _emulateDragOver: function () {
533
+ if (touchEvt) {
534
+ if (this._lastX === touchEvt.clientX && this._lastY === touchEvt.clientY) {
535
+ return;
536
+ }
537
+
538
+ this._lastX = touchEvt.clientX;
539
+ this._lastY = touchEvt.clientY;
540
+
541
+ if (!supportCssPointerEvents) {
542
+ _css(ghostEl, 'display', 'none');
543
+ }
544
+
545
+ var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
546
+ var parent = target;
547
+ var i = touchDragOverListeners.length;
548
+
549
+ if (target && target.shadowRoot) {
550
+ target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
551
+ parent = target;
552
+ }
553
+
554
+ if (parent) {
555
+ do {
556
+ if (parent[expando]) {
557
+ while (i--) {
558
+ touchDragOverListeners[i]({
559
+ clientX: touchEvt.clientX,
560
+ clientY: touchEvt.clientY,
561
+ target: target,
562
+ rootEl: parent
563
+ });
564
+ }
565
+
566
+ break;
567
+ }
568
+
569
+ target = parent; // store last element
570
+ }
571
+ /* jshint boss:true */
572
+ while (parent = parent.parentNode);
573
+ }
574
+
575
+ if (!supportCssPointerEvents) {
576
+ _css(ghostEl, 'display', '');
577
+ }
578
+ }
579
+ },
580
+
581
+
582
+ _onTouchMove: function (/**TouchEvent*/evt) {
583
+ if (tapEvt) {
584
+ var options = this.options,
585
+ fallbackTolerance = options.fallbackTolerance,
586
+ fallbackOffset = options.fallbackOffset,
587
+ touch = evt.touches ? evt.touches[0] : evt,
588
+ dx = (touch.clientX - tapEvt.clientX) + fallbackOffset.x,
589
+ dy = (touch.clientY - tapEvt.clientY) + fallbackOffset.y,
590
+ translate3d = evt.touches ? 'translate3d(' + dx + 'px,' + dy + 'px,0)' : 'translate(' + dx + 'px,' + dy + 'px)';
591
+
592
+ // only set the status to dragging, when we are actually dragging
593
+ if (!Sortable.active) {
594
+ if (fallbackTolerance &&
595
+ min(abs(touch.clientX - this._lastX), abs(touch.clientY - this._lastY)) < fallbackTolerance
596
+ ) {
597
+ return;
598
+ }
599
+
600
+ this._dragStarted();
601
+ }
602
+
603
+ // as well as creating the ghost element on the document body
604
+ this._appendGhost();
605
+
606
+ moved = true;
607
+ touchEvt = touch;
608
+
609
+ _css(ghostEl, 'webkitTransform', translate3d);
610
+ _css(ghostEl, 'mozTransform', translate3d);
611
+ _css(ghostEl, 'msTransform', translate3d);
612
+ _css(ghostEl, 'transform', translate3d);
613
+
614
+ evt.preventDefault();
615
+ }
616
+ },
617
+
618
+ _appendGhost: function () {
619
+ if (!ghostEl) {
620
+ var rect = dragEl.getBoundingClientRect(),
621
+ css = _css(dragEl),
622
+ options = this.options,
623
+ ghostRect;
624
+
625
+ ghostEl = dragEl.cloneNode(true);
626
+
627
+ _toggleClass(ghostEl, options.ghostClass, false);
628
+ _toggleClass(ghostEl, options.fallbackClass, true);
629
+ _toggleClass(ghostEl, options.dragClass, true);
630
+
631
+ _css(ghostEl, 'top', rect.top - parseInt(css.marginTop, 10));
632
+ _css(ghostEl, 'left', rect.left - parseInt(css.marginLeft, 10));
633
+ _css(ghostEl, 'width', rect.width);
634
+ _css(ghostEl, 'height', rect.height);
635
+ _css(ghostEl, 'opacity', '0.8');
636
+ _css(ghostEl, 'position', 'fixed');
637
+ _css(ghostEl, 'zIndex', '100000');
638
+ _css(ghostEl, 'pointerEvents', 'none');
639
+
640
+ options.fallbackOnBody && document.body.appendChild(ghostEl) || rootEl.appendChild(ghostEl);
641
+
642
+ // Fixing dimensions.
643
+ ghostRect = ghostEl.getBoundingClientRect();
644
+ _css(ghostEl, 'width', rect.width * 2 - ghostRect.width);
645
+ _css(ghostEl, 'height', rect.height * 2 - ghostRect.height);
646
+ }
647
+ },
648
+
649
+ _onDragStart: function (/**Event*/evt, /**boolean*/useFallback) {
650
+ var _this = this;
651
+ var dataTransfer = evt.dataTransfer;
652
+ var options = _this.options;
653
+
654
+ _this._offUpEvents();
655
+
656
+ if (activeGroup.checkPull(_this, _this, dragEl, evt)) {
657
+ cloneEl = _clone(dragEl);
658
+
659
+ cloneEl.draggable = false;
660
+ cloneEl.style['will-change'] = '';
661
+
662
+ _css(cloneEl, 'display', 'none');
663
+ _toggleClass(cloneEl, _this.options.chosenClass, false);
664
+
665
+ // #1143: IFrame support workaround
666
+ _this._cloneId = _nextTick(function () {
667
+ rootEl.insertBefore(cloneEl, dragEl);
668
+ _dispatchEvent(_this, rootEl, 'clone', dragEl);
669
+ });
670
+ }
671
+
672
+ _toggleClass(dragEl, options.dragClass, true);
673
+
674
+ if (useFallback) {
675
+ if (useFallback === 'touch') {
676
+ // Bind touch events
677
+ _on(document, 'touchmove', _this._onTouchMove);
678
+ _on(document, 'touchend', _this._onDrop);
679
+ _on(document, 'touchcancel', _this._onDrop);
680
+
681
+ if (options.supportPointer) {
682
+ _on(document, 'pointermove', _this._onTouchMove);
683
+ _on(document, 'pointerup', _this._onDrop);
684
+ }
685
+ } else {
686
+ // Old brwoser
687
+ _on(document, 'mousemove', _this._onTouchMove);
688
+ _on(document, 'mouseup', _this._onDrop);
689
+ }
690
+
691
+ _this._loopId = setInterval(_this._emulateDragOver, 50);
692
+ }
693
+ else {
694
+ if (dataTransfer) {
695
+ dataTransfer.effectAllowed = 'move';
696
+ options.setData && options.setData.call(_this, dataTransfer, dragEl);
697
+ }
698
+
699
+ _on(document, 'drop', _this);
700
+
701
+ // #1143: Бывает элемент с IFrame внутри блокирует `drop`,
702
+ // поэтому если вызвался `mouseover`, значит надо отменять весь d'n'd.
703
+ // Breaking Chrome 62+
704
+ // _on(document, 'mouseover', _this);
705
+
706
+ _this._dragStartId = _nextTick(_this._dragStarted);
707
+ }
708
+ },
709
+
710
+ _onDragOver: function (/**Event*/evt) {
711
+ var el = this.el,
712
+ target,
713
+ dragRect,
714
+ targetRect,
715
+ revert,
716
+ options = this.options,
717
+ group = options.group,
718
+ activeSortable = Sortable.active,
719
+ isOwner = (activeGroup === group),
720
+ isMovingBetweenSortable = false,
721
+ canSort = options.sort;
722
+
723
+ if (evt.preventDefault !== void 0) {
724
+ evt.preventDefault();
725
+ !options.dragoverBubble && evt.stopPropagation();
726
+ }
727
+
728
+ if (dragEl.animated) {
729
+ return;
730
+ }
731
+
732
+ moved = true;
733
+
734
+ if (activeSortable && !options.disabled &&
735
+ (isOwner
736
+ ? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
737
+ : (
738
+ putSortable === this ||
739
+ (
740
+ (activeSortable.lastPullMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) &&
741
+ group.checkPut(this, activeSortable, dragEl, evt)
742
+ )
743
+ )
744
+ ) &&
745
+ (evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
746
+ ) {
747
+ // Smart auto-scrolling
748
+ _autoScroll(evt, options, this.el);
749
+
750
+ if (_silent) {
751
+ return;
752
+ }
753
+
754
+ target = _closest(evt.target, options.draggable, el);
755
+ dragRect = dragEl.getBoundingClientRect();
756
+
757
+ if (putSortable !== this) {
758
+ putSortable = this;
759
+ isMovingBetweenSortable = true;
760
+ }
761
+
762
+ if (revert) {
763
+ _cloneHide(activeSortable, true);
764
+ parentEl = rootEl; // actualization
765
+
766
+ if (cloneEl || nextEl) {
767
+ rootEl.insertBefore(dragEl, cloneEl || nextEl);
768
+ }
769
+ else if (!canSort) {
770
+ rootEl.appendChild(dragEl);
771
+ }
772
+
773
+ return;
774
+ }
775
+
776
+
777
+ if ((el.children.length === 0) || (el.children[0] === ghostEl) ||
778
+ (el === evt.target) && (_ghostIsLast(el, evt))
779
+ ) {
780
+ //assign target only if condition is true
781
+ if (el.children.length !== 0 && el.children[0] !== ghostEl && el === evt.target) {
782
+ target = el.lastElementChild;
783
+ }
784
+
785
+ if (target) {
786
+ if (target.animated) {
787
+ return;
788
+ }
789
+
790
+ targetRect = target.getBoundingClientRect();
791
+ }
792
+
793
+ _cloneHide(activeSortable, isOwner);
794
+
795
+ if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt) !== false) {
796
+ if (!dragEl.contains(el)) {
797
+ el.appendChild(dragEl);
798
+ parentEl = el; // actualization
799
+ }
800
+
801
+ this._animate(dragRect, dragEl);
802
+ target && this._animate(targetRect, target);
803
+ }
804
+ }
805
+ else if (target && !target.animated && target !== dragEl && (target.parentNode[expando] !== void 0)) {
806
+ if (lastEl !== target) {
807
+ lastEl = target;
808
+ lastCSS = _css(target);
809
+ lastParentCSS = _css(target.parentNode);
810
+ }
811
+
812
+ targetRect = target.getBoundingClientRect();
813
+
814
+ var width = targetRect.right - targetRect.left,
815
+ height = targetRect.bottom - targetRect.top,
816
+ floating = R_FLOAT.test(lastCSS.cssFloat + lastCSS.display)
817
+ || (lastParentCSS.display == 'flex' && lastParentCSS['flex-direction'].indexOf('row') === 0),
818
+ isWide = (target.offsetWidth > dragEl.offsetWidth),
819
+ isLong = (target.offsetHeight > dragEl.offsetHeight),
820
+ halfway = (floating ? (evt.clientX - targetRect.left) / width : (evt.clientY - targetRect.top) / height) > 0.5,
821
+ nextSibling = target.nextElementSibling,
822
+ after = false
823
+ ;
824
+
825
+ if (floating) {
826
+ var elTop = dragEl.offsetTop,
827
+ tgTop = target.offsetTop;
828
+
829
+ if (elTop === tgTop) {
830
+ after = (target.previousElementSibling === dragEl) && !isWide || halfway && isWide;
831
+ }
832
+ else if (target.previousElementSibling === dragEl || dragEl.previousElementSibling === target) {
833
+ after = (evt.clientY - targetRect.top) / height > 0.5;
834
+ } else {
835
+ after = tgTop > elTop;
836
+ }
837
+ } else if (!isMovingBetweenSortable) {
838
+ after = (nextSibling !== dragEl) && !isLong || halfway && isLong;
839
+ }
840
+
841
+ var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after);
842
+
843
+ if (moveVector !== false) {
844
+ if (moveVector === 1 || moveVector === -1) {
845
+ after = (moveVector === 1);
846
+ }
847
+
848
+ _silent = true;
849
+ setTimeout(_unsilent, 30);
850
+
851
+ _cloneHide(activeSortable, isOwner);
852
+
853
+ if (!dragEl.contains(el)) {
854
+ if (after && !nextSibling) {
855
+ el.appendChild(dragEl);
856
+ } else {
857
+ target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
858
+ }
859
+ }
860
+
861
+ parentEl = dragEl.parentNode; // actualization
862
+
863
+ this._animate(dragRect, dragEl);
864
+ this._animate(targetRect, target);
865
+ }
866
+ }
867
+ }
868
+ },
869
+
870
+ _animate: function (prevRect, target) {
871
+ var ms = this.options.animation;
872
+
873
+ if (ms) {
874
+ var currentRect = target.getBoundingClientRect();
875
+
876
+ if (prevRect.nodeType === 1) {
877
+ prevRect = prevRect.getBoundingClientRect();
878
+ }
879
+
880
+ _css(target, 'transition', 'none');
881
+ _css(target, 'transform', 'translate3d('
882
+ + (prevRect.left - currentRect.left) + 'px,'
883
+ + (prevRect.top - currentRect.top) + 'px,0)'
884
+ );
885
+
886
+ target.offsetWidth; // repaint
887
+
888
+ _css(target, 'transition', 'all ' + ms + 'ms');
889
+ _css(target, 'transform', 'translate3d(0,0,0)');
890
+
891
+ clearTimeout(target.animated);
892
+ target.animated = setTimeout(function () {
893
+ _css(target, 'transition', '');
894
+ _css(target, 'transform', '');
895
+ target.animated = false;
896
+ }, ms);
897
+ }
898
+ },
899
+
900
+ _offUpEvents: function () {
901
+ var ownerDocument = this.el.ownerDocument;
902
+
903
+ _off(document, 'touchmove', this._onTouchMove);
904
+ _off(document, 'pointermove', this._onTouchMove);
905
+ _off(ownerDocument, 'mouseup', this._onDrop);
906
+ _off(ownerDocument, 'touchend', this._onDrop);
907
+ _off(ownerDocument, 'pointerup', this._onDrop);
908
+ _off(ownerDocument, 'touchcancel', this._onDrop);
909
+ _off(ownerDocument, 'pointercancel', this._onDrop);
910
+ _off(ownerDocument, 'selectstart', this);
911
+ },
912
+
913
+ _onDrop: function (/**Event*/evt) {
914
+ var el = this.el,
915
+ options = this.options;
916
+
917
+ clearInterval(this._loopId);
918
+ clearInterval(autoScroll.pid);
919
+ clearTimeout(this._dragStartTimer);
920
+
921
+ _cancelNextTick(this._cloneId);
922
+ _cancelNextTick(this._dragStartId);
923
+
924
+ // Unbind events
925
+ _off(document, 'mouseover', this);
926
+ _off(document, 'mousemove', this._onTouchMove);
927
+
928
+ if (this.nativeDraggable) {
929
+ _off(document, 'drop', this);
930
+ _off(el, 'dragstart', this._onDragStart);
931
+ }
932
+
933
+ this._offUpEvents();
934
+
935
+ if (evt) {
936
+ if (moved) {
937
+ evt.preventDefault();
938
+ !options.dropBubble && evt.stopPropagation();
939
+ }
940
+
941
+ ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl);
942
+
943
+ if (rootEl === parentEl || Sortable.active.lastPullMode !== 'clone') {
944
+ // Remove clone
945
+ cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl);
946
+ }
947
+
948
+ if (dragEl) {
949
+ if (this.nativeDraggable) {
950
+ _off(dragEl, 'dragend', this);
951
+ }
952
+
953
+ _disableDraggable(dragEl);
954
+ dragEl.style['will-change'] = '';
955
+
956
+ // Remove class's
957
+ _toggleClass(dragEl, this.options.ghostClass, false);
958
+ _toggleClass(dragEl, this.options.chosenClass, false);
959
+
960
+ // Drag stop event
961
+ _dispatchEvent(this, rootEl, 'unchoose', dragEl, parentEl, rootEl, oldIndex);
962
+
963
+ if (rootEl !== parentEl) {
964
+ newIndex = _index(dragEl, options.draggable);
965
+
966
+ if (newIndex >= 0) {
967
+ // Add event
968
+ _dispatchEvent(null, parentEl, 'add', dragEl, parentEl, rootEl, oldIndex, newIndex);
969
+
970
+ // Remove event
971
+ _dispatchEvent(this, rootEl, 'remove', dragEl, parentEl, rootEl, oldIndex, newIndex);
972
+
973
+ // drag from one list and drop into another
974
+ _dispatchEvent(null, parentEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
975
+ _dispatchEvent(this, rootEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
976
+ }
977
+ }
978
+ else {
979
+ if (dragEl.nextSibling !== nextEl) {
980
+ // Get the index of the dragged element within its parent
981
+ newIndex = _index(dragEl, options.draggable);
982
+
983
+ if (newIndex >= 0) {
984
+ // drag & drop within the same list
985
+ _dispatchEvent(this, rootEl, 'update', dragEl, parentEl, rootEl, oldIndex, newIndex);
986
+ _dispatchEvent(this, rootEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
987
+ }
988
+ }
989
+ }
990
+
991
+ if (Sortable.active) {
992
+ /* jshint eqnull:true */
993
+ if (newIndex == null || newIndex === -1) {
994
+ newIndex = oldIndex;
995
+ }
996
+
997
+ _dispatchEvent(this, rootEl, 'end', dragEl, parentEl, rootEl, oldIndex, newIndex);
998
+
999
+ // Save sorting
1000
+ this.save();
1001
+ }
1002
+ }
1003
+
1004
+ }
1005
+
1006
+ this._nulling();
1007
+ },
1008
+
1009
+ _nulling: function() {
1010
+ rootEl =
1011
+ dragEl =
1012
+ parentEl =
1013
+ ghostEl =
1014
+ nextEl =
1015
+ cloneEl =
1016
+ lastDownEl =
1017
+
1018
+ scrollEl =
1019
+ scrollParentEl =
1020
+
1021
+ tapEvt =
1022
+ touchEvt =
1023
+
1024
+ moved =
1025
+ newIndex =
1026
+
1027
+ lastEl =
1028
+ lastCSS =
1029
+
1030
+ putSortable =
1031
+ activeGroup =
1032
+ Sortable.active = null;
1033
+
1034
+ savedInputChecked.forEach(function (el) {
1035
+ el.checked = true;
1036
+ });
1037
+ savedInputChecked.length = 0;
1038
+ },
1039
+
1040
+ handleEvent: function (/**Event*/evt) {
1041
+ switch (evt.type) {
1042
+ case 'drop':
1043
+ case 'dragend':
1044
+ this._onDrop(evt);
1045
+ break;
1046
+
1047
+ case 'dragover':
1048
+ case 'dragenter':
1049
+ if (dragEl) {
1050
+ this._onDragOver(evt);
1051
+ _globalDragOver(evt);
1052
+ }
1053
+ break;
1054
+
1055
+ case 'mouseover':
1056
+ this._onDrop(evt);
1057
+ break;
1058
+
1059
+ case 'selectstart':
1060
+ evt.preventDefault();
1061
+ break;
1062
+ }
1063
+ },
1064
+
1065
+
1066
+ /**
1067
+ * Serializes the item into an array of string.
1068
+ * @returns {String[]}
1069
+ */
1070
+ toArray: function () {
1071
+ var order = [],
1072
+ el,
1073
+ children = this.el.children,
1074
+ i = 0,
1075
+ n = children.length,
1076
+ options = this.options;
1077
+
1078
+ for (; i < n; i++) {
1079
+ el = children[i];
1080
+ if (_closest(el, options.draggable, this.el)) {
1081
+ order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
1082
+ }
1083
+ }
1084
+
1085
+ return order;
1086
+ },
1087
+
1088
+
1089
+ /**
1090
+ * Sorts the elements according to the array.
1091
+ * @param {String[]} order order of the items
1092
+ */
1093
+ sort: function (order) {
1094
+ var items = {}, rootEl = this.el;
1095
+
1096
+ this.toArray().forEach(function (id, i) {
1097
+ var el = rootEl.children[i];
1098
+
1099
+ if (_closest(el, this.options.draggable, rootEl)) {
1100
+ items[id] = el;
1101
+ }
1102
+ }, this);
1103
+
1104
+ order.forEach(function (id) {
1105
+ if (items[id]) {
1106
+ rootEl.removeChild(items[id]);
1107
+ rootEl.appendChild(items[id]);
1108
+ }
1109
+ });
1110
+ },
1111
+
1112
+
1113
+ /**
1114
+ * Save the current sorting
1115
+ */
1116
+ save: function () {
1117
+ var store = this.options.store;
1118
+ store && store.set(this);
1119
+ },
1120
+
1121
+
1122
+ /**
1123
+ * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
1124
+ * @param {HTMLElement} el
1125
+ * @param {String} [selector] default: `options.draggable`
1126
+ * @returns {HTMLElement|null}
1127
+ */
1128
+ closest: function (el, selector) {
1129
+ return _closest(el, selector || this.options.draggable, this.el);
1130
+ },
1131
+
1132
+
1133
+ /**
1134
+ * Set/get option
1135
+ * @param {string} name
1136
+ * @param {*} [value]
1137
+ * @returns {*}
1138
+ */
1139
+ option: function (name, value) {
1140
+ var options = this.options;
1141
+
1142
+ if (value === void 0) {
1143
+ return options[name];
1144
+ } else {
1145
+ options[name] = value;
1146
+
1147
+ if (name === 'group') {
1148
+ _prepareGroup(options);
1149
+ }
1150
+ }
1151
+ },
1152
+
1153
+
1154
+ /**
1155
+ * Destroy
1156
+ */
1157
+ destroy: function () {
1158
+ var el = this.el;
1159
+
1160
+ el[expando] = null;
1161
+
1162
+ _off(el, 'mousedown', this._onTapStart);
1163
+ _off(el, 'touchstart', this._onTapStart);
1164
+ _off(el, 'pointerdown', this._onTapStart);
1165
+
1166
+ if (this.nativeDraggable) {
1167
+ _off(el, 'dragover', this);
1168
+ _off(el, 'dragenter', this);
1169
+ }
1170
+
1171
+ // Remove draggable attributes
1172
+ Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
1173
+ el.removeAttribute('draggable');
1174
+ });
1175
+
1176
+ touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);
1177
+
1178
+ this._onDrop();
1179
+
1180
+ this.el = el = null;
1181
+ }
1182
+ };
1183
+
1184
+
1185
+ function _cloneHide(sortable, state) {
1186
+ if (sortable.lastPullMode !== 'clone') {
1187
+ state = true;
1188
+ }
1189
+
1190
+ if (cloneEl && (cloneEl.state !== state)) {
1191
+ _css(cloneEl, 'display', state ? 'none' : '');
1192
+
1193
+ if (!state) {
1194
+ if (cloneEl.state) {
1195
+ if (sortable.options.group.revertClone) {
1196
+ rootEl.insertBefore(cloneEl, nextEl);
1197
+ sortable._animate(dragEl, cloneEl);
1198
+ } else {
1199
+ rootEl.insertBefore(cloneEl, dragEl);
1200
+ }
1201
+ }
1202
+ }
1203
+
1204
+ cloneEl.state = state;
1205
+ }
1206
+ }
1207
1207
 
1208
1208
 
1209
- function _closest(/**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx) {
1210
- if (el) {
1211
- ctx = ctx || document;
1209
+ function _closest(/**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx) {
1210
+ if (el) {
1211
+ ctx = ctx || document;
1212
1212
 
1213
- do {
1214
- if ((selector === '>*' && el.parentNode === ctx) || _matches(el, selector)) {
1215
- return el;
1216
- }
1217
- /* jshint boss:true */
1218
- } while (el = _getParentOrHost(el));
1219
- }
1213
+ do {
1214
+ if ((selector === '>*' && el.parentNode === ctx) || _matches(el, selector)) {
1215
+ return el;
1216
+ }
1217
+ /* jshint boss:true */
1218
+ } while (el = _getParentOrHost(el));
1219
+ }
1220
1220
 
1221
- return null;
1222
- }
1221
+ return null;
1222
+ }
1223
1223
 
1224
1224
 
1225
- function _getParentOrHost(el) {
1226
- var parent = el.host;
1225
+ function _getParentOrHost(el) {
1226
+ var parent = el.host;
1227
1227
 
1228
- return (parent && parent.nodeType) ? parent : el.parentNode;
1229
- }
1228
+ return (parent && parent.nodeType) ? parent : el.parentNode;
1229
+ }
1230
1230
 
1231
1231
 
1232
- function _globalDragOver(/**Event*/evt) {
1233
- if (evt.dataTransfer) {
1234
- evt.dataTransfer.dropEffect = 'move';
1235
- }
1236
- evt.preventDefault();
1237
- }
1232
+ function _globalDragOver(/**Event*/evt) {
1233
+ if (evt.dataTransfer) {
1234
+ evt.dataTransfer.dropEffect = 'move';
1235
+ }
1236
+ evt.preventDefault();
1237
+ }
1238
1238
 
1239
1239
 
1240
- function _on(el, event, fn) {
1241
- el.addEventListener(event, fn, captureMode);
1242
- }
1240
+ function _on(el, event, fn) {
1241
+ el.addEventListener(event, fn, captureMode);
1242
+ }
1243
1243
 
1244
1244
 
1245
- function _off(el, event, fn) {
1246
- el.removeEventListener(event, fn, captureMode);
1247
- }
1245
+ function _off(el, event, fn) {
1246
+ el.removeEventListener(event, fn, captureMode);
1247
+ }
1248
1248
 
1249
1249
 
1250
- function _toggleClass(el, name, state) {
1251
- if (el) {
1252
- if (el.classList) {
1253
- el.classList[state ? 'add' : 'remove'](name);
1254
- }
1255
- else {
1256
- var className = (' ' + el.className + ' ').replace(R_SPACE, ' ').replace(' ' + name + ' ', ' ');
1257
- el.className = (className + (state ? ' ' + name : '')).replace(R_SPACE, ' ');
1258
- }
1259
- }
1260
- }
1250
+ function _toggleClass(el, name, state) {
1251
+ if (el) {
1252
+ if (el.classList) {
1253
+ el.classList[state ? 'add' : 'remove'](name);
1254
+ }
1255
+ else {
1256
+ var className = (' ' + el.className + ' ').replace(R_SPACE, ' ').replace(' ' + name + ' ', ' ');
1257
+ el.className = (className + (state ? ' ' + name : '')).replace(R_SPACE, ' ');
1258
+ }
1259
+ }
1260
+ }
1261
1261
 
1262
1262
 
1263
- function _css(el, prop, val) {
1264
- var style = el && el.style;
1263
+ function _css(el, prop, val) {
1264
+ var style = el && el.style;
1265
1265
 
1266
- if (style) {
1267
- if (val === void 0) {
1268
- if (document.defaultView && document.defaultView.getComputedStyle) {
1269
- val = document.defaultView.getComputedStyle(el, '');
1270
- }
1271
- else if (el.currentStyle) {
1272
- val = el.currentStyle;
1273
- }
1266
+ if (style) {
1267
+ if (val === void 0) {
1268
+ if (document.defaultView && document.defaultView.getComputedStyle) {
1269
+ val = document.defaultView.getComputedStyle(el, '');
1270
+ }
1271
+ else if (el.currentStyle) {
1272
+ val = el.currentStyle;
1273
+ }
1274
1274
 
1275
- return prop === void 0 ? val : val[prop];
1276
- }
1277
- else {
1278
- if (!(prop in style)) {
1279
- prop = '-webkit-' + prop;
1280
- }
1275
+ return prop === void 0 ? val : val[prop];
1276
+ }
1277
+ else {
1278
+ if (!(prop in style)) {
1279
+ prop = '-webkit-' + prop;
1280
+ }
1281
1281
 
1282
- style[prop] = val + (typeof val === 'string' ? '' : 'px');
1283
- }
1284
- }
1285
- }
1282
+ style[prop] = val + (typeof val === 'string' ? '' : 'px');
1283
+ }
1284
+ }
1285
+ }
1286
1286
 
1287
1287
 
1288
- function _find(ctx, tagName, iterator) {
1289
- if (ctx) {
1290
- var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;
1288
+ function _find(ctx, tagName, iterator) {
1289
+ if (ctx) {
1290
+ var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;
1291
1291
 
1292
- if (iterator) {
1293
- for (; i < n; i++) {
1294
- iterator(list[i], i);
1295
- }
1296
- }
1292
+ if (iterator) {
1293
+ for (; i < n; i++) {
1294
+ iterator(list[i], i);
1295
+ }
1296
+ }
1297
1297
 
1298
- return list;
1299
- }
1298
+ return list;
1299
+ }
1300
1300
 
1301
- return [];
1302
- }
1301
+ return [];
1302
+ }
1303
1303
 
1304
1304
 
1305
1305
 
1306
- function _dispatchEvent(sortable, rootEl, name, targetEl, toEl, fromEl, startIndex, newIndex) {
1307
- sortable = (sortable || rootEl[expando]);
1306
+ function _dispatchEvent(sortable, rootEl, name, targetEl, toEl, fromEl, startIndex, newIndex) {
1307
+ sortable = (sortable || rootEl[expando]);
1308
1308
 
1309
- var evt = document.createEvent('Event'),
1310
- options = sortable.options,
1311
- onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
1309
+ var evt = document.createEvent('Event'),
1310
+ options = sortable.options,
1311
+ onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
1312
1312
 
1313
- evt.initEvent(name, true, true);
1313
+ evt.initEvent(name, true, true);
1314
1314
 
1315
- evt.to = toEl || rootEl;
1316
- evt.from = fromEl || rootEl;
1317
- evt.item = targetEl || rootEl;
1318
- evt.clone = cloneEl;
1315
+ evt.to = toEl || rootEl;
1316
+ evt.from = fromEl || rootEl;
1317
+ evt.item = targetEl || rootEl;
1318
+ evt.clone = cloneEl;
1319
1319
 
1320
- evt.oldIndex = startIndex;
1321
- evt.newIndex = newIndex;
1320
+ evt.oldIndex = startIndex;
1321
+ evt.newIndex = newIndex;
1322
1322
 
1323
- rootEl.dispatchEvent(evt);
1323
+ rootEl.dispatchEvent(evt);
1324
1324
 
1325
- if (options[onName]) {
1326
- options[onName].call(sortable, evt);
1327
- }
1328
- }
1325
+ if (options[onName]) {
1326
+ options[onName].call(sortable, evt);
1327
+ }
1328
+ }
1329
1329
 
1330
1330
 
1331
- function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvt, willInsertAfter) {
1332
- var evt,
1333
- sortable = fromEl[expando],
1334
- onMoveFn = sortable.options.onMove,
1335
- retVal;
1331
+ function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvt, willInsertAfter) {
1332
+ var evt,
1333
+ sortable = fromEl[expando],
1334
+ onMoveFn = sortable.options.onMove,
1335
+ retVal;
1336
1336
 
1337
- evt = document.createEvent('Event');
1338
- evt.initEvent('move', true, true);
1337
+ evt = document.createEvent('Event');
1338
+ evt.initEvent('move', true, true);
1339
1339
 
1340
- evt.to = toEl;
1341
- evt.from = fromEl;
1342
- evt.dragged = dragEl;
1343
- evt.draggedRect = dragRect;
1344
- evt.related = targetEl || toEl;
1345
- evt.relatedRect = targetRect || toEl.getBoundingClientRect();
1346
- evt.willInsertAfter = willInsertAfter;
1347
-
1348
- fromEl.dispatchEvent(evt);
1349
-
1350
- if (onMoveFn) {
1351
- retVal = onMoveFn.call(sortable, evt, originalEvt);
1352
- }
1353
-
1354
- return retVal;
1355
- }
1340
+ evt.to = toEl;
1341
+ evt.from = fromEl;
1342
+ evt.dragged = dragEl;
1343
+ evt.draggedRect = dragRect;
1344
+ evt.related = targetEl || toEl;
1345
+ evt.relatedRect = targetRect || toEl.getBoundingClientRect();
1346
+ evt.willInsertAfter = willInsertAfter;
1347
+
1348
+ fromEl.dispatchEvent(evt);
1349
+
1350
+ if (onMoveFn) {
1351
+ retVal = onMoveFn.call(sortable, evt, originalEvt);
1352
+ }
1353
+
1354
+ return retVal;
1355
+ }
1356
1356
 
1357
1357
 
1358
- function _disableDraggable(el) {
1359
- el.draggable = false;
1360
- }
1358
+ function _disableDraggable(el) {
1359
+ el.draggable = false;
1360
+ }
1361
1361
 
1362
-
1363
- function _unsilent() {
1364
- _silent = false;
1365
- }
1366
-
1367
-
1368
- /** @returns {HTMLElement|false} */
1369
- function _ghostIsLast(el, evt) {
1370
- var lastEl = el.lastElementChild,
1371
- rect = lastEl.getBoundingClientRect();
1372
-
1373
- // 5 — min delta
1374
- // abs — нельзя добавлять, а то глюки при наведении сверху
1375
- return (evt.clientY - (rect.top + rect.height) > 5) ||
1376
- (evt.clientX - (rect.left + rect.width) > 5);
1377
- }
1378
-
1379
-
1380
- /**
1381
- * Generate id
1382
- * @param {HTMLElement} el
1383
- * @returns {String}
1384
- * @private
1385
- */
1386
- function _generateId(el) {
1387
- var str = el.tagName + el.className + el.src + el.href + el.textContent,
1388
- i = str.length,
1389
- sum = 0;
1390
-
1391
- while (i--) {
1392
- sum += str.charCodeAt(i);
1393
- }
1394
-
1395
- return sum.toString(36);
1396
- }
1397
-
1398
- /**
1399
- * Returns the index of an element within its parent for a selected set of
1400
- * elements
1401
- * @param {HTMLElement} el
1402
- * @param {selector} selector
1403
- * @return {number}
1404
- */
1405
- function _index(el, selector) {
1406
- var index = 0;
1407
-
1408
- if (!el || !el.parentNode) {
1409
- return -1;
1410
- }
1411
-
1412
- while (el && (el = el.previousElementSibling)) {
1413
- if ((el.nodeName.toUpperCase() !== 'TEMPLATE') && (selector === '>*' || _matches(el, selector))) {
1414
- index++;
1415
- }
1416
- }
1417
-
1418
- return index;
1419
- }
1420
-
1421
- function _matches(/**HTMLElement*/el, /**String*/selector) {
1422
- if (el) {
1423
- selector = selector.split('.');
1424
-
1425
- var tag = selector.shift().toUpperCase(),
1426
- re = new RegExp('\\s(' + selector.join('|') + ')(?=\\s)', 'g');
1427
-
1428
- return (
1429
- (tag === '' || el.nodeName.toUpperCase() == tag) &&
1430
- (!selector.length || ((' ' + el.className + ' ').match(re) || []).length == selector.length)
1431
- );
1432
- }
1433
-
1434
- return false;
1435
- }
1436
-
1437
- function _throttle(callback, ms) {
1438
- var args, _this;
1439
-
1440
- return function () {
1441
- if (args === void 0) {
1442
- args = arguments;
1443
- _this = this;
1444
-
1445
- setTimeout(function () {
1446
- if (args.length === 1) {
1447
- callback.call(_this, args[0]);
1448
- } else {
1449
- callback.apply(_this, args);
1450
- }
1451
-
1452
- args = void 0;
1453
- }, ms);
1454
- }
1455
- };
1456
- }
1457
-
1458
- function _extend(dst, src) {
1459
- if (dst && src) {
1460
- for (var key in src) {
1461
- if (src.hasOwnProperty(key)) {
1462
- dst[key] = src[key];
1463
- }
1464
- }
1465
- }
1466
-
1467
- return dst;
1468
- }
1469
-
1470
- function _clone(el) {
1471
- if (Polymer && Polymer.dom) {
1472
- return Polymer.dom(el).cloneNode(true);
1473
- }
1474
- else if ($) {
1475
- return $(el).clone(true)[0];
1476
- }
1477
- else {
1478
- return el.cloneNode(true);
1479
- }
1480
- }
1481
-
1482
- function _saveInputCheckedState(root) {
1483
- var inputs = root.getElementsByTagName('input');
1484
- var idx = inputs.length;
1485
-
1486
- while (idx--) {
1487
- var el = inputs[idx];
1488
- el.checked && savedInputChecked.push(el);
1489
- }
1490
- }
1491
-
1492
- function _nextTick(fn) {
1493
- return setTimeout(fn, 0);
1494
- }
1495
-
1496
- function _cancelNextTick(id) {
1497
- return clearTimeout(id);
1498
- }
1499
-
1500
- // Fixed #973:
1501
- _on(document, 'touchmove', function (evt) {
1502
- if (Sortable.active) {
1503
- evt.preventDefault();
1504
- }
1505
- });
1506
-
1507
- // Export utils
1508
- Sortable.utils = {
1509
- on: _on,
1510
- off: _off,
1511
- css: _css,
1512
- find: _find,
1513
- is: function (el, selector) {
1514
- return !!_closest(el, selector, el);
1515
- },
1516
- extend: _extend,
1517
- throttle: _throttle,
1518
- closest: _closest,
1519
- toggleClass: _toggleClass,
1520
- clone: _clone,
1521
- index: _index,
1522
- nextTick: _nextTick,
1523
- cancelNextTick: _cancelNextTick
1524
- };
1525
-
1526
-
1527
- /**
1528
- * Create sortable instance
1529
- * @param {HTMLElement} el
1530
- * @param {Object} [options]
1531
- */
1532
- Sortable.create = function (el, options) {
1533
- return new Sortable(el, options);
1534
- };
1535
-
1536
-
1537
- // Export
1538
- Sortable.version = '1.7.0';
1539
- return Sortable;
1362
+
1363
+ function _unsilent() {
1364
+ _silent = false;
1365
+ }
1366
+
1367
+
1368
+ /** @returns {HTMLElement|false} */
1369
+ function _ghostIsLast(el, evt) {
1370
+ var lastEl = el.lastElementChild,
1371
+ rect = lastEl.getBoundingClientRect();
1372
+
1373
+ // 5 — min delta
1374
+ // abs — нельзя добавлять, а то глюки при наведении сверху
1375
+ return (evt.clientY - (rect.top + rect.height) > 5) ||
1376
+ (evt.clientX - (rect.left + rect.width) > 5);
1377
+ }
1378
+
1379
+
1380
+ /**
1381
+ * Generate id
1382
+ * @param {HTMLElement} el
1383
+ * @returns {String}
1384
+ * @private
1385
+ */
1386
+ function _generateId(el) {
1387
+ var str = el.tagName + el.className + el.src + el.href + el.textContent,
1388
+ i = str.length,
1389
+ sum = 0;
1390
+
1391
+ while (i--) {
1392
+ sum += str.charCodeAt(i);
1393
+ }
1394
+
1395
+ return sum.toString(36);
1396
+ }
1397
+
1398
+ /**
1399
+ * Returns the index of an element within its parent for a selected set of
1400
+ * elements
1401
+ * @param {HTMLElement} el
1402
+ * @param {selector} selector
1403
+ * @return {number}
1404
+ */
1405
+ function _index(el, selector) {
1406
+ var index = 0;
1407
+
1408
+ if (!el || !el.parentNode) {
1409
+ return -1;
1410
+ }
1411
+
1412
+ while (el && (el = el.previousElementSibling)) {
1413
+ if ((el.nodeName.toUpperCase() !== 'TEMPLATE') && (selector === '>*' || _matches(el, selector))) {
1414
+ index++;
1415
+ }
1416
+ }
1417
+
1418
+ return index;
1419
+ }
1420
+
1421
+ function _matches(/**HTMLElement*/el, /**String*/selector) {
1422
+ if (el) {
1423
+ selector = selector.split('.');
1424
+
1425
+ var tag = selector.shift().toUpperCase(),
1426
+ re = new RegExp('\\s(' + selector.join('|') + ')(?=\\s)', 'g');
1427
+
1428
+ return (
1429
+ (tag === '' || el.nodeName.toUpperCase() == tag) &&
1430
+ (!selector.length || ((' ' + el.className + ' ').match(re) || []).length == selector.length)
1431
+ );
1432
+ }
1433
+
1434
+ return false;
1435
+ }
1436
+
1437
+ function _throttle(callback, ms) {
1438
+ var args, _this;
1439
+
1440
+ return function () {
1441
+ if (args === void 0) {
1442
+ args = arguments;
1443
+ _this = this;
1444
+
1445
+ setTimeout(function () {
1446
+ if (args.length === 1) {
1447
+ callback.call(_this, args[0]);
1448
+ } else {
1449
+ callback.apply(_this, args);
1450
+ }
1451
+
1452
+ args = void 0;
1453
+ }, ms);
1454
+ }
1455
+ };
1456
+ }
1457
+
1458
+ function _extend(dst, src) {
1459
+ if (dst && src) {
1460
+ for (var key in src) {
1461
+ if (src.hasOwnProperty(key)) {
1462
+ dst[key] = src[key];
1463
+ }
1464
+ }
1465
+ }
1466
+
1467
+ return dst;
1468
+ }
1469
+
1470
+ function _clone(el) {
1471
+ if (Polymer && Polymer.dom) {
1472
+ return Polymer.dom(el).cloneNode(true);
1473
+ }
1474
+ else if ($) {
1475
+ return $(el).clone(true)[0];
1476
+ }
1477
+ else {
1478
+ return el.cloneNode(true);
1479
+ }
1480
+ }
1481
+
1482
+ function _saveInputCheckedState(root) {
1483
+ var inputs = root.getElementsByTagName('input');
1484
+ var idx = inputs.length;
1485
+
1486
+ while (idx--) {
1487
+ var el = inputs[idx];
1488
+ el.checked && savedInputChecked.push(el);
1489
+ }
1490
+ }
1491
+
1492
+ function _nextTick(fn) {
1493
+ return setTimeout(fn, 0);
1494
+ }
1495
+
1496
+ function _cancelNextTick(id) {
1497
+ return clearTimeout(id);
1498
+ }
1499
+
1500
+ // Fixed #973:
1501
+ _on(document, 'touchmove', function (evt) {
1502
+ if (Sortable.active) {
1503
+ evt.preventDefault();
1504
+ }
1505
+ });
1506
+
1507
+ // Export utils
1508
+ Sortable.utils = {
1509
+ on: _on,
1510
+ off: _off,
1511
+ css: _css,
1512
+ find: _find,
1513
+ is: function (el, selector) {
1514
+ return !!_closest(el, selector, el);
1515
+ },
1516
+ extend: _extend,
1517
+ throttle: _throttle,
1518
+ closest: _closest,
1519
+ toggleClass: _toggleClass,
1520
+ clone: _clone,
1521
+ index: _index,
1522
+ nextTick: _nextTick,
1523
+ cancelNextTick: _cancelNextTick
1524
+ };
1525
+
1526
+
1527
+ /**
1528
+ * Create sortable instance
1529
+ * @param {HTMLElement} el
1530
+ * @param {Object} [options]
1531
+ */
1532
+ Sortable.create = function (el, options) {
1533
+ return new Sortable(el, options);
1534
+ };
1535
+
1536
+
1537
+ // Export
1538
+ Sortable.version = '1.7.0';
1539
+ return Sortable;
1540
1540
  });