text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(1);
  module.exports = __webpack_require__(5);
  
  
  /***/ }),
  /* 1 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sb_admin_2_js__ = __webpack_require__(2);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sb_admin_2_js___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__sb_admin_2_js__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_jquery_repeater__ = __webpack_require__(3);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_jquery_repeater___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_jquery_repeater__);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_sortablejs__ = __webpack_require__(4);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_sortablejs___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_sortablejs__);
  
  
  
  
  $(function () {
      var csrf_token = document.querySelector('meta[name="csrf_token"]').content;
      $('#side-menu').metisMenu();
  
      /*$('#dataTables-example').DataTable({
          responsive: true
      });*/
  
      $('.repeater').repeater({
          show: function show() {
              $(this).show();
              $(this).find('select').prop('disabled', false);
              $(this).find('.no-repeat').prop('disabled', true);
          }
      });
  
      $('.sortable').each(function () {
          var $this = $(this);
          new __WEBPACK_IMPORTED_MODULE_2_sortablejs__(this, {
              animation: 150,
              handle: ".sort-handle",
              onUpdate: function onUpdate(e) {
                  $this.prev().find('.d-none').removeClass('d-none');
                  console.log($this);
                  var arr = [];
                  $(e.from.children).each(function (i) {
                      var id = $(this).data('device-id');
                      arr.push([id, i]);
                  });
                  $.ajax(window.rootUrl + '/admin/devices/set_order', {
                      method: 'post',
                      data: {
                          _token: csrf_token,
                          data: arr
                      },
                      success: function success() {
                          $this.prev().find('.loading').addClass('d-none');
                      }
                  });
              }
          });
      });
      $('.sortable-list').each(function () {
          new __WEBPACK_IMPORTED_MODULE_2_sortablejs__(this, {
              animation: 150,
              handle: ".sort-handle"
          });
      });
  
      $('#lfm').filemanager('image', { prefix: window.rootUrl + '/laravel-filemanager' });
  });
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports) {
  
  /*!
   * Start Bootstrap - SB Admin 2 v3.3.7+1 (http://startbootstrap.com/template-overviews/sb-admin-2)
   * Copyright 2013-2016 Start Bootstrap
   * Licensed under MIT (https://github.com/BlackrockDigital/startbootstrap/blob/gh-pages/LICENSE)
   */
  
  //Loads the correct sidebar on window load,
  //collapses the sidebar on window resize.
  // Sets the min-height of #page-wrapper to window size
  $(function () {
  
      $(window).bind("load resize", function () {
          var topOffset = 50;
          var width = this.window.innerWidth > 0 ? this.window.innerWidth : this.screen.width;
          if (width < 768) {
              $('div.navbar-collapse').addClass('collapse');
              topOffset = 100; // 2-row-menu
          } else {
              $('div.navbar-collapse').removeClass('collapse');
          }
  
          var height = (this.window.innerHeight > 0 ? this.window.innerHeight : this.screen.height) - 1;
          height = height - topOffset;
          if (height < 1) height = 1;
          if (height > topOffset) {
              $("#page-wrapper").css("min-height", height + "px");
          }
      });
  
      var url = window.location;
      // var element = $('ul.nav a').filter(function() {
      //     return this.href == url;
      // }).addClass('active').parent().parent().addClass('in').parent();
      var element = $('ul.nav a').filter(function () {
          return this.href == url;
      }).addClass('active').parent();
  
      while (true) {
          if (element.is('li')) {
              element = element.parent().addClass('in').parent();
          } else {
              break;
          }
      }
  });
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports) {
  
  // jquery.repeater version 1.2.1
  // https://github.com/DubFriend/jquery.repeater
  // (MIT) 09-10-2016
  // Brian Detering <BDeterin@gmail.com> (http://www.briandetering.net/)
  (function ($) {
  'use strict';
  
  var identity = function (x) {
      return x;
  };
  
  var isArray = function (value) {
      return $.isArray(value);
  };
  
  var isObject = function (value) {
      return !isArray(value) && (value instanceof Object);
  };
  
  var isNumber = function (value) {
      return value instanceof Number;
  };
  
  var isFunction = function (value) {
      return value instanceof Function;
  };
  
  var indexOf = function (object, value) {
      return $.inArray(value, object);
  };
  
  var inArray = function (array, value) {
      return indexOf(array, value) !== -1;
  };
  
  var foreach = function (collection, callback) {
      for(var i in collection) {
          if(collection.hasOwnProperty(i)) {
              callback(collection[i], i, collection);
          }
      }
  };
  
  
  var last = function (array) {
      return array[array.length - 1];
  };
  
  var argumentsToArray = function (args) {
      return Array.prototype.slice.call(args);
  };
  
  var extend = function () {
      var extended = {};
      foreach(argumentsToArray(arguments), function (o) {
          foreach(o, function (val, key) {
              extended[key] = val;
          });
      });
      return extended;
  };
  
  var mapToArray = function (collection, callback) {
      var mapped = [];
      foreach(collection, function (value, key, coll) {
          mapped.push(callback(value, key, coll));
      });
      return mapped;
  };
  
  var mapToObject = function (collection, callback, keyCallback) {
      var mapped = {};
      foreach(collection, function (value, key, coll) {
          key = keyCallback ? keyCallback(key, value) : key;
          mapped[key] = callback(value, key, coll);
      });
      return mapped;
  };
  
  var map = function (collection, callback, keyCallback) {
      return isArray(collection) ?
          mapToArray(collection, callback) :
          mapToObject(collection, callback, keyCallback);
  };
  
  var pluck = function (arrayOfObjects, key) {
      return map(arrayOfObjects, function (val) {
          return val[key];
      });
  };
  
  var filter = function (collection, callback) {
      var filtered;
  
      if(isArray(collection)) {
          filtered = [];
          foreach(collection, function (val, key, coll) {
              if(callback(val, key, coll)) {
                  filtered.push(val);
              }
          });
      }
      else {
          filtered = {};
          foreach(collection, function (val, key, coll) {
              if(callback(val, key, coll)) {
                  filtered[key] = val;
              }
          });
      }
  
      return filtered;
  };
  
  var call = function (collection, functionName, args) {
      return map(collection, function (object, name) {
          return object[functionName].apply(object, args || []);
      });
  };
  
  //execute callback immediately and at most one time on the minimumInterval,
  //ignore block attempts
  var throttle = function (minimumInterval, callback) {
      var timeout = null;
      return function () {
          var that = this, args = arguments;
          if(timeout === null) {
              timeout = setTimeout(function () {
                  timeout = null;
              }, minimumInterval);
              callback.apply(that, args);
          }
      };
  };
  
  
  var mixinPubSub = function (object) {
      object = object || {};
      var topics = {};
  
      object.publish = function (topic, data) {
          foreach(topics[topic], function (callback) {
              callback(data);
          });
      };
  
      object.subscribe = function (topic, callback) {
          topics[topic] = topics[topic] || [];
          topics[topic].push(callback);
      };
  
      object.unsubscribe = function (callback) {
          foreach(topics, function (subscribers) {
              var index = indexOf(subscribers, callback);
              if(index !== -1) {
                  subscribers.splice(index, 1);
              }
          });
      };
  
      return object;
  };
  
  // jquery.input version 0.0.0
  // https://github.com/DubFriend/jquery.input
  // (MIT) 09-04-2014
  // Brian Detering <BDeterin@gmail.com> (http://www.briandetering.net/)
  (function ($) {
  'use strict';
  
  var createBaseInput = function (fig, my) {
      var self = mixinPubSub(),
          $self = fig.$;
  
      self.getType = function () {
          throw 'implement me (return type. "text", "radio", etc.)';
      };
  
      self.$ = function (selector) {
          return selector ? $self.find(selector) : $self;
      };
  
      self.disable = function () {
          self.$().prop('disabled', true);
          self.publish('isEnabled', false);
      };
  
      self.enable = function () {
          self.$().prop('disabled', false);
          self.publish('isEnabled', true);
      };
  
      my.equalTo = function (a, b) {
          return a === b;
      };
  
      my.publishChange = (function () {
          var oldValue;
          return function (e, domElement) {
              var newValue = self.get();
              if(!my.equalTo(newValue, oldValue)) {
                  self.publish('change', { e: e, domElement: domElement });
              }
              oldValue = newValue;
          };
      }());
  
      return self;
  };
  
  
  var createInput = function (fig, my) {
      var self = createBaseInput(fig, my);
  
      self.get = function () {
          return self.$().val();
      };
  
      self.set = function (newValue) {
          self.$().val(newValue);
      };
  
      self.clear = function () {
          self.set('');
      };
  
      my.buildSetter = function (callback) {
          return function (newValue) {
              callback.call(self, newValue);
          };
      };
  
      return self;
  };
  
  var inputEqualToArray = function (a, b) {
      a = isArray(a) ? a : [a];
      b = isArray(b) ? b : [b];
  
      var isEqual = true;
      if(a.length !== b.length) {
          isEqual = false;
      }
      else {
          foreach(a, function (value) {
              if(!inArray(b, value)) {
                  isEqual = false;
              }
          });
      }
  
      return isEqual;
  };
  
  var createInputButton = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'button';
      };
  
      self.$().on('change', function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputCheckbox = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'checkbox';
      };
  
      self.get = function () {
          var values = [];
          self.$().filter(':checked').each(function () {
              values.push($(this).val());
          });
          return values;
      };
  
      self.set = function (newValues) {
          newValues = isArray(newValues) ? newValues : [newValues];
  
          self.$().each(function () {
              $(this).prop('checked', false);
          });
  
          foreach(newValues, function (value) {
              self.$().filter('[value="' + value + '"]')
                  .prop('checked', true);
          });
      };
  
      my.equalTo = inputEqualToArray;
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputEmail = function (fig) {
      var my = {},
          self = createInputText(fig, my);
  
      self.getType = function () {
          return 'email';
      };
  
      return self;
  };
  
  var createInputFile = function (fig) {
      var my = {},
          self = createBaseInput(fig, my);
  
      self.getType = function () {
          return 'file';
      };
  
      self.get = function () {
          return last(self.$().val().split('\\'));
      };
  
      self.clear = function () {
          // http://stackoverflow.com/questions/1043957/clearing-input-type-file-using-jquery
          this.$().each(function () {
              $(this).wrap('<form>').closest('form').get(0).reset();
              $(this).unwrap();
          });
      };
  
      self.$().change(function (e) {
          my.publishChange(e, this);
          // self.publish('change', self);
      });
  
      return self;
  };
  
  var createInputHidden = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'hidden';
      };
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  var createInputMultipleFile = function (fig) {
      var my = {},
          self = createBaseInput(fig, my);
  
      self.getType = function () {
          return 'file[multiple]';
      };
  
      self.get = function () {
          // http://stackoverflow.com/questions/14035530/how-to-get-value-of-html-5-multiple-file-upload-variable-using-jquery
          var fileListObject = self.$().get(0).files || [],
              names = [], i;
  
          for(i = 0; i < (fileListObject.length || 0); i += 1) {
              names.push(fileListObject[i].name);
          }
  
          return names;
      };
  
      self.clear = function () {
          // http://stackoverflow.com/questions/1043957/clearing-input-type-file-using-jquery
          this.$().each(function () {
              $(this).wrap('<form>').closest('form').get(0).reset();
              $(this).unwrap();
          });
      };
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputMultipleSelect = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'select[multiple]';
      };
  
      self.get = function () {
          return self.$().val() || [];
      };
  
      self.set = function (newValues) {
          self.$().val(
              newValues === '' ? [] : isArray(newValues) ? newValues : [newValues]
          );
      };
  
      my.equalTo = inputEqualToArray;
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputPassword = function (fig) {
      var my = {},
          self = createInputText(fig, my);
  
      self.getType = function () {
          return 'password';
      };
  
      return self;
  };
  
  var createInputRadio = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'radio';
      };
  
      self.get = function () {
          return self.$().filter(':checked').val() || null;
      };
  
      self.set = function (newValue) {
          if(!newValue) {
              self.$().each(function () {
                  $(this).prop('checked', false);
              });
          }
          else {
              self.$().filter('[value="' + newValue + '"]').prop('checked', true);
          }
      };
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputRange = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'range';
      };
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputSelect = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'select';
      };
  
      self.$().change(function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputText = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'text';
      };
  
      self.$().on('change keyup keydown', function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputTextarea = function (fig) {
      var my = {},
          self = createInput(fig, my);
  
      self.getType = function () {
          return 'textarea';
      };
  
      self.$().on('change keyup keydown', function (e) {
          my.publishChange(e, this);
      });
  
      return self;
  };
  
  var createInputURL = function (fig) {
      var my = {},
          self = createInputText(fig, my);
  
      self.getType = function () {
          return 'url';
      };
  
      return self;
  };
  
  var buildFormInputs = function (fig) {
      var inputs = {},
          $self = fig.$;
  
      var constructor = fig.constructorOverride || {
          button: createInputButton,
          text: createInputText,
          url: createInputURL,
          email: createInputEmail,
          password: createInputPassword,
          range: createInputRange,
          textarea: createInputTextarea,
          select: createInputSelect,
          'select[multiple]': createInputMultipleSelect,
          radio: createInputRadio,
          checkbox: createInputCheckbox,
          file: createInputFile,
          'file[multiple]': createInputMultipleFile,
          hidden: createInputHidden
      };
  
      var addInputsBasic = function (type, selector) {
          var $input = isObject(selector) ? selector : $self.find(selector);
  
          $input.each(function () {
              var name = $(this).attr('name');
              inputs[name] = constructor[type]({
                  $: $(this)
              });
          });
      };
  
      var addInputsGroup = function (type, selector) {
          var names = [],
              $input = isObject(selector) ? selector : $self.find(selector);
  
          if(isObject(selector)) {
              inputs[$input.attr('name')] = constructor[type]({
                  $: $input
              });
          }
          else {
              // group by name attribute
              $input.each(function () {
                  if(indexOf(names, $(this).attr('name')) === -1) {
                      names.push($(this).attr('name'));
                  }
              });
  
              foreach(names, function (name) {
                  inputs[name] = constructor[type]({
                      $: $self.find('input[name="' + name + '"]')
                  });
              });
          }
      };
  
  
      if($self.is('input, select, textarea')) {
          if($self.is('input[type="button"], button, input[type="submit"]')) {
              addInputsBasic('button', $self);
          }
          else if($self.is('textarea')) {
              addInputsBasic('textarea', $self);
          }
          else if(
              $self.is('input[type="text"]') ||
              $self.is('input') && !$self.attr('type')
          ) {
              addInputsBasic('text', $self);
          }
          else if($self.is('input[type="password"]')) {
              addInputsBasic('password', $self);
          }
          else if($self.is('input[type="email"]')) {
              addInputsBasic('email', $self);
          }
          else if($self.is('input[type="url"]')) {
              addInputsBasic('url', $self);
          }
          else if($self.is('input[type="range"]')) {
              addInputsBasic('range', $self);
          }
          else if($self.is('select')) {
              if($self.is('[multiple]')) {
                  addInputsBasic('select[multiple]', $self);
              }
              else {
                  addInputsBasic('select', $self);
              }
          }
          else if($self.is('input[type="file"]')) {
              if($self.is('[multiple]')) {
                  addInputsBasic('file[multiple]', $self);
              }
              else {
                  addInputsBasic('file', $self);
              }
          }
          else if($self.is('input[type="hidden"]')) {
              addInputsBasic('hidden', $self);
          }
          else if($self.is('input[type="radio"]')) {
              addInputsGroup('radio', $self);
          }
          else if($self.is('input[type="checkbox"]')) {
              addInputsGroup('checkbox', $self);
          }
          else {
              //in all other cases default to a "text" input interface.
              addInputsBasic('text', $self);
          }
      }
      else {
          addInputsBasic('button', 'input[type="button"], button, input[type="submit"]');
          addInputsBasic('text', 'input[type="text"]');
          addInputsBasic('password', 'input[type="password"]');
          addInputsBasic('email', 'input[type="email"]');
          addInputsBasic('url', 'input[type="url"]');
          addInputsBasic('range', 'input[type="range"]');
          addInputsBasic('textarea', 'textarea');
          addInputsBasic('select', 'select:not([multiple])');
          addInputsBasic('select[multiple]', 'select[multiple]');
          addInputsBasic('file', 'input[type="file"]:not([multiple])');
          addInputsBasic('file[multiple]', 'input[type="file"][multiple]');
          addInputsBasic('hidden', 'input[type="hidden"]');
          addInputsGroup('radio', 'input[type="radio"]');
          addInputsGroup('checkbox', 'input[type="checkbox"]');
      }
  
      return inputs;
  };
  
  $.fn.inputVal = function (newValue) {
      var $self = $(this);
  
      var inputs = buildFormInputs({ $: $self });
  
      if($self.is('input, textarea, select')) {
          if(typeof newValue === 'undefined') {
              return inputs[$self.attr('name')].get();
          }
          else {
              inputs[$self.attr('name')].set(newValue);
              return $self;
          }
      }
      else {
          if(typeof newValue === 'undefined') {
              return call(inputs, 'get');
          }
          else {
              foreach(newValue, function (value, inputName) {
                  inputs[inputName].set(value);
              });
              return $self;
          }
      }
  };
  
  $.fn.inputOnChange = function (callback) {
      var $self = $(this);
      var inputs = buildFormInputs({ $: $self });
      foreach(inputs, function (input) {
          input.subscribe('change', function (data) {
              callback.call(data.domElement, data.e);
          });
      });
      return $self;
  };
  
  $.fn.inputDisable = function () {
      var $self = $(this);
      call(buildFormInputs({ $: $self }), 'disable');
      return $self;
  };
  
  $.fn.inputEnable = function () {
      var $self = $(this);
      call(buildFormInputs({ $: $self }), 'enable');
      return $self;
  };
  
  $.fn.inputClear = function () {
      var $self = $(this);
      call(buildFormInputs({ $: $self }), 'clear');
      return $self;
  };
  
  }(jQuery));
  
  $.fn.repeaterVal = function () {
      var parse = function (raw) {
          var parsed = [];
  
          foreach(raw, function (val, key) {
              var parsedKey = [];
              if(key !== "undefined") {
                  parsedKey.push(key.match(/^[^\[]*/)[0]);
                  parsedKey = parsedKey.concat(map(
                      key.match(/\[[^\]]*\]/g),
                      function (bracketed) {
                          return bracketed.replace(/[\[\]]/g, '');
                      }
                  ));
  
                  parsed.push({
                      val: val,
                      key: parsedKey
                  });
              }
          });
  
          return parsed;
      };
  
      var build = function (parsed) {
          if(
              parsed.length === 1 &&
              (parsed[0].key.length === 0 || parsed[0].key.length === 1 && !parsed[0].key[0])
          ) {
              return parsed[0].val;
          }
  
          foreach(parsed, function (p) {
              p.head = p.key.shift();
          });
  
          var grouped = (function () {
              var grouped = {};
  
              foreach(parsed, function (p) {
                  if(!grouped[p.head]) {
                      grouped[p.head] = [];
                  }
                  grouped[p.head].push(p);
              });
  
              return grouped;
          }());
  
          var built;
  
          if(/^[0-9]+$/.test(parsed[0].head)) {
              built = [];
              foreach(grouped, function (group) {
                  built.push(build(group));
              });
          }
          else {
              built = {};
              foreach(grouped, function (group, key) {
                  built[key] = build(group);
              });
          }
  
          return built;
      };
  
      return build(parse($(this).inputVal()));
  };
  
  $.fn.repeater = function (fig) {
      fig = fig || {};
  
      var setList;
  
      $(this).each(function () {
  
          var $self = $(this);
  
          var show = fig.show || function () {
              $(this).show();
          };
  
          var hide = fig.hide || function (removeElement) {
              removeElement();
          };
  
          var $list = $self.find('[data-repeater-list]').first();
  
          var $filterNested = function ($items, repeaters) {
              return $items.filter(function () {
                  return repeaters ?
                      $(this).closest(
                          pluck(repeaters, 'selector').join(',')
                      ).length === 0 : true;
              });
          };
  
          var $items = function () {
              return $filterNested($list.find('[data-repeater-item]'), fig.repeaters);
          };
  
          var $itemTemplate = $list.find('[data-repeater-item]')
                                   .first().clone().hide();
  
          var $firstDeleteButton = $filterNested(
              $filterNested($(this).find('[data-repeater-item]'), fig.repeaters)
              .first().find('[data-repeater-delete]'),
              fig.repeaters
          );
  
          if(fig.isFirstItemUndeletable && $firstDeleteButton) {
              $firstDeleteButton.remove();
          }
  
          var getGroupName = function () {
              var groupName = $list.data('repeater-list');
              return fig.$parent ?
                  fig.$parent.data('item-name') + '[' + groupName + ']' :
                  groupName;
          };
  
          var initNested = function ($listItems) {
              if(fig.repeaters) {
                  $listItems.each(function () {
                      var $item = $(this);
                      foreach(fig.repeaters, function (nestedFig) {
                          $item.find(nestedFig.selector).repeater(extend(
                              nestedFig, { $parent: $item }
                          ));
                      });
                  });
              }
          };
  
          var $foreachRepeaterInItem = function (repeaters, $item, cb) {
              if(repeaters) {
                  foreach(repeaters, function (nestedFig) {
                      cb.call($item.find(nestedFig.selector)[0], nestedFig);
                  });
              }
          };
  
          var setIndexes = function ($items, groupName, repeaters) {
              $items.each(function (index) {
                  var $item = $(this);
                  $item.data('item-name', groupName + '[' + index + ']');
                  $filterNested($item.find('[name]'), repeaters)
                  .each(function () {
                      var $input = $(this);
                      // match non empty brackets (ex: "[foo]")
                      var matches = $input.attr('name').match(/\[[^\]]+\]/g);
  
                      var name = matches ?
                          // strip "[" and "]" characters
                          last(matches).replace(/\[|\]/g, '') :
                          $input.attr('name');
  
  
                      var newName = groupName + '[' + index + '][' + name + ']' +
                          ($input.is(':checkbox') || $input.attr('multiple') ? '[]' : '');
  
                      $input.attr('name', newName);
  
                      $foreachRepeaterInItem(repeaters, $item, function (nestedFig) {
                          var $repeater = $(this);
                          setIndexes(
                              $filterNested($repeater.find('[data-repeater-item]'), nestedFig.repeaters || []),
                              groupName + '[' + index + ']' +
                                          '[' + $repeater.find('[data-repeater-list]').first().data('repeater-list') + ']',
                              nestedFig.repeaters
                          );
                      });
                  });
              });
  
              $list.find('input[name][checked]')
                  .removeAttr('checked')
                  .prop('checked', true);
          };
  
          setIndexes($items(), getGroupName(), fig.repeaters);
          initNested($items());
          if(fig.initEmpty) {
              $items().remove();
          }
  
          if(fig.ready) {
              fig.ready(function () {
                  setIndexes($items(), getGroupName(), fig.repeaters);
              });
          }
  
          var appendItem = (function () {
              var setItemsValues = function ($item, data, repeaters) {
                  if(data || fig.defaultValues) {
                      var inputNames = {};
                      $filterNested($item.find('[name]'), repeaters).each(function () {
                          var key = $(this).attr('name').match(/\[([^\]]*)(\]|\]\[\])$/)[1];
                          inputNames[key] = $(this).attr('name');
                      });
  
                      $item.inputVal(map(
                          filter(data || fig.defaultValues, function (val, name) {
                              return inputNames[name];
                          }),
                          identity,
                          function (name) {
                              return inputNames[name];
                          }
                      ));
                  }
  
  
                  $foreachRepeaterInItem(repeaters, $item, function (nestedFig) {
                      var $repeater = $(this);
                      $filterNested(
                          $repeater.find('[data-repeater-item]'),
                          nestedFig.repeaters
                      )
                      .each(function () {
                          var fieldName = $repeater.find('[data-repeater-list]').data('repeater-list');
                          if(data && data[fieldName]) {
                              var $template = $(this).clone();
                              $repeater.find('[data-repeater-item]').remove();
                              foreach(data[fieldName], function (data) {
                                  var $item = $template.clone();
                                  setItemsValues(
                                      $item,
                                      data,
                                      nestedFig.repeaters || []
                                  );
                                  $repeater.find('[data-repeater-list]').append($item);
                              });
                          }
                          else {
                              setItemsValues(
                                  $(this),
                                  nestedFig.defaultValues,
                                  nestedFig.repeaters || []
                              );
                          }
                      });
                  });
  
              };
  
              return function ($item, data) {
                  $list.append($item);
                  setIndexes($items(), getGroupName(), fig.repeaters);
                  $item.find('[name]').each(function () {
                      $(this).inputClear();
                  });
                  setItemsValues($item, data || fig.defaultValues, fig.repeaters);
              };
          }());
  
          var addItem = function (data) {
              var $item = $itemTemplate.clone();
              appendItem($item, data);
              if(fig.repeaters) {
                  initNested($item);
              }
              show.call($item.get(0));
          };
  
          setList = function (rows) {
              $items().remove();
              foreach(rows, addItem);
          };
  
          $filterNested($self.find('[data-repeater-create]'), fig.repeaters).click(function () {
              addItem();
          });
  
          $list.on('click', '[data-repeater-delete]', function () {
              var self = $(this).closest('[data-repeater-item]').get(0);
              hide.call(self, function () {
                  $(self).remove();
                  setIndexes($items(), getGroupName(), fig.repeaters);
              });
          });
      });
  
      this.setList = setList;
  
      return this;
  };
  
  }(jQuery));
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**!
   * Sortable
   * @author	RubaXa   <trash@rubaxa.org>
   * @license MIT
   */
  
  (function sortableModule(factory) {
  	"use strict";
  
  	if (true) {
  		!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
  				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
  				__WEBPACK_AMD_DEFINE_FACTORY__),
  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  	}
  	else if (typeof module != "undefined" && typeof module.exports != "undefined") {
  		module.exports = factory();
  	}
  	else {
  		/* jshint sub:true */
  		window["Sortable"] = factory();
  	}
  })(function sortableFactory() {
  	"use strict";
  
  	if (typeof window === "undefined" || !window.document) {
  		return function sortableError() {
  			throw new Error("Sortable.js requires a window with a document");
  		};
  	}
  
  	var dragEl,
  		parentEl,
  		ghostEl,
  		cloneEl,
  		rootEl,
  		nextEl,
  		lastDownEl,
  
  		scrollEl,
  		scrollParentEl,
  		scrollCustomFn,
  
  		lastEl,
  		lastCSS,
  		lastParentCSS,
  
  		oldIndex,
  		newIndex,
  
  		activeGroup,
  		putSortable,
  
  		autoScroll = {},
  
  		tapEvt,
  		touchEvt,
  
  		moved,
  
  		/** @const */
  		R_SPACE = /\s+/g,
  		R_FLOAT = /left|right|inline/,
  
  		expando = 'Sortable' + (new Date).getTime(),
  
  		win = window,
  		document = win.document,
  		parseInt = win.parseInt,
  		setTimeout = win.setTimeout,
  
  		$ = win.jQuery || win.Zepto,
  		Polymer = win.Polymer,
  
  		captureMode = false,
  		passiveMode = false,
  
  		supportDraggable = ('draggable' in document.createElement('div')),
  		supportCssPointerEvents = (function (el) {
  			// false when IE11
  			if (!!navigator.userAgent.match(/(?:Trident.*rv[ :]?11\.|msie)/i)) {
  				return false;
  			}
  			el = document.createElement('x');
  			el.style.cssText = 'pointer-events:auto';
  			return el.style.pointerEvents === 'auto';
  		})(),
  
  		_silent = false,
  
  		abs = Math.abs,
  		min = Math.min,
  
  		savedInputChecked = [],
  		touchDragOverListeners = [],
  
  		_autoScroll = _throttle(function (/**Event*/evt, /**Object*/options, /**HTMLElement*/rootEl) {
  			// Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
  			if (rootEl && options.scroll) {
  				var _this = rootEl[expando],
  					el,
  					rect,
  					sens = options.scrollSensitivity,
  					speed = options.scrollSpeed,
  
  					x = evt.clientX,
  					y = evt.clientY,
  
  					winWidth = window.innerWidth,
  					winHeight = window.innerHeight,
  
  					vx,
  					vy,
  
  					scrollOffsetX,
  					scrollOffsetY
  				;
  
  				// Delect scrollEl
  				if (scrollParentEl !== rootEl) {
  					scrollEl = options.scroll;
  					scrollParentEl = rootEl;
  					scrollCustomFn = options.scrollFn;
  
  					if (scrollEl === true) {
  						scrollEl = rootEl;
  
  						do {
  							if ((scrollEl.offsetWidth < scrollEl.scrollWidth) ||
  								(scrollEl.offsetHeight < scrollEl.scrollHeight)
  							) {
  								break;
  							}
  							/* jshint boss:true */
  						} while (scrollEl = scrollEl.parentNode);
  					}
  				}
  
  				if (scrollEl) {
  					el = scrollEl;
  					rect = scrollEl.getBoundingClientRect();
  					vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
  					vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens);
  				}
  
  
  				if (!(vx || vy)) {
  					vx = (winWidth - x <= sens) - (x <= sens);
  					vy = (winHeight - y <= sens) - (y <= sens);
  
  					/* jshint expr:true */
  					(vx || vy) && (el = win);
  				}
  
  
  				if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
  					autoScroll.el = el;
  					autoScroll.vx = vx;
  					autoScroll.vy = vy;
  
  					clearInterval(autoScroll.pid);
  
  					if (el) {
  						autoScroll.pid = setInterval(function () {
  							scrollOffsetY = vy ? vy * speed : 0;
  							scrollOffsetX = vx ? vx * speed : 0;
  
  							if ('function' === typeof(scrollCustomFn)) {
  								return scrollCustomFn.call(_this, scrollOffsetX, scrollOffsetY, evt);
  							}
  
  							if (el === win) {
  								win.scrollTo(win.pageXOffset + scrollOffsetX, win.pageYOffset + scrollOffsetY);
  							} else {
  								el.scrollTop += scrollOffsetY;
  								el.scrollLeft += scrollOffsetX;
  							}
  						}, 24);
  					}
  				}
  			}
  		}, 30),
  
  		_prepareGroup = function (options) {
  			function toFn(value, pull) {
  				if (value === void 0 || value === true) {
  					value = group.name;
  				}
  
  				if (typeof value === 'function') {
  					return value;
  				} else {
  					return function (to, from) {
  						var fromGroup = from.options.group.name;
  
  						return pull
  							? value
  							: value && (value.join
  								? value.indexOf(fromGroup) > -1
  								: (fromGroup == value)
  							);
  					};
  				}
  			}
  
  			var group = {};
  			var originalGroup = options.group;
  
  			if (!originalGroup || typeof originalGroup != 'object') {
  				originalGroup = {name: originalGroup};
  			}
  
  			group.name = originalGroup.name;
  			group.checkPull = toFn(originalGroup.pull, true);
  			group.checkPut = toFn(originalGroup.put);
  			group.revertClone = originalGroup.revertClone;
  
  			options.group = group;
  		}
  	;
  
  	// Detect support a passive mode
  	try {
  		window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
  			get: function () {
  				// `false`, because everything starts to work incorrectly and instead of d'n'd,
  				// begins the page has scrolled.
  				passiveMode = false;
  				captureMode = {
  					capture: false,
  					passive: passiveMode
  				};
  			}
  		}));
  	} catch (err) {}
  
  	/**
  	 * @class  Sortable
  	 * @param  {HTMLElement}  el
  	 * @param  {Object}       [options]
  	 */
  	function Sortable(el, options) {
  		if (!(el && el.nodeType && el.nodeType === 1)) {
  			throw 'Sortable: `el` must be HTMLElement, and not ' + {}.toString.call(el);
  		}
  
  		this.el = el; // root element
  		this.options = options = _extend({}, options);
  
  
  		// Export instance
  		el[expando] = this;
  
  		// Default options
  		var defaults = {
  			group: Math.random(),
  			sort: true,
  			disabled: false,
  			store: null,
  			handle: null,
  			scroll: true,
  			scrollSensitivity: 30,
  			scrollSpeed: 10,
  			draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
  			ghostClass: 'sortable-ghost',
  			chosenClass: 'sortable-chosen',
  			dragClass: 'sortable-drag',
  			ignore: 'a, img',
  			filter: null,
  			preventOnFilter: true,
  			animation: 0,
  			setData: function (dataTransfer, dragEl) {
  				dataTransfer.setData('Text', dragEl.textContent);
  			},
  			dropBubble: false,
  			dragoverBubble: false,
  			dataIdAttr: 'data-id',
  			delay: 0,
  			forceFallback: false,
  			fallbackClass: 'sortable-fallback',
  			fallbackOnBody: false,
  			fallbackTolerance: 0,
  			fallbackOffset: {x: 0, y: 0},
  			supportPointer: Sortable.supportPointer !== false
  		};
  
  
  		// Set default options
  		for (var name in defaults) {
  			!(name in options) && (options[name] = defaults[name]);
  		}
  
  		_prepareGroup(options);
  
  		// Bind all private methods
  		for (var fn in this) {
  			if (fn.charAt(0) === '_' && typeof this[fn] === 'function') {
  				this[fn] = this[fn].bind(this);
  			}
  		}
  
  		// Setup drag mode
  		this.nativeDraggable = options.forceFallback ? false : supportDraggable;
  
  		// Bind events
  		_on(el, 'mousedown', this._onTapStart);
  		_on(el, 'touchstart', this._onTapStart);
  		options.supportPointer && _on(el, 'pointerdown', this._onTapStart);
  
  		if (this.nativeDraggable) {
  			_on(el, 'dragover', this);
  			_on(el, 'dragenter', this);
  		}
  
  		touchDragOverListeners.push(this._onDragOver);
  
  		// Restore sorting
  		options.store && this.sort(options.store.get(this));
  	}
  
  
  	Sortable.prototype = /** @lends Sortable.prototype */ {
  		constructor: Sortable,
  
  		_onTapStart: function (/** Event|TouchEvent */evt) {
  			var _this = this,
  				el = this.el,
  				options = this.options,
  				preventOnFilter = options.preventOnFilter,
  				type = evt.type,
  				touch = evt.touches && evt.touches[0],
  				target = (touch || evt).target,
  				originalTarget = evt.target.shadowRoot && (evt.path && evt.path[0]) || target,
  				filter = options.filter,
  				startIndex;
  
  			_saveInputCheckedState(el);
  
  
  			// Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group.
  			if (dragEl) {
  				return;
  			}
  
  			if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) {
  				return; // only left button or enabled
  			}
  
  			// cancel dnd if original target is content editable
  			if (originalTarget.isContentEditable) {
  				return;
  			}
  
  			target = _closest(target, options.draggable, el);
  
  			if (!target) {
  				return;
  			}
  
  			if (lastDownEl === target) {
  				// Ignoring duplicate `down`
  				return;
  			}
  
  			// Get the index of the dragged element within its parent
  			startIndex = _index(target, options.draggable);
  
  			// Check filter
  			if (typeof filter === 'function') {
  				if (filter.call(this, evt, target, this)) {
  					_dispatchEvent(_this, originalTarget, 'filter', target, el, el, startIndex);
  					preventOnFilter && evt.preventDefault();
  					return; // cancel dnd
  				}
  			}
  			else if (filter) {
  				filter = filter.split(',').some(function (criteria) {
  					criteria = _closest(originalTarget, criteria.trim(), el);
  
  					if (criteria) {
  						_dispatchEvent(_this, criteria, 'filter', target, el, el, startIndex);
  						return true;
  					}
  				});
  
  				if (filter) {
  					preventOnFilter && evt.preventDefault();
  					return; // cancel dnd
  				}
  			}
  
  			if (options.handle && !_closest(originalTarget, options.handle, el)) {
  				return;
  			}
  
  			// Prepare `dragstart`
  			this._prepareDragStart(evt, touch, target, startIndex);
  		},
  
  		_prepareDragStart: function (/** Event */evt, /** Touch */touch, /** HTMLElement */target, /** Number */startIndex) {
  			var _this = this,
  				el = _this.el,
  				options = _this.options,
  				ownerDocument = el.ownerDocument,
  				dragStartFn;
  
  			if (target && !dragEl && (target.parentNode === el)) {
  				tapEvt = evt;
  
  				rootEl = el;
  				dragEl = target;
  				parentEl = dragEl.parentNode;
  				nextEl = dragEl.nextSibling;
  				lastDownEl = target;
  				activeGroup = options.group;
  				oldIndex = startIndex;
  
  				this._lastX = (touch || evt).clientX;
  				this._lastY = (touch || evt).clientY;
  
  				dragEl.style['will-change'] = 'all';
  
  				dragStartFn = function () {
  					// Delayed drag has been triggered
  					// we can re-enable the events: touchmove/mousemove
  					_this._disableDelayedDrag();
  
  					// Make the element draggable
  					dragEl.draggable = _this.nativeDraggable;
  
  					// Chosen item
  					_toggleClass(dragEl, options.chosenClass, true);
  
  					// Bind the events: dragstart/dragend
  					_this._triggerDragStart(evt, touch);
  
  					// Drag start event
  					_dispatchEvent(_this, rootEl, 'choose', dragEl, rootEl, rootEl, oldIndex);
  				};
  
  				// Disable "draggable"
  				options.ignore.split(',').forEach(function (criteria) {
  					_find(dragEl, criteria.trim(), _disableDraggable);
  				});
  
  				_on(ownerDocument, 'mouseup', _this._onDrop);
  				_on(ownerDocument, 'touchend', _this._onDrop);
  				_on(ownerDocument, 'touchcancel', _this._onDrop);
  				_on(ownerDocument, 'selectstart', _this);
  				options.supportPointer && _on(ownerDocument, 'pointercancel', _this._onDrop);
  
  				if (options.delay) {
  					// If the user moves the pointer or let go the click or touch
  					// before the delay has been reached:
  					// disable the delayed drag
  					_on(ownerDocument, 'mouseup', _this._disableDelayedDrag);
  					_on(ownerDocument, 'touchend', _this._disableDelayedDrag);
  					_on(ownerDocument, 'touchcancel', _this._disableDelayedDrag);
  					_on(ownerDocument, 'mousemove', _this._disableDelayedDrag);
  					_on(ownerDocument, 'touchmove', _this._disableDelayedDrag);
  					options.supportPointer && _on(ownerDocument, 'pointermove', _this._disableDelayedDrag);
  
  					_this._dragStartTimer = setTimeout(dragStartFn, options.delay);
  				} else {
  					dragStartFn();
  				}
  
  
  			}
  		},
  
  		_disableDelayedDrag: function () {
  			var ownerDocument = this.el.ownerDocument;
  
  			clearTimeout(this._dragStartTimer);
  			_off(ownerDocument, 'mouseup', this._disableDelayedDrag);
  			_off(ownerDocument, 'touchend', this._disableDelayedDrag);
  			_off(ownerDocument, 'touchcancel', this._disableDelayedDrag);
  			_off(ownerDocument, 'mousemove', this._disableDelayedDrag);
  			_off(ownerDocument, 'touchmove', this._disableDelayedDrag);
  			_off(ownerDocument, 'pointermove', this._disableDelayedDrag);
  		},
  
  		_triggerDragStart: function (/** Event */evt, /** Touch */touch) {
  			touch = touch || (evt.pointerType == 'touch' ? evt : null);
  
  			if (touch) {
  				// Touch device support
  				tapEvt = {
  					target: dragEl,
  					clientX: touch.clientX,
  					clientY: touch.clientY
  				};
  
  				this._onDragStart(tapEvt, 'touch');
  			}
  			else if (!this.nativeDraggable) {
  				this._onDragStart(tapEvt, true);
  			}
  			else {
  				_on(dragEl, 'dragend', this);
  				_on(rootEl, 'dragstart', this._onDragStart);
  			}
  
  			try {
  				if (document.selection) {
  					// Timeout neccessary for IE9
  					_nextTick(function () {
  						document.selection.empty();
  					});
  				} else {
  					window.getSelection().removeAllRanges();
  				}
  			} catch (err) {
  			}
  		},
  
  		_dragStarted: function () {
  			if (rootEl && dragEl) {
  				var options = this.options;
  
  				// Apply effect
  				_toggleClass(dragEl, options.ghostClass, true);
  				_toggleClass(dragEl, options.dragClass, false);
  
  				Sortable.active = this;
  
  				// Drag start event
  				_dispatchEvent(this, rootEl, 'start', dragEl, rootEl, rootEl, oldIndex);
  			} else {
  				this._nulling();
  			}
  		},
  
  		_emulateDragOver: function () {
  			if (touchEvt) {
  				if (this._lastX === touchEvt.clientX && this._lastY === touchEvt.clientY) {
  					return;
  				}
  
  				this._lastX = touchEvt.clientX;
  				this._lastY = touchEvt.clientY;
  
  				if (!supportCssPointerEvents) {
  					_css(ghostEl, 'display', 'none');
  				}
  
  				var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
  				var parent = target;
  				var i = touchDragOverListeners.length;
  
  				if (target && target.shadowRoot) {
  					target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
  					parent = target;
  				}
  
  				if (parent) {
  					do {
  						if (parent[expando]) {
  							while (i--) {
  								touchDragOverListeners[i]({
  									clientX: touchEvt.clientX,
  									clientY: touchEvt.clientY,
  									target: target,
  									rootEl: parent
  								});
  							}
  
  							break;
  						}
  
  						target = parent; // store last element
  					}
  					/* jshint boss:true */
  					while (parent = parent.parentNode);
  				}
  
  				if (!supportCssPointerEvents) {
  					_css(ghostEl, 'display', '');
  				}
  			}
  		},
  
  
  		_onTouchMove: function (/**TouchEvent*/evt) {
  			if (tapEvt) {
  				var	options = this.options,
  					fallbackTolerance = options.fallbackTolerance,
  					fallbackOffset = options.fallbackOffset,
  					touch = evt.touches ? evt.touches[0] : evt,
  					dx = (touch.clientX - tapEvt.clientX) + fallbackOffset.x,
  					dy = (touch.clientY - tapEvt.clientY) + fallbackOffset.y,
  					translate3d = evt.touches ? 'translate3d(' + dx + 'px,' + dy + 'px,0)' : 'translate(' + dx + 'px,' + dy + 'px)';
  
  				// only set the status to dragging, when we are actually dragging
  				if (!Sortable.active) {
  					if (fallbackTolerance &&
  						min(abs(touch.clientX - this._lastX), abs(touch.clientY - this._lastY)) < fallbackTolerance
  					) {
  						return;
  					}
  
  					this._dragStarted();
  				}
  
  				// as well as creating the ghost element on the document body
  				this._appendGhost();
  
  				moved = true;
  				touchEvt = touch;
  
  				_css(ghostEl, 'webkitTransform', translate3d);
  				_css(ghostEl, 'mozTransform', translate3d);
  				_css(ghostEl, 'msTransform', translate3d);
  				_css(ghostEl, 'transform', translate3d);
  
  				evt.preventDefault();
  			}
  		},
  
  		_appendGhost: function () {
  			if (!ghostEl) {
  				var rect = dragEl.getBoundingClientRect(),
  					css = _css(dragEl),
  					options = this.options,
  					ghostRect;
  
  				ghostEl = dragEl.cloneNode(true);
  
  				_toggleClass(ghostEl, options.ghostClass, false);
  				_toggleClass(ghostEl, options.fallbackClass, true);
  				_toggleClass(ghostEl, options.dragClass, true);
  
  				_css(ghostEl, 'top', rect.top - parseInt(css.marginTop, 10));
  				_css(ghostEl, 'left', rect.left - parseInt(css.marginLeft, 10));
  				_css(ghostEl, 'width', rect.width);
  				_css(ghostEl, 'height', rect.height);
  				_css(ghostEl, 'opacity', '0.8');
  				_css(ghostEl, 'position', 'fixed');
  				_css(ghostEl, 'zIndex', '100000');
  				_css(ghostEl, 'pointerEvents', 'none');
  
  				options.fallbackOnBody && document.body.appendChild(ghostEl) || rootEl.appendChild(ghostEl);
  
  				// Fixing dimensions.
  				ghostRect = ghostEl.getBoundingClientRect();
  				_css(ghostEl, 'width', rect.width * 2 - ghostRect.width);
  				_css(ghostEl, 'height', rect.height * 2 - ghostRect.height);
  			}
  		},
  
  		_onDragStart: function (/**Event*/evt, /**boolean*/useFallback) {
  			var _this = this;
  			var dataTransfer = evt.dataTransfer;
  			var options = _this.options;
  
  			_this._offUpEvents();
  
  			if (activeGroup.checkPull(_this, _this, dragEl, evt)) {
  				cloneEl = _clone(dragEl);
  
  				cloneEl.draggable = false;
  				cloneEl.style['will-change'] = '';
  
  				_css(cloneEl, 'display', 'none');
  				_toggleClass(cloneEl, _this.options.chosenClass, false);
  
  				// #1143: IFrame support workaround
  				_this._cloneId = _nextTick(function () {
  					rootEl.insertBefore(cloneEl, dragEl);
  					_dispatchEvent(_this, rootEl, 'clone', dragEl);
  				});
  			}
  
  			_toggleClass(dragEl, options.dragClass, true);
  
  			if (useFallback) {
  				if (useFallback === 'touch') {
  					// Bind touch events
  					_on(document, 'touchmove', _this._onTouchMove);
  					_on(document, 'touchend', _this._onDrop);
  					_on(document, 'touchcancel', _this._onDrop);
  
  					if (options.supportPointer) {
  						_on(document, 'pointermove', _this._onTouchMove);
  						_on(document, 'pointerup', _this._onDrop);
  					}
  				} else {
  					// Old brwoser
  					_on(document, 'mousemove', _this._onTouchMove);
  					_on(document, 'mouseup', _this._onDrop);
  				}
  
  				_this._loopId = setInterval(_this._emulateDragOver, 50);
  			}
  			else {
  				if (dataTransfer) {
  					dataTransfer.effectAllowed = 'move';
  					options.setData && options.setData.call(_this, dataTransfer, dragEl);
  				}
  
  				_on(document, 'drop', _this);
  
  				// #1143: Бывает элемент с IFrame внутри блокирует `drop`,
  				// поэтому если вызвался `mouseover`, значит надо отменять весь d'n'd.
  				// Breaking Chrome 62+
  				// _on(document, 'mouseover', _this);
  
  				_this._dragStartId = _nextTick(_this._dragStarted);
  			}
  		},
  
  		_onDragOver: function (/**Event*/evt) {
  			var el = this.el,
  				target,
  				dragRect,
  				targetRect,
  				revert,
  				options = this.options,
  				group = options.group,
  				activeSortable = Sortable.active,
  				isOwner = (activeGroup === group),
  				isMovingBetweenSortable = false,
  				canSort = options.sort;
  
  			if (evt.preventDefault !== void 0) {
  				evt.preventDefault();
  				!options.dragoverBubble && evt.stopPropagation();
  			}
  
  			if (dragEl.animated) {
  				return;
  			}
  
  			moved = true;
  
  			if (activeSortable && !options.disabled &&
  				(isOwner
  					? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
  					: (
  						putSortable === this ||
  						(
  							(activeSortable.lastPullMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) &&
  							group.checkPut(this, activeSortable, dragEl, evt)
  						)
  					)
  				) &&
  				(evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
  			) {
  				// Smart auto-scrolling
  				_autoScroll(evt, options, this.el);
  
  				if (_silent) {
  					return;
  				}
  
  				target = _closest(evt.target, options.draggable, el);
  				dragRect = dragEl.getBoundingClientRect();
  
  				if (putSortable !== this) {
  					putSortable = this;
  					isMovingBetweenSortable = true;
  				}
  
  				if (revert) {
  					_cloneHide(activeSortable, true);
  					parentEl = rootEl; // actualization
  
  					if (cloneEl || nextEl) {
  						rootEl.insertBefore(dragEl, cloneEl || nextEl);
  					}
  					else if (!canSort) {
  						rootEl.appendChild(dragEl);
  					}
  
  					return;
  				}
  
  
  				if ((el.children.length === 0) || (el.children[0] === ghostEl) ||
  					(el === evt.target) && (_ghostIsLast(el, evt))
  				) {
  					//assign target only if condition is true
  					if (el.children.length !== 0 && el.children[0] !== ghostEl && el === evt.target) {
  						target = el.lastElementChild;
  					}
  
  					if (target) {
  						if (target.animated) {
  							return;
  						}
  
  						targetRect = target.getBoundingClientRect();
  					}
  
  					_cloneHide(activeSortable, isOwner);
  
  					if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt) !== false) {
  						if (!dragEl.contains(el)) {
  							el.appendChild(dragEl);
  							parentEl = el; // actualization
  						}
  
  						this._animate(dragRect, dragEl);
  						target && this._animate(targetRect, target);
  					}
  				}
  				else if (target && !target.animated && target !== dragEl && (target.parentNode[expando] !== void 0)) {
  					if (lastEl !== target) {
  						lastEl = target;
  						lastCSS = _css(target);
  						lastParentCSS = _css(target.parentNode);
  					}
  
  					targetRect = target.getBoundingClientRect();
  
  					var width = targetRect.right - targetRect.left,
  						height = targetRect.bottom - targetRect.top,
  						floating = R_FLOAT.test(lastCSS.cssFloat + lastCSS.display)
  							|| (lastParentCSS.display == 'flex' && lastParentCSS['flex-direction'].indexOf('row') === 0),
  						isWide = (target.offsetWidth > dragEl.offsetWidth),
  						isLong = (target.offsetHeight > dragEl.offsetHeight),
  						halfway = (floating ? (evt.clientX - targetRect.left) / width : (evt.clientY - targetRect.top) / height) > 0.5,
  						nextSibling = target.nextElementSibling,
  						after = false
  					;
  
  					if (floating) {
  						var elTop = dragEl.offsetTop,
  							tgTop = target.offsetTop;
  
  						if (elTop === tgTop) {
  							after = (target.previousElementSibling === dragEl) && !isWide || halfway && isWide;
  						}
  						else if (target.previousElementSibling === dragEl || dragEl.previousElementSibling === target) {
  							after = (evt.clientY - targetRect.top) / height > 0.5;
  						} else {
  							after = tgTop > elTop;
  						}
  						} else if (!isMovingBetweenSortable) {
  						after = (nextSibling !== dragEl) && !isLong || halfway && isLong;
  					}
  
  					var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after);
  
  					if (moveVector !== false) {
  						if (moveVector === 1 || moveVector === -1) {
  							after = (moveVector === 1);
  						}
  
  						_silent = true;
  						setTimeout(_unsilent, 30);
  
  						_cloneHide(activeSortable, isOwner);
  
  						if (!dragEl.contains(el)) {
  							if (after && !nextSibling) {
  								el.appendChild(dragEl);
  							} else {
  								target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
  							}
  						}
  
  						parentEl = dragEl.parentNode; // actualization
  
  						this._animate(dragRect, dragEl);
  						this._animate(targetRect, target);
  					}
  				}
  			}
  		},
  
  		_animate: function (prevRect, target) {
  			var ms = this.options.animation;
  
  			if (ms) {
  				var currentRect = target.getBoundingClientRect();
  
  				if (prevRect.nodeType === 1) {
  					prevRect = prevRect.getBoundingClientRect();
  				}
  
  				_css(target, 'transition', 'none');
  				_css(target, 'transform', 'translate3d('
  					+ (prevRect.left - currentRect.left) + 'px,'
  					+ (prevRect.top - currentRect.top) + 'px,0)'
  				);
  
  				target.offsetWidth; // repaint
  
  				_css(target, 'transition', 'all ' + ms + 'ms');
  				_css(target, 'transform', 'translate3d(0,0,0)');
  
  				clearTimeout(target.animated);
  				target.animated = setTimeout(function () {
  					_css(target, 'transition', '');
  					_css(target, 'transform', '');
  					target.animated = false;
  				}, ms);
  			}
  		},
  
  		_offUpEvents: function () {
  			var ownerDocument = this.el.ownerDocument;
  
  			_off(document, 'touchmove', this._onTouchMove);
  			_off(document, 'pointermove', this._onTouchMove);
  			_off(ownerDocument, 'mouseup', this._onDrop);
  			_off(ownerDocument, 'touchend', this._onDrop);
  			_off(ownerDocument, 'pointerup', this._onDrop);
  			_off(ownerDocument, 'touchcancel', this._onDrop);
  			_off(ownerDocument, 'pointercancel', this._onDrop);
  			_off(ownerDocument, 'selectstart', this);
  		},
  
  		_onDrop: function (/**Event*/evt) {
  			var el = this.el,
  				options = this.options;
  
  			clearInterval(this._loopId);
  			clearInterval(autoScroll.pid);
  			clearTimeout(this._dragStartTimer);
  
  			_cancelNextTick(this._cloneId);
  			_cancelNextTick(this._dragStartId);
  
  			// Unbind events
  			_off(document, 'mouseover', this);
  			_off(document, 'mousemove', this._onTouchMove);
  
  			if (this.nativeDraggable) {
  				_off(document, 'drop', this);
  				_off(el, 'dragstart', this._onDragStart);
  			}
  
  			this._offUpEvents();
  
  			if (evt) {
  				if (moved) {
  					evt.preventDefault();
  					!options.dropBubble && evt.stopPropagation();
  				}
  
  				ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl);
  
  				if (rootEl === parentEl || Sortable.active.lastPullMode !== 'clone') {
  					// Remove clone
  					cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl);
  				}
  
  				if (dragEl) {
  					if (this.nativeDraggable) {
  						_off(dragEl, 'dragend', this);
  					}
  
  					_disableDraggable(dragEl);
  					dragEl.style['will-change'] = '';
  
  					// Remove class's
  					_toggleClass(dragEl, this.options.ghostClass, false);
  					_toggleClass(dragEl, this.options.chosenClass, false);
  
  					// Drag stop event
  					_dispatchEvent(this, rootEl, 'unchoose', dragEl, parentEl, rootEl, oldIndex);
  
  					if (rootEl !== parentEl) {
  						newIndex = _index(dragEl, options.draggable);
  
  						if (newIndex >= 0) {
  							// Add event
  							_dispatchEvent(null, parentEl, 'add', dragEl, parentEl, rootEl, oldIndex, newIndex);
  
  							// Remove event
  							_dispatchEvent(this, rootEl, 'remove', dragEl, parentEl, rootEl, oldIndex, newIndex);
  
  							// drag from one list and drop into another
  							_dispatchEvent(null, parentEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
  							_dispatchEvent(this, rootEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
  						}
  					}
  					else {
  						if (dragEl.nextSibling !== nextEl) {
  							// Get the index of the dragged element within its parent
  							newIndex = _index(dragEl, options.draggable);
  
  							if (newIndex >= 0) {
  								// drag & drop within the same list
  								_dispatchEvent(this, rootEl, 'update', dragEl, parentEl, rootEl, oldIndex, newIndex);
  								_dispatchEvent(this, rootEl, 'sort', dragEl, parentEl, rootEl, oldIndex, newIndex);
  							}
  						}
  					}
  
  					if (Sortable.active) {
  						/* jshint eqnull:true */
  						if (newIndex == null || newIndex === -1) {
  							newIndex = oldIndex;
  						}
  
  						_dispatchEvent(this, rootEl, 'end', dragEl, parentEl, rootEl, oldIndex, newIndex);
  
  						// Save sorting
  						this.save();
  					}
  				}
  
  			}
  
  			this._nulling();
  		},
  
  		_nulling: function() {
  			rootEl =
  			dragEl =
  			parentEl =
  			ghostEl =
  			nextEl =
  			cloneEl =
  			lastDownEl =
  
  			scrollEl =
  			scrollParentEl =
  
  			tapEvt =
  			touchEvt =
  
  			moved =
  			newIndex =
  
  			lastEl =
  			lastCSS =
  
  			putSortable =
  			activeGroup =
  			Sortable.active = null;
  
  			savedInputChecked.forEach(function (el) {
  				el.checked = true;
  			});
  			savedInputChecked.length = 0;
  		},
  
  		handleEvent: function (/**Event*/evt) {
  			switch (evt.type) {
  				case 'drop':
  				case 'dragend':
  					this._onDrop(evt);
  					break;
  
  				case 'dragover':
  				case 'dragenter':
  					if (dragEl) {
  						this._onDragOver(evt);
  						_globalDragOver(evt);
  					}
  					break;
  
  				case 'mouseover':
  					this._onDrop(evt);
  					break;
  
  				case 'selectstart':
  					evt.preventDefault();
  					break;
  			}
  		},
  
  
  		/**
  		 * Serializes the item into an array of string.
  		 * @returns {String[]}
  		 */
  		toArray: function () {
  			var order = [],
  				el,
  				children = this.el.children,
  				i = 0,
  				n = children.length,
  				options = this.options;
  
  			for (; i < n; i++) {
  				el = children[i];
  				if (_closest(el, options.draggable, this.el)) {
  					order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
  				}
  			}
  
  			return order;
  		},
  
  
  		/**
  		 * Sorts the elements according to the array.
  		 * @param  {String[]}  order  order of the items
  		 */
  		sort: function (order) {
  			var items = {}, rootEl = this.el;
  
  			this.toArray().forEach(function (id, i) {
  				var el = rootEl.children[i];
  
  				if (_closest(el, this.options.draggable, rootEl)) {
  					items[id] = el;
  				}
  			}, this);
  
  			order.forEach(function (id) {
  				if (items[id]) {
  					rootEl.removeChild(items[id]);
  					rootEl.appendChild(items[id]);
  				}
  			});
  		},
  
  
  		/**
  		 * Save the current sorting
  		 */
  		save: function () {
  			var store = this.options.store;
  			store && store.set(this);
  		},
  
  
  		/**
  		 * 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.
  		 * @param   {HTMLElement}  el
  		 * @param   {String}       [selector]  default: `options.draggable`
  		 * @returns {HTMLElement|null}
  		 */
  		closest: function (el, selector) {
  			return _closest(el, selector || this.options.draggable, this.el);
  		},
  
  
  		/**
  		 * Set/get option
  		 * @param   {string} name
  		 * @param   {*}      [value]
  		 * @returns {*}
  		 */
  		option: function (name, value) {
  			var options = this.options;
  
  			if (value === void 0) {
  				return options[name];
  			} else {
  				options[name] = value;
  
  				if (name === 'group') {
  					_prepareGroup(options);
  				}
  			}
  		},
  
  
  		/**
  		 * Destroy
  		 */
  		destroy: function () {
  			var el = this.el;
  
  			el[expando] = null;
  
  			_off(el, 'mousedown', this._onTapStart);
  			_off(el, 'touchstart', this._onTapStart);
  			_off(el, 'pointerdown', this._onTapStart);
  
  			if (this.nativeDraggable) {
  				_off(el, 'dragover', this);
  				_off(el, 'dragenter', this);
  			}
  
  			// Remove draggable attributes
  			Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
  				el.removeAttribute('draggable');
  			});
  
  			touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);
  
  			this._onDrop();
  
  			this.el = el = null;
  		}
  	};
  
  
  	function _cloneHide(sortable, state) {
  		if (sortable.lastPullMode !== 'clone') {
  			state = true;
  		}
  
  		if (cloneEl && (cloneEl.state !== state)) {
  			_css(cloneEl, 'display', state ? 'none' : '');
  
  			if (!state) {
  				if (cloneEl.state) {
  					if (sortable.options.group.revertClone) {
  						rootEl.insertBefore(cloneEl, nextEl);
  						sortable._animate(dragEl, cloneEl);
  					} else {
  						rootEl.insertBefore(cloneEl, dragEl);
  					}
  				}
  			}
  
  			cloneEl.state = state;
  		}
  	}
  
  
  	function _closest(/**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx) {
  		if (el) {
  			ctx = ctx || document;
  
  			do {
  				if ((selector === '>*' && el.parentNode === ctx) || _matches(el, selector)) {
  					return el;
  				}
  				/* jshint boss:true */
  			} while (el = _getParentOrHost(el));
  		}
  
  		return null;
  	}
  
  
  	function _getParentOrHost(el) {
  		var parent = el.host;
  
  		return (parent && parent.nodeType) ? parent : el.parentNode;
  	}
  
  
  	function _globalDragOver(/**Event*/evt) {
  		if (evt.dataTransfer) {
  			evt.dataTransfer.dropEffect = 'move';
  		}
  		evt.preventDefault();
  	}
  
  
  	function _on(el, event, fn) {
  		el.addEventListener(event, fn, captureMode);
  	}
  
  
  	function _off(el, event, fn) {
  		el.removeEventListener(event, fn, captureMode);
  	}
  
  
  	function _toggleClass(el, name, state) {
  		if (el) {
  			if (el.classList) {
  				el.classList[state ? 'add' : 'remove'](name);
  			}
  			else {
  				var className = (' ' + el.className + ' ').replace(R_SPACE, ' ').replace(' ' + name + ' ', ' ');
  				el.className = (className + (state ? ' ' + name : '')).replace(R_SPACE, ' ');
  			}
  		}
  	}
  
  
  	function _css(el, prop, val) {
  		var style = el && el.style;
  
  		if (style) {
  			if (val === void 0) {
  				if (document.defaultView && document.defaultView.getComputedStyle) {
  					val = document.defaultView.getComputedStyle(el, '');
  				}
  				else if (el.currentStyle) {
  					val = el.currentStyle;
  				}
  
  				return prop === void 0 ? val : val[prop];
  			}
  			else {
  				if (!(prop in style)) {
  					prop = '-webkit-' + prop;
  				}
  
  				style[prop] = val + (typeof val === 'string' ? '' : 'px');
  			}
  		}
  	}
  
  
  	function _find(ctx, tagName, iterator) {
  		if (ctx) {
  			var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;
  
  			if (iterator) {
  				for (; i < n; i++) {
  					iterator(list[i], i);
  				}
  			}
  
  			return list;
  		}
  
  		return [];
  	}
  
  
  
  	function _dispatchEvent(sortable, rootEl, name, targetEl, toEl, fromEl, startIndex, newIndex) {
  		sortable = (sortable || rootEl[expando]);
  
  		var evt = document.createEvent('Event'),
  			options = sortable.options,
  			onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
  
  		evt.initEvent(name, true, true);
  
  		evt.to = toEl || rootEl;
  		evt.from = fromEl || rootEl;
  		evt.item = targetEl || rootEl;
  		evt.clone = cloneEl;
  
  		evt.oldIndex = startIndex;
  		evt.newIndex = newIndex;
  
  		rootEl.dispatchEvent(evt);
  
  		if (options[onName]) {
  			options[onName].call(sortable, evt);
  		}
  	}
  
  
  	function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvt, willInsertAfter) {
  		var evt,
  			sortable = fromEl[expando],
  			onMoveFn = sortable.options.onMove,
  			retVal;
  
  		evt = document.createEvent('Event');
  		evt.initEvent('move', true, true);
  
  		evt.to = toEl;
  		evt.from = fromEl;
  		evt.dragged = dragEl;
  		evt.draggedRect = dragRect;
  		evt.related = targetEl || toEl;
  		evt.relatedRect = targetRect || toEl.getBoundingClientRect();
  		evt.willInsertAfter = willInsertAfter;
  
  		fromEl.dispatchEvent(evt);
  
  		if (onMoveFn) {
  			retVal = onMoveFn.call(sortable, evt, originalEvt);
  		}
  
  		return retVal;
  	}
  
  
  	function _disableDraggable(el) {
  		el.draggable = false;
  	}
  
  
  	function _unsilent() {
  		_silent = false;
  	}
  
  
  	/** @returns {HTMLElement|false} */
  	function _ghostIsLast(el, evt) {
  		var lastEl = el.lastElementChild,
  			rect = lastEl.getBoundingClientRect();
  
  		// 5 — min delta
  		// abs — нельзя добавлять, а то глюки при наведении сверху
  		return (evt.clientY - (rect.top + rect.height) > 5) ||
  			(evt.clientX - (rect.left + rect.width) > 5);
  	}
  
  
  	/**
  	 * Generate id
  	 * @param   {HTMLElement} el
  	 * @returns {String}
  	 * @private
  	 */
  	function _generateId(el) {
  		var str = el.tagName + el.className + el.src + el.href + el.textContent,
  			i = str.length,
  			sum = 0;
  
  		while (i--) {
  			sum += str.charCodeAt(i);
  		}
  
  		return sum.toString(36);
  	}
  
  	/**
  	 * Returns the index of an element within its parent for a selected set of
  	 * elements
  	 * @param  {HTMLElement} el
  	 * @param  {selector} selector
  	 * @return {number}
  	 */
  	function _index(el, selector) {
  		var index = 0;
  
  		if (!el || !el.parentNode) {
  			return -1;
  		}
  
  		while (el && (el = el.previousElementSibling)) {
  			if ((el.nodeName.toUpperCase() !== 'TEMPLATE') && (selector === '>*' || _matches(el, selector))) {
  				index++;
  			}
  		}
  
  		return index;
  	}
  
  	function _matches(/**HTMLElement*/el, /**String*/selector) {
  		if (el) {
  			selector = selector.split('.');
  
  			var tag = selector.shift().toUpperCase(),
  				re = new RegExp('\\s(' + selector.join('|') + ')(?=\\s)', 'g');
  
  			return (
  				(tag === '' || el.nodeName.toUpperCase() == tag) &&
  				(!selector.length || ((' ' + el.className + ' ').match(re) || []).length == selector.length)
  			);
  		}
  
  		return false;
  	}
  
  	function _throttle(callback, ms) {
  		var args, _this;
  
  		return function () {
  			if (args === void 0) {
  				args = arguments;
  				_this = this;
  
  				setTimeout(function () {
  					if (args.length === 1) {
  						callback.call(_this, args[0]);
  					} else {
  						callback.apply(_this, args);
  					}
  
  					args = void 0;
  				}, ms);
  			}
  		};
  	}
  
  	function _extend(dst, src) {
  		if (dst && src) {
  			for (var key in src) {
  				if (src.hasOwnProperty(key)) {
  					dst[key] = src[key];
  				}
  			}
  		}
  
  		return dst;
  	}
  
  	function _clone(el) {
  		if (Polymer && Polymer.dom) {
  			return Polymer.dom(el).cloneNode(true);
  		}
  		else if ($) {
  			return $(el).clone(true)[0];
  		}
  		else {
  			return el.cloneNode(true);
  		}
  	}
  
  	function _saveInputCheckedState(root) {
  		var inputs = root.getElementsByTagName('input');
  		var idx = inputs.length;
  
  		while (idx--) {
  			var el = inputs[idx];
  			el.checked && savedInputChecked.push(el);
  		}
  	}
  
  	function _nextTick(fn) {
  		return setTimeout(fn, 0);
  	}
  
  	function _cancelNextTick(id) {
  		return clearTimeout(id);
  	}
  
  	// Fixed #973:
  	_on(document, 'touchmove', function (evt) {
  		if (Sortable.active) {
  			evt.preventDefault();
  		}
  	});
  
  	// Export utils
  	Sortable.utils = {
  		on: _on,
  		off: _off,
  		css: _css,
  		find: _find,
  		is: function (el, selector) {
  			return !!_closest(el, selector, el);
  		},
  		extend: _extend,
  		throttle: _throttle,
  		closest: _closest,
  		toggleClass: _toggleClass,
  		clone: _clone,
  		index: _index,
  		nextTick: _nextTick,
  		cancelNextTick: _cancelNextTick
  	};
  
  
  	/**
  	 * Create sortable instance
  	 * @param {HTMLElement}  el
  	 * @param {Object}      [options]
  	 */
  	Sortable.create = function (el, options) {
  		return new Sortable(el, options);
  	};
  
  
  	// Export
  	Sortable.version = '1.7.0';
  	return Sortable;
  });
  
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports) {
  
  // removed by extract-text-webpack-plugin
  
  /***/ })
  /******/ ]);