window["DJNesting"] =
/******/ (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
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// 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);
/******/ })
/************************************************************************/
/******/ ({

/***/ "./nested_admin/static/nested_admin/src/nested-admin/grp$.js":
/*!*******************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/grp$.js ***!
  \*******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");
/**
 * For grappelli 2.14, converts a django.jQuery instance to a grp.jQuery
 * instance. Otherwise (if grappelli is not present, or for grappelli <= 2.13,
 * where the grappelli jQuery instance is the same as django's), returns the
 * object that was passed in, unchanged.
 */


function grp$($sel) {
  if (typeof window.grp === 'undefined') {
    return $($sel);
  }

  if (window.grp.jQuery.fn.init === $.fn.init) {
    return $($sel);
  }

  var $grpSel = window.grp.jQuery($sel);

  if ($sel.prevObject) {
    $grpSel.prevObject = grp$($sel.prevObject);
  }

  return $grpSel;
}

module.exports = grp$;

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/index.js":
/*!********************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/index.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");

var grappelli = __webpack_require__(/*! grappelli */ "grappelli");

var DJNesting = __webpack_require__(/*! ./utils */ "./nested_admin/static/nested_admin/src/nested-admin/utils.js");

DJNesting.DjangoFormset = __webpack_require__(/*! ./jquery.djangoformset */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.djangoformset.js");
$(document).ready(function () {
  // Remove the border on any empty fieldsets
  $('fieldset.grp-module, fieldset.module').filter(function (i, element) {
    return element.childNodes.length == 0;
  }).css('border-width', '0'); // Set predelete class on any form elements with the DELETE input checked.
  // These can occur on forms rendered after a validation error.

  $('input[name$="-DELETE"]:checked').not('[name*="__prefix__"]').closest('.djn-inline-form').addClass('grp-predelete');
  $(document).on('djnesting:initialized djnesting:mutate', function onMutate(e, $inline) {
    var $items = $inline.find('> .djn-items, > .tabular > .module > .djn-items');
    var $rows = $items.children('.djn-tbody');
    $rows.removeClass('row1 row2');
    $rows.each(function (i, row) {
      var n = 1 + i % 2;
      $(row).addClass('row' + n);
    });
  }); // Register the nested formset on top level djnesting-stacked elements.
  // It will handle recursing down the nested inlines.

  $('.djn-group-root').each(function (i, rootGroup) {
    $(rootGroup).djangoFormset();
  });
  $('form').on('submit.djnesting', function (e) {
    $('.djn-group').each(function () {
      DJNesting.updatePositions($(this).djangoFormsetPrefix());
      $(document).trigger('djnesting:mutate', [$(this).djangoFormset().$inline]);
    });
  });
});
module.exports = DJNesting;

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/jquery.djangoformset.js":
/*!***********************************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/jquery.djangoformset.js ***!
  \***********************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.array.sort */ "./node_modules/core-js/modules/es6.array.sort.js");

__webpack_require__(/*! core-js/modules/es6.regexp.replace */ "./node_modules/core-js/modules/es6.regexp.replace.js");

__webpack_require__(/*! core-js/modules/es6.function.name */ "./node_modules/core-js/modules/es6.function.name.js");

__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");

var regexQuote = __webpack_require__(/*! ./regexquote */ "./nested_admin/static/nested_admin/src/nested-admin/regexquote.js");

var DJNesting = __webpack_require__(/*! ./utils */ "./nested_admin/static/nested_admin/src/nested-admin/utils.js");

var grappelli = __webpack_require__(/*! grappelli */ "grappelli");

var grp = __webpack_require__(/*! grp */ "grp");

var grp$ = __webpack_require__(/*! ./grp$ */ "./nested_admin/static/nested_admin/src/nested-admin/grp$.js");

var pluginName = 'djangoFormset';

var DjangoFormset =
/*#__PURE__*/
function () {
  function DjangoFormset(inline) {
    this.opts = {
      emptyClass: 'empty-form grp-empty-form djn-empty-form',
      predeleteClass: 'grp-predelete'
    };
    this.$inline = $(inline);
    this.prefix = this.$inline.djangoFormsetPrefix();
    this._$totalForms = this.$inline.find('#id_' + this.prefix + '-TOTAL_FORMS');

    this._$totalForms.attr('autocomplete', 'off');

    this._$template = $('#' + this.prefix + '-empty');
    var inlineModelClassName = this.$inline.djnData('inlineModel');
    this.opts = $.extend({}, this.opts, {
      childTypes: this.$inline.data('inlineFormset').options.childTypes,
      formsetFkModel: this.$inline.djnData('formsetFkModel'),
      addButtonSelector: '.djn-add-handler.djn-model-' + inlineModelClassName,
      removeButtonSelector: '.djn-remove-handler.djn-model-' + inlineModelClassName,
      deleteButtonSelector: '.djn-delete-handler.djn-model-' + inlineModelClassName,
      formClass: 'dynamic-form grp-dynamic-form djn-dynamic-form-' + inlineModelClassName,
      formClassSelector: '.djn-dynamic-form-' + inlineModelClassName
    });
    DJNesting.initRelatedFields(this.prefix, this.$inline.djnData());
    DJNesting.initAutocompleteFields(this.prefix, this.$inline.djnData());

    if (this.opts.childTypes) {
      this._setupPolymorphic();
    }

    this._bindEvents();

    this._initializeForms();

    this.$inline.find('.djn-items:not([id*="-empty"])').trigger('djnesting:init'); // initialize nested formsets

    this.$inline.find('.djn-group[id$="-group"][id^="' + this.prefix + '"][data-inline-formset]:not([id*="-empty"])').each(function () {
      $(this)[pluginName]();
    });

    if (this.$inline.is('.djn-group-root')) {
      DJNesting.createSortable(this.$inline);
    }

    $(document).trigger('djnesting:initialized', [this.$inline, this]);
  }

  var _proto = DjangoFormset.prototype;

  _proto._setupPolymorphic = function _setupPolymorphic() {
    if (!this.opts.childTypes) {
      throw Error('The polymorphic fieldset options.childTypes is not defined!');
    }

    var menu = '<div class="polymorphic-type-menu" style="display: none"><ul>';
    this.opts.childTypes.forEach(function (c) {
      menu += "<li><a href=\"#\" data-type=\"" + c.type + "\">" + c.name + "</a></li>";
    });
    menu += '</ul></div>';
    var $addButton = this.$inline.find(this.opts.addButtonSelector);
    var $menu = $(menu);
    $addButton.after($menu);
  };

  _proto._initializeForms = function _initializeForms() {
    var totalForms = this.mgmtVal('TOTAL_FORMS');
    var maxForms = this.mgmtVal('MAX_NUM_FORMS');

    if (maxForms <= totalForms) {
      this.$inline.find(this.opts.addButtonSelector).parents('.djn-add-item').hide();
    }

    for (var i = 0; i < totalForms; i++) {
      this._initializeForm('#' + this.prefix + '-' + i);
    }
  };

  _proto._initializeForm = function _initializeForm(form) {
    var $form = $(form);
    var formPrefix = $form.djangoFormPrefix();
    $form.addClass(this.opts.formClass);

    if ($form.hasClass('has_original')) {
      $('#id_' + formPrefix + 'DELETE:checked').toggleClass(this.opts.predeleteClass);
    }

    var minForms = this.mgmtVal('MIN_NUM_FORMS');
    var totalForms = this.mgmtVal('TOTAL_FORMS');
    var self = this;
    var hideRemoveButton = totalForms <= minForms;
    this.$inline.djangoFormsetForms().each(function () {
      var showHideMethod = hideRemoveButton ? 'hide' : 'show';
      $(this).find(self.opts.removeButtonSelector)[showHideMethod]();
    });
  };

  _proto._bindEvents = function _bindEvents($el) {
    var self = this;

    if (typeof $el == 'undefined') {
      $el = this.$inline;
    }

    var $addButton = $el.find(this.opts.addButtonSelector);
    $addButton.off('click.djnesting').on('click.djnesting', function (e) {
      e.preventDefault();
      e.stopPropagation();
      var $menu = $(this).next('.polymorphic-type-menu');

      if (!$menu.length) {
        self.add();
      } else {
        if (!$menu.is(':visible')) {
          var hideMenu = function hideMenu() {
            $menu.hide();
            $(document).off('click', hideMenu);
          };

          $(document).on('click', hideMenu);
        }

        $menu.show();
      }
    });
    var $menuButtons = $addButton.parent().find('> .polymorphic-type-menu a');
    $menuButtons.off('click.djnesting').on('click.djnesting', function (e) {
      e.preventDefault();
      e.stopPropagation();
      var polymorphicType = $(this).attr('data-type');
      self.add(null, polymorphicType);
      var $menu = $(e.target).closest('.polymorphic-type-menu');

      if ($menu.is(':visible')) {
        $menu.hide();
      }
    });
    $el.find(this.opts.removeButtonSelector).filter(function () {
      return !$(this).closest('.djn-empty-form').length;
    }).off('click.djnesting').on('click.djnesting', function (e) {
      e.preventDefault();
      e.stopPropagation();
      var $form = $(this).closest(self.opts.formClassSelector);
      self.remove($form);
    });

    var deleteClickHandler = function deleteClickHandler(e) {
      e.preventDefault();
      e.stopImmediatePropagation();
      var $form = $(this).closest(self.opts.formClassSelector);
      var $deleteInput = $('#id_' + $form.djangoFormPrefix() + 'DELETE');

      if (!$deleteInput.is(':checked')) {
        self['delete']($form);
      } else {
        self.undelete($form);
      }
    };

    var $deleteButton = $el.find(this.opts.deleteButtonSelector).filter(function () {
      return !$(this).closest('.djn-empty-form').length;
    });
    $deleteButton.off('click.djnesting').on('click.djnesting', deleteClickHandler);
    $deleteButton.find('[id$="-DELETE"]').on('mousedown.djnesting', deleteClickHandler);
  };

  _proto.remove = function remove(form) {
    var $form = $(form);
    var totalForms = this.mgmtVal('TOTAL_FORMS');
    var minForms = this.mgmtVal('MIN_NUM_FORMS');
    var maxForms = this.mgmtVal('MAX_NUM_FORMS');
    var index = $form.djangoFormIndex();
    var isInitial = $form.data('isInitial'); // Clearing out the form HTML itself using DOM APIs is much faster
    // than using jQuery to remove the element. Using jQuery is so
    // slow that it hangs the page.

    $form[0].innerHTML = "";
    $form.remove();
    totalForms -= 1;
    this.mgmtVal('TOTAL_FORMS', totalForms);

    if (maxForms - totalForms >= 0) {
      this.$inline.find(this.opts.addButtonSelector).parents('.djn-add-item').show();
    }

    this._fillGap(index, isInitial);

    var self = this;
    var hideRemoveButton = totalForms <= minForms;
    this.$inline.djangoFormsetForms().each(function () {
      var showHideMethod = hideRemoveButton ? 'hide' : 'show';
      $(this).find(self.opts.removeButtonSelector)[showHideMethod]();
    });
    DJNesting.updatePositions(this.prefix);
    $(document).trigger('djnesting:mutate', [this.$inline]); // Also fire using the events that were added in Django 1.9

    $(document).trigger('formset:removed', [$form, this.prefix]);
  };

  _proto.delete = function _delete(form) {
    var self = this,
        $form = $(form),
        formPrefix = $form.djangoFormPrefix(),
        $deleteInput = $('#id_' + formPrefix + 'DELETE');

    if ($form.hasClass(this.opts.predeleteClass)) {
      return;
    }

    if (!$form.data('isInitial')) {
      return;
    }

    $deleteInput.attr('checked', 'checked');

    if ($deleteInput.length) {
      $deleteInput[0].checked = true;
    }

    $form.addClass(this.opts.predeleteClass);
    $form.find('.djn-group').each(function () {
      var $childInline = $(this);
      var childFormset = $childInline.djangoFormset();
      $childInline.djangoFormsetForms().each(function () {
        if ($(this).hasClass(self.opts.predeleteClass)) {
          $(this).data('alreadyDeleted', true);
        } else {
          childFormset.delete(this);
        }
      });
    });
    $form.find('.cropduster-form').each(function () {
      var formPrefix = $(this).djangoFormsetPrefix() + '-0-';
      var $deleteInput = $('#id_' + formPrefix + 'DELETE');
      $deleteInput.attr('checked', 'checked');

      if ($deleteInput.length) {
        $deleteInput[0].checked = true;
      }
    });
    DJNesting.updatePositions(this.prefix);
    $(document).trigger('djnesting:mutate', [this.$inline]);
    $(document).trigger('formset:deleted', [$form, this.prefix]);
  };

  _proto.undelete = function undelete(form) {
    var $form = $(form),
        formPrefix = $form.djangoFormPrefix(),
        $deleteInput = $('#id_' + formPrefix + 'DELETE');

    if ($form.parent().closest('.' + this.opts.predeleteClass).length) {
      return;
    }

    if ($form.hasClass('has_original')) {
      $deleteInput.removeAttr('checked');

      if ($deleteInput.length) {
        $deleteInput[0].checked = false;
      }

      $form.removeClass(this.opts.predeleteClass);
    }

    $form.data('alreadyDeleted', false);
    $form.find('.djn-group').each(function () {
      var $childInline = $(this);
      var childFormset = $childInline.djangoFormset();
      $childInline.djangoFormsetForms().each(function () {
        if ($(this).data('alreadyDeleted')) {
          $(this).data('alreadyDeleted', false);
        } else {
          childFormset.undelete(this);
        }
      });
    });
    $form.find('.cropduster-form').each(function () {
      var formPrefix = $(this).djangoFormsetPrefix() + '-0-';
      var $deleteInput = $('#id_' + formPrefix + 'DELETE');
      $deleteInput.removeAttr('checked');

      if ($deleteInput.length) {
        $deleteInput[0].checked = false;
      }
    });
    DJNesting.updatePositions(this.prefix);
    $(document).trigger('djnesting:mutate', [this.$inline]);
    $(document).trigger('formset:undeleted', [$form, this.prefix]);
  };

  _proto.add = function add(spliceIndex, ctype) {
    var self = this;
    var $template = ctype ? $("#" + this.prefix + "-empty-" + ctype) : this._$template;
    var $form = $template.clone(true); // For django-grappelli >= 2.14, where the grp.jQuery instance is not
    // the same as django.jQuery, we must copy any prepopulated_field
    // dependency data from grp.jQuery to the cloned nodes.

    grp$($template).find(':data(dependency_ids)').each(function () {
      var id = $(this).attr('id');
      var $el = $form.find("#" + id);
      grp$($el).data($.extend({}, $el.data(), grp$(this).data()));
    });
    var index = this.mgmtVal('TOTAL_FORMS');
    var maxForms = this.mgmtVal('MAX_NUM_FORMS');
    var isNested = this.$inline.hasClass('djn-group-nested');
    $(document).trigger('djnesting:beforeadded', [this.$inline, $form]);
    $form.removeClass(this.opts.emptyClass);
    $form.addClass('djn-item');
    $form.attr('id', $form.attr('id').replace(/\-empty.*?$/, '-' + index));

    if (isNested) {
      $form.append(DJNesting.createContainerElement());
    }

    DJNesting.updateFormAttributes($form, new RegExp('([#_]id_|[\\#]|^id_|\"|^)' + regexQuote(this.prefix) + '\\-(?:__prefix__|empty)\\-', 'g'), '$1' + this.prefix + '-' + index + '-');
    var $firstTemplate = this._$template;

    if (this.opts.childTypes) {
      $firstTemplate = $template.closest('.djn-group').find('> .djn-items > [id*="-empty"], > .djn-fieldset > .djn-items > [id*="-empty"]').eq(0);
    }

    if (this.opts.childTypes) {
      var compatibleParents = this.$inline.djnData('compatibleParents') || {};
      $form.find('> .djn-group').each(function (i, el) {
        var fkModel = $(el).djnData('formsetFkModel');
        var compatModels = compatibleParents[ctype] || [];
        var $el = $(el);
        var parentModel = $el.djnData('inlineParentModel');
        var isPolymorphic = !!$el.data('inlineFormset').options.childTypes;
        var formPrefix = $el.data('inlineFormset').options.prefix;

        if (parentModel !== ctype || isPolymorphic && fkModel !== ctype && compatModels.indexOf(fkModel) === -1) {
          $el.find('input[id$="_FORMS"]').each(function (i, input) {
            input.value = 0;
            input.setAttribute('value', '0');
            el.parentNode.appendChild(input);
          });
          el.parentNode.removeChild(el);
        }
      });
    }

    $form.insertBefore($firstTemplate);
    this.mgmtVal('TOTAL_FORMS', index + 1);

    if (maxForms - (index + 1) <= 0) {
      this.$inline.find(this.opts.addButtonSelector).parents('.djn-add-item').hide();
    }

    DJNesting.updatePositions(this.prefix);

    if ($.isNumeric(spliceIndex)) {
      this.spliceInto($form, spliceIndex, true);
    } else {
      $(document).trigger('djnesting:mutate', [this.$inline]);
    }

    if (grappelli) {
      grappelli.reinitDateTimeFields(grp$($form));
    }

    DJNesting.DjangoInlines.initPrepopulatedFields($form);
    DJNesting.DjangoInlines.reinitDateTimeShortCuts();
    DJNesting.DjangoInlines.updateSelectFilter($form);
    DJNesting.initRelatedFields(this.prefix);
    DJNesting.initAutocompleteFields(this.prefix);

    if (grp && grp.jQuery.fn.grp_collapsible) {
      var addBackMethod = grp.jQuery.fn.addBack ? 'addBack' : 'andSelf';
      grp$($form).find('.grp-collapse:not([id$="-empty"]):not([id*="-empty-"])')[addBackMethod]().grp_collapsible({
        toggle_handler_slctr: '.grp-collapse-handler:first',
        closed_css: 'closed grp-closed',
        open_css: 'open grp-open',
        on_toggle: function on_toggle() {
          $(document).trigger('djnesting:toggle', [self.$inline]);
        }
      });
    }

    if (typeof $.fn.curated_content_type == 'function') {
      $form.find('.curated-content-type-select').each(function () {
        $(this).curated_content_type();
      });
    }

    this._initializeForm($form);

    this._bindEvents($form);

    if (ctype) {
      var formsetModelClassName = this.$inline.djnData('inlineModel');
      var inlineModelClassName = $form.attr('data-inline-model');
      var $buttons = $form.find(".djn-model-" + formsetModelClassName);
      $buttons.addClass("djn-model-" + inlineModelClassName);
      $form.addClass("djn-dynamic-form-" + inlineModelClassName);
    } // find any nested formsets


    $form.find('.djn-group[id$="-group"][id^="' + this.prefix + '"][data-inline-formset]:not([id*="-empty"])').each(function () {
      $(this)[pluginName]();
    }); // Fire an event on the document so other javascript applications
    // can be alerted to the newly inserted inline

    $(document).trigger('djnesting:added', [this.$inline, $form]); // Also fire using the events that were added in Django 1.9

    $(document).trigger('formset:added', [$form, this.prefix]);
    return $form;
  };

  _proto._fillGap = function _fillGap(index, isInitial) {
    var $initialForm, $newForm;
    var formsets = this.$inline.djangoFormsetForms().toArray(); // Sort formsets in index order, so that we get the last indexed form for the swap.

    formsets.sort(function (a, b) {
      return $(a).djangoFormIndex() - $(b).djangoFormIndex();
    });
    formsets.forEach(function (form) {
      var $form = $(form);
      var i = $form.djangoFormIndex();

      if (i <= index) {
        return;
      }

      if ($form.data('isInitial')) {
        $initialForm = $form;
      } else {
        $newForm = $form;
      }
    });
    var $form = isInitial ? $initialForm || $newForm : $newForm;

    if (!$form) {
      return;
    }

    var oldIndex = $form.djangoFormIndex();
    var oldFormPrefixRegex = new RegExp('([\\#_]|^)' + regexQuote(this.prefix + '-' + oldIndex) + '(?!\\-\\d)');
    $form.attr('id', this.prefix + '-' + index);
    DJNesting.updateFormAttributes($form, oldFormPrefixRegex, '$1' + this.prefix + '-' + index); // Update prefixes on nested DjangoFormset objects

    $form.find('.djn-group').each(function () {
      var $childInline = $(this);
      var childFormset = $childInline.djangoFormset();
      childFormset.prefix = $childInline.djangoFormsetPrefix();
    });
    $(document).trigger('djnesting:attrchange', [this.$inline, $form]);

    if (isInitial && $initialForm && $newForm) {
      this._fillGap(oldIndex, false);
    }
  };

  _proto._makeRoomForInsert = function _makeRoomForInsert() {
    var initialFormCount = this.mgmtVal('INITIAL_FORMS'),
        totalFormCount = this.mgmtVal('TOTAL_FORMS'),
        gapIndex = initialFormCount,
        $existingForm = $('#' + this.prefix + '-' + gapIndex);

    if (!$existingForm.length) {
      return;
    }

    var oldFormPrefixRegex = new RegExp('([\\#_]|^)' + regexQuote(this.prefix) + '-' + gapIndex + '(?!\\-\\d)');
    $existingForm.attr('id', this.prefix + '-' + totalFormCount);
    DJNesting.updateFormAttributes($existingForm, oldFormPrefixRegex, '$1' + this.prefix + '-' + totalFormCount); // Update prefixes on nested DjangoFormset objects

    $existingForm.find('.djn-group').each(function () {
      var $childInline = $(this);
      var childFormset = $childInline.djangoFormset();
      childFormset.prefix = $childInline.djangoFormsetPrefix();
    });
    $(document).trigger('djnesting:attrchange', [this.$inline, $existingForm]);
  };
  /**
   * Splice a form into the current formset at new position `index`.
   */


  _proto.spliceInto = function spliceInto($form, index, isNewAddition) {
    var initialFormCount = this.mgmtVal('INITIAL_FORMS'),
        totalFormCount = this.mgmtVal('TOTAL_FORMS'),
        oldFormsetPrefix = $form.djangoFormsetPrefix(),
        newFormsetPrefix = this.prefix,
        isInitial = $form.data('isInitial'),
        newIndex,
        $before; // Make sure the form being spliced is from a different inline

    if ($form.djangoFormsetPrefix() == this.prefix) {
      var currentPosition = $form.prevAll('.djn-item:not(.djn-no-drag,.djn-thead)').length;

      if (currentPosition === index || typeof index == 'undefined') {
        DJNesting.updatePositions(newFormsetPrefix);
        return;
      }

      $before = this.$inline.find('> .djn-items, > .tabular > .module > .djn-items').find('> .djn-item:not(#' + $form.attr('id') + ')').eq(index);
      $before.after($form);
    } else {
      var $oldInline = $('#' + oldFormsetPrefix + '-group');
      var $currentFormInline = $form.closest('.djn-group');

      if ($currentFormInline.djangoFormsetPrefix() != newFormsetPrefix) {
        $before = this.$inline.find('> .djn-items, > .tabular > .module > .djn-items').find('> .djn-item').eq(index);
        $before.after($form);
      }

      var oldDjangoFormset = $oldInline.djangoFormset();
      oldDjangoFormset.mgmtVal('TOTAL_FORMS', oldDjangoFormset.mgmtVal('TOTAL_FORMS') - 1);

      oldDjangoFormset._fillGap($form.djangoFormIndex(), isInitial);

      if (isInitial) {
        oldDjangoFormset.mgmtVal('INITIAL_FORMS', oldDjangoFormset.mgmtVal('INITIAL_FORMS') - 1);
        var $parentInline = this.$inline.parent().closest('.djn-group');

        if ($parentInline.length) {
          var $parentForm = this.$inline.closest('.djn-inline-form');
          var parentPkField = ($parentInline.djnData('fieldNames') || {}).pk;
          var $parentPk = $parentForm.djangoFormField(parentPkField);

          if (!$parentPk.val()) {
            $form.data('isInitial', false);
            $form.attr('data-is-initial', 'false');
            isInitial = false; // Set initial form counts to 0 on nested DjangoFormsets

            setTimeout(function () {
              $form.find('[name^="' + $form.djangoFormPrefix() + '"][name$="-INITIAL_FORMS"]').val('0').trigger('change');
            }, 0);
          }
        }
      }

      if (isInitial) {
        this._makeRoomForInsert();
      } // Replace the ids for the splice form


      var oldFormPrefixRegex = new RegExp('([\\#_]|^)' + regexQuote($form.attr('id')) + '(?!\\-\\d)');
      newIndex = isInitial ? initialFormCount : totalFormCount;
      $form.attr('id', newFormsetPrefix + '-' + newIndex);
      DJNesting.updateFormAttributes($form, oldFormPrefixRegex, '$1' + newFormsetPrefix + '-' + newIndex); // Update prefixes on nested DjangoFormset objects

      $form.find('.djn-group').each(function () {
        var $childInline = $(this);
        var childFormset = $childInline.djangoFormset();
        childFormset.prefix = $childInline.djangoFormsetPrefix();
      });
      $(document).trigger('djnesting:attrchange', [this.$inline, $form]);

      if (isInitial) {
        this.mgmtVal('INITIAL_FORMS', initialFormCount + 1);
      }

      this.mgmtVal('TOTAL_FORMS', totalFormCount + 1);
      DJNesting.updatePositions(oldFormsetPrefix);
      $(document).trigger('djnesting:mutate', [$oldInline]);
    }

    DJNesting.updatePositions(newFormsetPrefix);

    if (!isNewAddition) {
      $(document).trigger('djnesting:mutate', [this.$inline]);
    }
  };

  _proto.mgmtVal = function mgmtVal(name, newValue) {
    var $field = this.$inline.find('#id_' + this.prefix + '-' + name);

    if (typeof newValue == 'undefined') {
      return parseInt($field.val(), 10);
    } else {
      return parseInt($field.val(newValue).trigger('change').val(), 10);
    }
  };

  return DjangoFormset;
}();

$.fn[pluginName] = function () {
  var options, fn, args;
  var $el = this.eq(0);

  if (arguments.length === 0 || arguments.length === 1 && $.type(arguments[0]) != 'string') {
    options = arguments[0];
    var djangoFormset = $el.data(pluginName);

    if (!djangoFormset) {
      djangoFormset = new DjangoFormset($el, options);
      $el.data(pluginName, djangoFormset);
    }

    return djangoFormset;
  }

  fn = arguments[0];
  args = $.makeArray(arguments).slice(1);

  if (fn in DjangoFormset.prototype) {
    return $el.data(pluginName)[fn](args);
  } else {
    throw new Error('Unknown function call ' + fn + ' for $.fn.' + pluginName);
  }
};

module.exports = DjangoFormset;

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/jquery.djnutils.js":
/*!******************************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/jquery.djnutils.js ***!
  \******************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.array.sort */ "./node_modules/core-js/modules/es6.array.sort.js");

__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

__webpack_require__(/*! core-js/modules/es6.regexp.match */ "./node_modules/core-js/modules/es6.regexp.match.js");

__webpack_require__(/*! core-js/modules/es6.function.name */ "./node_modules/core-js/modules/es6.function.name.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");

var prefixCache = {};

$.fn.djnData = function (name) {
  var inlineFormsetData = $(this).data('inlineFormset') || {},
      nestedOptions = inlineFormsetData.nestedOptions || {};

  if (!name) {
    return nestedOptions;
  } else {
    return nestedOptions[name];
  }
};

$.fn.djangoPrefixIndex = function () {
  var $this = this.length > 1 ? this.first() : this;
  var id = $this.attr('id'),
      name = $this.attr('name'),
      forattr = $this.attr('for'),
      prefix,
      $form,
      $group,
      groupId,
      cacheKey,
      match,
      index;

  if ((match = prefixCache[id]) || (match = prefixCache[name]) || (match = prefixCache[forattr])) {
    return match;
  }

  if (id && !prefix) {
    prefix = (id.match(/^(.*)\-group$/) || [null, null])[1];
  }

  if (id && !prefix && $this.is('.djn-item') && id.match(/\d+$/)) {
    var _ref = id.match(/(.*?)\-(\d+)$/) || [null, null, null];

    cacheKey = _ref[0];
    prefix = _ref[1];
    index = _ref[2];
  }

  if (!prefix) {
    $form = $this.closest('.djn-inline-form');

    if ($form.length) {
      var _ref2 = $form.attr('id').match(/(.*?)\-(\d+)$/) || [null, null, null];

      cacheKey = _ref2[0];
      prefix = _ref2[1];
      index = _ref2[2];
    } else {
      $group = $this.closest('.djn-group');

      if (!$group.length) {
        return null;
      }

      groupId = $group.attr('id') || '';
      prefix = (groupId.match(/^(.*)\-group$/) || [null, null])[1];
    }
  } else {
    if (prefix.substr(0, 3) == 'id_') {
      prefix = prefix.substr(3);
    }

    if (!document.getElementById(prefix + '-group')) {
      return null;
    }
  }

  if (cacheKey) {
    prefixCache[cacheKey] = [prefix, index];
  }

  return [prefix, index];
};

$.fn.djangoFormPrefix = function () {
  var prefixIndex = this.djangoPrefixIndex();

  if (!prefixIndex || !prefixIndex[1]) {
    return null;
  }

  return prefixIndex[0] + '-' + prefixIndex[1] + '-';
};

$.fn.djangoFormIndex = function () {
  var prefixIndex = this.djangoPrefixIndex();
  return !prefixIndex || !prefixIndex[1] ? null : parseInt(prefixIndex[1], 10);
};

$.fn.djangoFormsetPrefix = function () {
  var prefixIndex = this.djangoPrefixIndex();
  return !prefixIndex ? null : prefixIndex[0];
};

var filterDjangoFormsetForms = function filterDjangoFormsetForms(form, $group, formsetPrefix) {
  var formId = form.getAttribute('id'),
      formIndex = formId.substr(formsetPrefix.length + 1); // Check if form id matches /{prefix}-\d+/

  if (formId.indexOf(formsetPrefix) !== 0) {
    return false;
  }

  return !formIndex.match(/\D/);
}; // Selects all initial forms within the same formset as the
// element the method is being called on.


$.fn.djangoFormsetForms = function () {
  var forms = [];
  this.each(function () {
    var $this = $(this),
        formsetPrefix = $this.djangoFormsetPrefix(),
        $group = formsetPrefix ? $('#' + formsetPrefix + '-group') : null,
        $forms;
    if (!formsetPrefix || !$group.length) return;
    $forms = $group.find('.djn-inline-form').filter(function () {
      return filterDjangoFormsetForms(this, $group, formsetPrefix);
    });
    var sortedForms = $forms.toArray().sort(function (a, b) {
      return $(a).djangoFormIndex() - $(b).djangoFormIndex;
    });
    Array.prototype.push.apply(forms, sortedForms);
  });
  return this.pushStack(forms);
};

if (typeof $.djangoFormField != 'function') {
  $.djangoFormField = function (fieldName, prefix, index) {
    var $empty = $([]),
        matches;

    if (matches = prefix.match(/^(.+)\-(\d+)\-$/)) {
      prefix = matches[1];
      index = matches[2];
    }

    index = parseInt(index, 10);

    if (isNaN(index)) {
      return $empty;
    }

    var namePrefix = prefix + '-' + index + '-';

    if (fieldName == '*') {
      return $('*[name^="' + namePrefix + '"]').filter(function () {
        var fieldPart = $(this).attr('name').substring(namePrefix.length);
        return fieldPart.indexOf('-') === -1;
      });
    }

    var $field = $('#id_' + namePrefix + fieldName);

    if (!$field.length && (fieldName == 'pk' || fieldName == 'position')) {
      var $group = $('#' + prefix + '-group'),
          fieldNameData = $group.djnData('fieldNames') || {};
      fieldName = fieldNameData[fieldName];

      if (!fieldName) {
        return $empty;
      }

      $field = $('#id_' + namePrefix + fieldName);
    }

    return $field;
  };
}

if (typeof $.fn.djangoFormField != 'function') {
  /**
   * Given a django model's field name, and the forms index in the
   * formset, returns the field's input element, or an empty jQuery
   * object on failure.
   *
   * @param String fieldName - 'pk', 'position', or the field's
   *                           name in django (e.g. 'content_type',
   *                           'url', etc.)
   * @return jQuery object containing the field's input element, or
   *         an empty jQuery object on failure
   */
  $.fn.djangoFormField = function (fieldName, index) {
    var prefixAndIndex = this.djangoPrefixIndex();
    var $empty = $([]);

    if (!prefixAndIndex) {
      return $empty;
    }

    var prefix = prefixAndIndex[0];

    if (typeof index == 'undefined') {
      index = prefixAndIndex[1];

      if (typeof index == 'undefined') {
        return $empty;
      }
    }

    return $.djangoFormField(fieldName, prefix, index);
  };
}

if (typeof $.fn.filterDjangoField != 'function') {
  var djRegexCache = {};

  $.fn.filterDjangoField = function (prefix, fieldName, index) {
    var $field, fieldNameData;

    if (typeof index != 'undefined') {
      if (typeof index == 'string') {
        index = parseInt(index, 10);
      }

      if (typeof index == 'number' && !isNaN(index)) {
        var fieldId = 'id_' + prefix + '-' + index + '-' + fieldName;
        $field = $('#' + fieldId);
      }
    } else {
      if (typeof djRegexCache[prefix] != 'object') {
        djRegexCache[prefix] = {};
      }

      if (typeof djRegexCache[prefix][fieldName] == 'undefined') {
        djRegexCache[prefix][fieldName] = new RegExp('^' + prefix + '-\\d+-' + fieldName + '$');
      }

      $field = this.find('input[name$="' + fieldName + '"]').filter(function () {
        return this.getAttribute('name').match(djRegexCache[prefix][fieldName]);
      });
    }

    if (!$field.length && (fieldName == 'pk' || fieldName == 'position')) {
      fieldNameData = $('#' + prefix + '-group').djnData('fieldNames') || {};

      if (typeof fieldNameData[fieldName] && fieldNameData[fieldName] != fieldName) {
        $field = $(this).filterDjangoField(prefix, fieldNameData[fieldName], index);
      }
    }

    return $field;
  };
}

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js":
/*!**************************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js ***!
  \**************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = window.django.jQuery;

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/jquery.ui.djnsortable.js":
/*!************************************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/jquery.ui.djnsortable.js ***!
  \************************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

__webpack_require__(/*! core-js/modules/es6.regexp.match */ "./node_modules/core-js/modules/es6.regexp.match.js");

__webpack_require__(/*! core-js/modules/es6.regexp.split */ "./node_modules/core-js/modules/es6.regexp.split.js");

__webpack_require__(/*! core-js/modules/es6.function.name */ "./node_modules/core-js/modules/es6.function.name.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");
/*!
 * jQuery UI Sortable @VERSION
 * http://jqueryui.com
 *
 * Copyright 2012 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/sortable/
 *
 * Depends:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */


if ($.ui === undefined) {
  var jQuery = $;

  (function (e, t) {
    function i(t, i) {
      var s,
          n,
          r,
          o = t.nodeName.toLowerCase();
      return "area" === o ? (s = t.parentNode, n = s.name, t.href && n && "map" === s.nodeName.toLowerCase() ? (r = e("img[usemap=#" + n + "]")[0], !!r && a(r)) : !1) : (/input|select|textarea|button|object/.test(o) ? !t.disabled : "a" === o ? t.href || i : i) && a(t);
    }

    function a(t) {
      return e.expr.filters.visible(t) && !e(t).parents().addBack().filter(function () {
        return "hidden" === e.css(this, "visibility");
      }).length;
    }

    var s = 0,
        n = /^ui-id-\d+$/;
    e.ui = e.ui || {}, e.extend(e.ui, {
      version: "1.10.3",
      keyCode: {
        BACKSPACE: 8,
        COMMA: 188,
        DELETE: 46,
        DOWN: 40,
        END: 35,
        ENTER: 13,
        ESCAPE: 27,
        HOME: 36,
        LEFT: 37,
        NUMPAD_ADD: 107,
        NUMPAD_DECIMAL: 110,
        NUMPAD_DIVIDE: 111,
        NUMPAD_ENTER: 108,
        NUMPAD_MULTIPLY: 106,
        NUMPAD_SUBTRACT: 109,
        PAGE_DOWN: 34,
        PAGE_UP: 33,
        PERIOD: 190,
        RIGHT: 39,
        SPACE: 32,
        TAB: 9,
        UP: 38
      }
    }), e.fn.extend({
      focus: function (t) {
        return function (i, a) {
          return "number" == typeof i ? this.each(function () {
            var t = this;
            setTimeout(function () {
              e(t).focus(), a && a.call(t);
            }, i);
          }) : t.apply(this, arguments);
        };
      }(e.fn.focus),
      scrollParent: function scrollParent() {
        var t;
        return t = e.ui.ie && /(static|relative)/.test(this.css("position")) || /absolute/.test(this.css("position")) ? this.parents().filter(function () {
          return /(relative|absolute|fixed)/.test(e.css(this, "position")) && /(auto|scroll)/.test(e.css(this, "overflow") + e.css(this, "overflow-y") + e.css(this, "overflow-x"));
        }).eq(0) : this.parents().filter(function () {
          return /(auto|scroll)/.test(e.css(this, "overflow") + e.css(this, "overflow-y") + e.css(this, "overflow-x"));
        }).eq(0), /fixed/.test(this.css("position")) || !t.length ? e(document) : t;
      },
      zIndex: function zIndex(i) {
        if (i !== t) return this.css("zIndex", i);
        if (this.length) for (var a, s, n = e(this[0]); n.length && n[0] !== document;) {
          if (a = n.css("position"), ("absolute" === a || "relative" === a || "fixed" === a) && (s = parseInt(n.css("zIndex"), 10), !isNaN(s) && 0 !== s)) return s;
          n = n.parent();
        }
        return 0;
      },
      uniqueId: function uniqueId() {
        return this.each(function () {
          this.id || (this.id = "ui-id-" + ++s);
        });
      },
      removeUniqueId: function removeUniqueId() {
        return this.each(function () {
          n.test(this.id) && e(this).removeAttr("id");
        });
      }
    }), e.extend(e.expr[":"], {
      data: e.expr.createPseudo ? e.expr.createPseudo(function (t) {
        return function (i) {
          return !!e.data(i, t);
        };
      }) : function (t, i, a) {
        return !!e.data(t, a[3]);
      },
      focusable: function focusable(t) {
        return i(t, !isNaN(e.attr(t, "tabindex")));
      },
      tabbable: function tabbable(t) {
        var a = e.attr(t, "tabindex"),
            s = isNaN(a);
        return (s || a >= 0) && i(t, !s);
      }
    }), e("<a>").outerWidth(1).jquery || e.each(["Width", "Height"], function (i, a) {
      function s(t, i, a, s) {
        return e.each(n, function () {
          i -= parseFloat(e.css(t, "padding" + this)) || 0, a && (i -= parseFloat(e.css(t, "border" + this + "Width")) || 0), s && (i -= parseFloat(e.css(t, "margin" + this)) || 0);
        }), i;
      }

      var n = "Width" === a ? ["Left", "Right"] : ["Top", "Bottom"],
          r = a.toLowerCase(),
          o = {
        innerWidth: e.fn.innerWidth,
        innerHeight: e.fn.innerHeight,
        outerWidth: e.fn.outerWidth,
        outerHeight: e.fn.outerHeight
      };
      e.fn["inner" + a] = function (i) {
        return i === t ? o["inner" + a].call(this) : this.each(function () {
          e(this).css(r, s(this, i) + "px");
        });
      }, e.fn["outer" + a] = function (t, i) {
        return "number" != typeof t ? o["outer" + a].call(this, t) : this.each(function () {
          e(this).css(r, s(this, t, !0, i) + "px");
        });
      };
    }), e.fn.addBack || (e.fn.addBack = function (e) {
      return this.add(null == e ? this.prevObject : this.prevObject.filter(e));
    }), e("<a>").data("a-b", "a").removeData("a-b").data("a-b") && (e.fn.removeData = function (t) {
      return function (i) {
        return arguments.length ? t.call(this, e.camelCase(i)) : t.call(this);
      };
    }(e.fn.removeData)), e.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase()), e.support.selectstart = "onselectstart" in document.createElement("div"), e.fn.extend({
      disableSelection: function disableSelection() {
        return this.bind((e.support.selectstart ? "selectstart" : "mousedown") + ".ui-disableSelection", function (e) {
          e.preventDefault();
        });
      },
      enableSelection: function enableSelection() {
        return this.unbind(".ui-disableSelection");
      }
    }), e.extend(e.ui, {
      plugin: {
        add: function add(t, i, a) {
          var s,
              n = e.ui[t].prototype;

          for (s in a) {
            n.plugins[s] = n.plugins[s] || [], n.plugins[s].push([i, a[s]]);
          }
        },
        call: function call(e, t, i) {
          var a,
              s = e.plugins[t];
          if (s && e.element[0].parentNode && 11 !== e.element[0].parentNode.nodeType) for (a = 0; s.length > a; a++) {
            e.options[s[a][0]] && s[a][1].apply(e.element, i);
          }
        }
      },
      hasScroll: function hasScroll(t, i) {
        if ("hidden" === e(t).css("overflow")) return !1;
        var a = i && "left" === i ? "scrollLeft" : "scrollTop",
            s = !1;
        return t[a] > 0 ? !0 : (t[a] = 1, s = t[a] > 0, t[a] = 0, s);
      }
    });
  })(jQuery);

  (function (e, t) {
    var i = 0,
        s = Array.prototype.slice,
        a = e.cleanData;
    e.cleanData = function (t) {
      for (var i, s = 0; null != (i = t[s]); s++) {
        try {
          e(i).triggerHandler("remove");
        } catch (n) {}
      }

      a(t);
    }, e.widget = function (i, s, a) {
      var n,
          r,
          o,
          h,
          l = {},
          u = i.split(".")[0];
      i = i.split(".")[1], n = u + "-" + i, a || (a = s, s = e.Widget), e.expr[":"][n.toLowerCase()] = function (t) {
        return !!e.data(t, n);
      }, e[u] = e[u] || {}, r = e[u][i], o = e[u][i] = function (e, i) {
        return this._createWidget ? (arguments.length && this._createWidget(e, i), t) : new o(e, i);
      }, e.extend(o, r, {
        version: a.version,
        _proto: e.extend({}, a),
        _childConstructors: []
      }), h = new s(), h.options = e.widget.extend({}, h.options), e.each(a, function (i, a) {
        return e.isFunction(a) ? (l[i] = function () {
          var e = function e() {
            return s.prototype[i].apply(this, arguments);
          },
              t = function t(e) {
            return s.prototype[i].apply(this, e);
          };

          return function () {
            var i,
                s = this._super,
                n = this._superApply;
            return this._super = e, this._superApply = t, i = a.apply(this, arguments), this._super = s, this._superApply = n, i;
          };
        }(), t) : (l[i] = a, t);
      }), o.prototype = e.widget.extend(h, {
        widgetEventPrefix: r ? h.widgetEventPrefix : i
      }, l, {
        constructor: o,
        namespace: u,
        widgetName: i,
        widgetFullName: n
      }), r ? (e.each(r._childConstructors, function (t, i) {
        var s = i.prototype;
        e.widget(s.namespace + "." + s.widgetName, o, i._proto);
      }), delete r._childConstructors) : s._childConstructors.push(o), e.widget.bridge(i, o);
    }, e.widget.extend = function (i) {
      for (var a, n, r = s.call(arguments, 1), o = 0, h = r.length; h > o; o++) {
        for (a in r[o]) {
          n = r[o][a], r[o].hasOwnProperty(a) && n !== t && (i[a] = e.isPlainObject(n) ? e.isPlainObject(i[a]) ? e.widget.extend({}, i[a], n) : e.widget.extend({}, n) : n);
        }
      }

      return i;
    }, e.widget.bridge = function (i, a) {
      var n = a.prototype.widgetFullName || i;

      e.fn[i] = function (r) {
        var o = "string" == typeof r,
            h = s.call(arguments, 1),
            l = this;
        return r = !o && h.length ? e.widget.extend.apply(null, [r].concat(h)) : r, o ? this.each(function () {
          var s,
              a = e.data(this, n);
          return a ? e.isFunction(a[r]) && "_" !== r.charAt(0) ? (s = a[r].apply(a, h), s !== a && s !== t ? (l = s && s.jquery ? l.pushStack(s.get()) : s, !1) : t) : e.error("no such method '" + r + "' for " + i + " widget instance") : e.error("cannot call methods on " + i + " prior to initialization; " + "attempted to call method '" + r + "'");
        }) : this.each(function () {
          var t = e.data(this, n);
          t ? t.option(r || {})._init() : e.data(this, n, new a(r, this));
        }), l;
      };
    }, e.Widget = function () {}, e.Widget._childConstructors = [], e.Widget.prototype = {
      widgetName: "widget",
      widgetEventPrefix: "",
      defaultElement: "<div>",
      options: {
        disabled: !1,
        create: null
      },
      _createWidget: function _createWidget(t, s) {
        s = e(s || this.defaultElement || this)[0], this.element = e(s), this.uuid = i++, this.eventNamespace = "." + this.widgetName + this.uuid, this.options = e.widget.extend({}, this.options, this._getCreateOptions(), t), this.bindings = e(), this.hoverable = e(), this.focusable = e(), s !== this && (e.data(s, this.widgetFullName, this), this._on(!0, this.element, {
          remove: function remove(e) {
            e.target === s && this.destroy();
          }
        }), this.document = e(s.style ? s.ownerDocument : s.document || s), this.window = e(this.document[0].defaultView || this.document[0].parentWindow)), this._create(), this._trigger("create", null, this._getCreateEventData()), this._init();
      },
      _getCreateOptions: e.noop,
      _getCreateEventData: e.noop,
      _create: e.noop,
      _init: e.noop,
      destroy: function destroy() {
        this._destroy(), this.element.unbind(this.eventNamespace).removeData(this.widgetName).removeData(this.widgetFullName).removeData(e.camelCase(this.widgetFullName)), this.widget().unbind(this.eventNamespace).removeAttr("aria-disabled").removeClass(this.widgetFullName + "-disabled " + "ui-state-disabled"), this.bindings.unbind(this.eventNamespace), this.hoverable.removeClass("ui-state-hover"), this.focusable.removeClass("ui-state-focus");
      },
      _destroy: e.noop,
      widget: function widget() {
        return this.element;
      },
      option: function option(i, s) {
        var a,
            n,
            r,
            o = i;
        if (0 === arguments.length) return e.widget.extend({}, this.options);
        if ("string" == typeof i) if (o = {}, a = i.split("."), i = a.shift(), a.length) {
          for (n = o[i] = e.widget.extend({}, this.options[i]), r = 0; a.length - 1 > r; r++) {
            n[a[r]] = n[a[r]] || {}, n = n[a[r]];
          }

          if (i = a.pop(), s === t) return n[i] === t ? null : n[i];
          n[i] = s;
        } else {
          if (s === t) return this.options[i] === t ? null : this.options[i];
          o[i] = s;
        }
        return this._setOptions(o), this;
      },
      _setOptions: function _setOptions(e) {
        var t;

        for (t in e) {
          this._setOption(t, e[t]);
        }

        return this;
      },
      _setOption: function _setOption(e, t) {
        return this.options[e] = t, "disabled" === e && (this.widget().toggleClass(this.widgetFullName + "-disabled ui-state-disabled", !!t).attr("aria-disabled", t), this.hoverable.removeClass("ui-state-hover"), this.focusable.removeClass("ui-state-focus")), this;
      },
      enable: function enable() {
        return this._setOption("disabled", !1);
      },
      disable: function disable() {
        return this._setOption("disabled", !0);
      },
      _on: function _on(i, s, a) {
        var n,
            r = this;
        "boolean" != typeof i && (a = s, s = i, i = !1), a ? (s = n = e(s), this.bindings = this.bindings.add(s)) : (a = s, s = this.element, n = this.widget()), e.each(a, function (a, o) {
          function h() {
            return i || r.options.disabled !== !0 && !e(this).hasClass("ui-state-disabled") ? ("string" == typeof o ? r[o] : o).apply(r, arguments) : t;
          }

          "string" != typeof o && (h.guid = o.guid = o.guid || h.guid || e.guid++);
          var l = a.match(/^(\w+)\s*(.*)$/),
              u = l[1] + r.eventNamespace,
              c = l[2];
          c ? n.delegate(c, u, h) : s.bind(u, h);
        });
      },
      _off: function _off(e, t) {
        t = (t || "").split(" ").join(this.eventNamespace + " ") + this.eventNamespace, e.unbind(t).undelegate(t);
      },
      _delay: function _delay(e, t) {
        function i() {
          return ("string" == typeof e ? s[e] : e).apply(s, arguments);
        }

        var s = this;
        return setTimeout(i, t || 0);
      },
      _hoverable: function _hoverable(t) {
        this.hoverable = this.hoverable.add(t), this._on(t, {
          mouseenter: function mouseenter(t) {
            e(t.currentTarget).addClass("ui-state-hover");
          },
          mouseleave: function mouseleave(t) {
            e(t.currentTarget).removeClass("ui-state-hover");
          }
        });
      },
      _focusable: function _focusable(t) {
        this.focusable = this.focusable.add(t), this._on(t, {
          focusin: function focusin(t) {
            e(t.currentTarget).addClass("ui-state-focus");
          },
          focusout: function focusout(t) {
            e(t.currentTarget).removeClass("ui-state-focus");
          }
        });
      },
      _trigger: function _trigger(t, i, s) {
        var a,
            n,
            r = this.options[t];
        if (s = s || {}, i = e.Event(i), i.type = (t === this.widgetEventPrefix ? t : this.widgetEventPrefix + t).toLowerCase(), i.target = this.element[0], n = i.originalEvent) for (a in n) {
          a in i || (i[a] = n[a]);
        }
        return this.element.trigger(i, s), !(e.isFunction(r) && r.apply(this.element[0], [i].concat(s)) === !1 || i.isDefaultPrevented());
      }
    }, e.each({
      show: "fadeIn",
      hide: "fadeOut"
    }, function (t, i) {
      e.Widget.prototype["_" + t] = function (s, a, n) {
        "string" == typeof a && (a = {
          effect: a
        });
        var r,
            o = a ? a === !0 || "number" == typeof a ? i : a.effect || i : t;
        a = a || {}, "number" == typeof a && (a = {
          duration: a
        }), r = !e.isEmptyObject(a), a.complete = n, a.delay && s.delay(a.delay), r && e.effects && e.effects.effect[o] ? s[t](a) : o !== t && s[o] ? s[o](a.duration, a.easing, n) : s.queue(function (i) {
          e(this)[t](), n && n.call(s[0]), i();
        });
      };
    });
  })(jQuery);

  (function (e) {
    var t = !1;
    e(document).mouseup(function () {
      t = !1;
    }), e.widget("ui.mouse", {
      version: "1.10.3",
      options: {
        cancel: "input,textarea,button,select,option",
        distance: 1,
        delay: 0
      },
      _mouseInit: function _mouseInit() {
        var t = this;
        this.element.bind("mousedown." + this.widgetName, function (e) {
          return t._mouseDown(e);
        }).bind("click." + this.widgetName, function (i) {
          return !0 === e.data(i.target, t.widgetName + ".preventClickEvent") ? (e.removeData(i.target, t.widgetName + ".preventClickEvent"), i.stopImmediatePropagation(), !1) : undefined;
        }), this.started = !1;
      },
      _mouseDestroy: function _mouseDestroy() {
        this.element.unbind("." + this.widgetName), this._mouseMoveDelegate && e(document).unbind("mousemove." + this.widgetName, this._mouseMoveDelegate).unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
      },
      _mouseDown: function _mouseDown(i) {
        if (!t) {
          this._mouseStarted && this._mouseUp(i), this._mouseDownEvent = i;
          var s = this,
              a = 1 === i.which,
              n = "string" == typeof this.options.cancel && i.target.nodeName ? e(i.target).closest(this.options.cancel).length : !1;
          return a && !n && this._mouseCapture(i) ? (this.mouseDelayMet = !this.options.delay, this.mouseDelayMet || (this._mouseDelayTimer = setTimeout(function () {
            s.mouseDelayMet = !0;
          }, this.options.delay)), this._mouseDistanceMet(i) && this._mouseDelayMet(i) && (this._mouseStarted = this._mouseStart(i) !== !1, !this._mouseStarted) ? (i.preventDefault(), !0) : (!0 === e.data(i.target, this.widgetName + ".preventClickEvent") && e.removeData(i.target, this.widgetName + ".preventClickEvent"), this._mouseMoveDelegate = function (e) {
            return s._mouseMove(e);
          }, this._mouseUpDelegate = function (e) {
            return s._mouseUp(e);
          }, e(document).bind("mousemove." + this.widgetName, this._mouseMoveDelegate).bind("mouseup." + this.widgetName, this._mouseUpDelegate), i.preventDefault(), t = !0, !0)) : !0;
        }
      },
      _mouseMove: function _mouseMove(t) {
        return e.ui.ie && (!document.documentMode || 9 > document.documentMode) && !t.button ? this._mouseUp(t) : this._mouseStarted ? (this._mouseDrag(t), t.preventDefault()) : (this._mouseDistanceMet(t) && this._mouseDelayMet(t) && (this._mouseStarted = this._mouseStart(this._mouseDownEvent, t) !== !1, this._mouseStarted ? this._mouseDrag(t) : this._mouseUp(t)), !this._mouseStarted);
      },
      _mouseUp: function _mouseUp(t) {
        return e(document).unbind("mousemove." + this.widgetName, this._mouseMoveDelegate).unbind("mouseup." + this.widgetName, this._mouseUpDelegate), this._mouseStarted && (this._mouseStarted = !1, t.target === this._mouseDownEvent.target && e.data(t.target, this.widgetName + ".preventClickEvent", !0), this._mouseStop(t)), !1;
      },
      _mouseDistanceMet: function _mouseDistanceMet(e) {
        return Math.max(Math.abs(this._mouseDownEvent.pageX - e.pageX), Math.abs(this._mouseDownEvent.pageY - e.pageY)) >= this.options.distance;
      },
      _mouseDelayMet: function _mouseDelayMet() {
        return this.mouseDelayMet;
      },
      _mouseStart: function _mouseStart() {},
      _mouseDrag: function _mouseDrag() {},
      _mouseStop: function _mouseStop() {},
      _mouseCapture: function _mouseCapture() {
        return !0;
      }
    });
  })(jQuery);

  (function (e, t) {
    function i(e, t, i) {
      return [parseFloat(e[0]) * (p.test(e[0]) ? t / 100 : 1), parseFloat(e[1]) * (p.test(e[1]) ? i / 100 : 1)];
    }

    function s(t, i) {
      return parseInt(e.css(t, i), 10) || 0;
    }

    function a(t) {
      var i = t[0];
      return 9 === i.nodeType ? {
        width: t.width(),
        height: t.height(),
        offset: {
          top: 0,
          left: 0
        }
      } : e.isWindow(i) ? {
        width: t.width(),
        height: t.height(),
        offset: {
          top: t.scrollTop(),
          left: t.scrollLeft()
        }
      } : i.preventDefault ? {
        width: 0,
        height: 0,
        offset: {
          top: i.pageY,
          left: i.pageX
        }
      } : {
        width: t.outerWidth(),
        height: t.outerHeight(),
        offset: t.offset()
      };
    }

    e.ui = e.ui || {};
    var n,
        r = Math.max,
        o = Math.abs,
        h = Math.round,
        l = /left|center|right/,
        u = /top|center|bottom/,
        c = /[\+\-]\d+(\.[\d]+)?%?/,
        d = /^\w+/,
        p = /%$/,
        f = e.fn.position;
    e.position = {
      scrollbarWidth: function scrollbarWidth() {
        if (n !== t) return n;
        var i,
            s,
            a = e("<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),
            r = a.children()[0];
        return e("body").append(a), i = r.offsetWidth, a.css("overflow", "scroll"), s = r.offsetWidth, i === s && (s = a[0].clientWidth), a.remove(), n = i - s;
      },
      getScrollInfo: function getScrollInfo(t) {
        var i = t.isWindow ? "" : t.element.css("overflow-x"),
            s = t.isWindow ? "" : t.element.css("overflow-y"),
            a = "scroll" === i || "auto" === i && t.width < t.element[0].scrollWidth,
            n = "scroll" === s || "auto" === s && t.height < t.element[0].scrollHeight;
        return {
          width: n ? e.position.scrollbarWidth() : 0,
          height: a ? e.position.scrollbarWidth() : 0
        };
      },
      getWithinInfo: function getWithinInfo(t) {
        var i = e(t || window),
            s = e.isWindow(i[0]);
        return {
          element: i,
          isWindow: s,
          offset: i.offset() || {
            left: 0,
            top: 0
          },
          scrollLeft: i.scrollLeft(),
          scrollTop: i.scrollTop(),
          width: s ? i.width() : i.outerWidth(),
          height: s ? i.height() : i.outerHeight()
        };
      }
    }, e.fn.position = function (t) {
      if (!t || !t.of) return f.apply(this, arguments);
      t = e.extend({}, t);

      var n,
          p,
          m,
          g,
          v,
          y,
          b = e(t.of),
          _ = e.position.getWithinInfo(t.within),
          x = e.position.getScrollInfo(_),
          k = (t.collision || "flip").split(" "),
          w = {};

      return y = a(b), b[0].preventDefault && (t.at = "left top"), p = y.width, m = y.height, g = y.offset, v = e.extend({}, g), e.each(["my", "at"], function () {
        var e,
            i,
            s = (t[this] || "").split(" ");
        1 === s.length && (s = l.test(s[0]) ? s.concat(["center"]) : u.test(s[0]) ? ["center"].concat(s) : ["center", "center"]), s[0] = l.test(s[0]) ? s[0] : "center", s[1] = u.test(s[1]) ? s[1] : "center", e = c.exec(s[0]), i = c.exec(s[1]), w[this] = [e ? e[0] : 0, i ? i[0] : 0], t[this] = [d.exec(s[0])[0], d.exec(s[1])[0]];
      }), 1 === k.length && (k[1] = k[0]), "right" === t.at[0] ? v.left += p : "center" === t.at[0] && (v.left += p / 2), "bottom" === t.at[1] ? v.top += m : "center" === t.at[1] && (v.top += m / 2), n = i(w.at, p, m), v.left += n[0], v.top += n[1], this.each(function () {
        var a,
            l,
            u = e(this),
            c = u.outerWidth(),
            d = u.outerHeight(),
            f = s(this, "marginLeft"),
            y = s(this, "marginTop"),
            D = c + f + s(this, "marginRight") + x.width,
            T = d + y + s(this, "marginBottom") + x.height,
            M = e.extend({}, v),
            S = i(w.my, u.outerWidth(), u.outerHeight());
        "right" === t.my[0] ? M.left -= c : "center" === t.my[0] && (M.left -= c / 2), "bottom" === t.my[1] ? M.top -= d : "center" === t.my[1] && (M.top -= d / 2), M.left += S[0], M.top += S[1], e.support.offsetFractions || (M.left = h(M.left), M.top = h(M.top)), a = {
          marginLeft: f,
          marginTop: y
        }, e.each(["left", "top"], function (i, s) {
          e.ui.position[k[i]] && e.ui.position[k[i]][s](M, {
            targetWidth: p,
            targetHeight: m,
            elemWidth: c,
            elemHeight: d,
            collisionPosition: a,
            collisionWidth: D,
            collisionHeight: T,
            offset: [n[0] + S[0], n[1] + S[1]],
            my: t.my,
            at: t.at,
            within: _,
            elem: u
          });
        }), t.using && (l = function l(e) {
          var i = g.left - M.left,
              s = i + p - c,
              a = g.top - M.top,
              n = a + m - d,
              h = {
            target: {
              element: b,
              left: g.left,
              top: g.top,
              width: p,
              height: m
            },
            element: {
              element: u,
              left: M.left,
              top: M.top,
              width: c,
              height: d
            },
            horizontal: 0 > s ? "left" : i > 0 ? "right" : "center",
            vertical: 0 > n ? "top" : a > 0 ? "bottom" : "middle"
          };
          c > p && p > o(i + s) && (h.horizontal = "center"), d > m && m > o(a + n) && (h.vertical = "middle"), h.important = r(o(i), o(s)) > r(o(a), o(n)) ? "horizontal" : "vertical", t.using.call(this, e, h);
        }), u.offset(e.extend(M, {
          using: l
        }));
      });
    }, e.ui.position = {
      fit: {
        left: function left(e, t) {
          var i,
              s = t.within,
              a = s.isWindow ? s.scrollLeft : s.offset.left,
              n = s.width,
              o = e.left - t.collisionPosition.marginLeft,
              h = a - o,
              l = o + t.collisionWidth - n - a;
          t.collisionWidth > n ? h > 0 && 0 >= l ? (i = e.left + h + t.collisionWidth - n - a, e.left += h - i) : e.left = l > 0 && 0 >= h ? a : h > l ? a + n - t.collisionWidth : a : h > 0 ? e.left += h : l > 0 ? e.left -= l : e.left = r(e.left - o, e.left);
        },
        top: function top(e, t) {
          var i,
              s = t.within,
              a = s.isWindow ? s.scrollTop : s.offset.top,
              n = t.within.height,
              o = e.top - t.collisionPosition.marginTop,
              h = a - o,
              l = o + t.collisionHeight - n - a;
          t.collisionHeight > n ? h > 0 && 0 >= l ? (i = e.top + h + t.collisionHeight - n - a, e.top += h - i) : e.top = l > 0 && 0 >= h ? a : h > l ? a + n - t.collisionHeight : a : h > 0 ? e.top += h : l > 0 ? e.top -= l : e.top = r(e.top - o, e.top);
        }
      },
      flip: {
        left: function left(e, t) {
          var i,
              s,
              a = t.within,
              n = a.offset.left + a.scrollLeft,
              r = a.width,
              h = a.isWindow ? a.scrollLeft : a.offset.left,
              l = e.left - t.collisionPosition.marginLeft,
              u = l - h,
              c = l + t.collisionWidth - r - h,
              d = "left" === t.my[0] ? -t.elemWidth : "right" === t.my[0] ? t.elemWidth : 0,
              p = "left" === t.at[0] ? t.targetWidth : "right" === t.at[0] ? -t.targetWidth : 0,
              f = -2 * t.offset[0];
          0 > u ? (i = e.left + d + p + f + t.collisionWidth - r - n, (0 > i || o(u) > i) && (e.left += d + p + f)) : c > 0 && (s = e.left - t.collisionPosition.marginLeft + d + p + f - h, (s > 0 || c > o(s)) && (e.left += d + p + f));
        },
        top: function top(e, t) {
          var i,
              s,
              a = t.within,
              n = a.offset.top + a.scrollTop,
              r = a.height,
              h = a.isWindow ? a.scrollTop : a.offset.top,
              l = e.top - t.collisionPosition.marginTop,
              u = l - h,
              c = l + t.collisionHeight - r - h,
              d = "top" === t.my[1],
              p = d ? -t.elemHeight : "bottom" === t.my[1] ? t.elemHeight : 0,
              f = "top" === t.at[1] ? t.targetHeight : "bottom" === t.at[1] ? -t.targetHeight : 0,
              m = -2 * t.offset[1];
          0 > u ? (s = e.top + p + f + m + t.collisionHeight - r - n, e.top + p + f + m > u && (0 > s || o(u) > s) && (e.top += p + f + m)) : c > 0 && (i = e.top - t.collisionPosition.marginTop + p + f + m - h, e.top + p + f + m > c && (i > 0 || c > o(i)) && (e.top += p + f + m));
        }
      },
      flipfit: {
        left: function left() {
          e.ui.position.flip.left.apply(this, arguments), e.ui.position.fit.left.apply(this, arguments);
        },
        top: function top() {
          e.ui.position.flip.top.apply(this, arguments), e.ui.position.fit.top.apply(this, arguments);
        }
      }
    }, function () {
      var t,
          i,
          s,
          a,
          n,
          r = document.getElementsByTagName("body")[0],
          o = document.createElement("div");
      t = document.createElement(r ? "div" : "body"), s = {
        visibility: "hidden",
        width: 0,
        height: 0,
        border: 0,
        margin: 0,
        background: "none"
      }, r && e.extend(s, {
        position: "absolute",
        left: "-1000px",
        top: "-1000px"
      });

      for (n in s) {
        t.style[n] = s[n];
      }

      t.appendChild(o), i = r || document.documentElement, i.insertBefore(t, i.firstChild), o.style.cssText = "position: absolute; left: 10.7432222px;", a = e(o).offset().left, e.support.offsetFractions = a > 10 && 11 > a, t.innerHTML = "", i.removeChild(t);
    }();
  })(jQuery);
}

$.widget("ui.djnsortable", $.ui.mouse, {
  version: "@VERSION",
  widgetEventPrefix: "sort",
  ready: false,
  options: {
    appendTo: "parent",
    axis: false,
    connectWith: false,
    containment: false,
    cursor: 'auto',
    cursorAt: false,
    dropOnEmpty: true,
    forcePlaceholderSize: false,
    forceHelperSize: false,
    grid: false,
    handle: false,
    helper: "original",
    items: '> *',
    opacity: false,
    placeholder: false,
    revert: false,
    scroll: true,
    scrollSensitivity: 20,
    scrollSpeed: 20,
    scope: "default",
    tolerance: "intersect",
    zIndex: 1000
  },
  _isOverAxis: function _isOverAxis(x, reference, size) {
    return x >= reference && x < reference + size;
  },
  _create: function _create() {
    var o = this.options;
    this.containerCache = {};
    this.element.addClass("ui-sortable"); //Get the items

    this.refresh(); //Let's determine if the items are being displayed horizontally

    this.floating = this.items.length ? o.axis === 'x' || /left|right/.test(this.items[0].item.css('float')) || /inline|table-cell/.test(this.items[0].item.css('display')) : false; //Let's determine the parent's offset

    this.offset = this.element.offset(); //Initialize mouse events for interaction

    this._mouseInit(); //We're ready to go


    this.ready = true;
  },
  _destroy: function _destroy() {
    this.element.removeClass("ui-sortable ui-sortable-disabled");

    this._mouseDestroy();

    for (var i = this.items.length - 1; i >= 0; i--) {
      this.items[i].item.removeData(this.widgetName + "-item");
    }

    return this;
  },
  _setOption: function _setOption(key, value) {
    if (key === "disabled") {
      this.options[key] = value;
      this.widget().toggleClass("ui-sortable-disabled", !!value);
    } else {
      // Don't call widget base _setOption for disable as it adds ui-state-disabled class
      $.Widget.prototype._setOption.apply(this, arguments);
    }
  },
  _mouseCapture: function _mouseCapture(event, overrideHandle) {
    var that = this;

    if (this.reverting) {
      return false;
    }

    if (this.options.disabled || this.options.type == 'static') return false; //We have to refresh the items data once first

    this._refreshItems(event); //Find out if the clicked node (or one of its parents) is a actual item in this.items


    var currentItem = null,
        nodes = $(event.target).parents().each(function () {
      if ($.data(this, that.widgetName + '-item') == that) {
        currentItem = $(this);
        return false;
      }
    });
    if ($.data(event.target, that.widgetName + '-item') == that) currentItem = $(event.target);
    if (!currentItem) return false;

    if (this.options.handle && !overrideHandle) {
      var validHandle = false;
      var addBackMethod = $.fn.addBack ? 'addBack' : 'andSelf';
      $(this.options.handle, currentItem).find("*")[addBackMethod]().each(function () {
        if (this == event.target) validHandle = true;
      });
      if (!validHandle) return false;
    }

    this.currentItem = currentItem;

    this._removeCurrentsFromItems();

    return true;
  },
  _mouseStart: function _mouseStart(event, overrideHandle, noActivation) {
    var o = this.options;
    this.currentContainer = this; //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture

    this.refreshPositions(); //Create and append the visible helper

    this.helper = this._createHelper(event); //Cache the helper size

    this._cacheHelperProportions();
    /*
     * - Position generation -
     * This block generates everything position related - it's the core of draggables.
     */
    //Cache the margins of the original element


    this._cacheMargins(); //Get the next scrolling parent


    this.scrollParent = this.helper.scrollParent(); //The element's absolute position on the page minus margins

    this.offset = this.currentItem.offset();
    this.offset = {
      top: this.offset.top - this.margins.top,
      left: this.offset.left - this.margins.left
    };
    $.extend(this.offset, {
      click: {
        //Where the click happened, relative to the element
        left: event.pageX - this.offset.left,
        top: event.pageY - this.offset.top
      },
      parent: this._getParentOffset(),
      relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper

    }); // Only after we got the offset, we can change the helper's position to absolute
    // TODO: Still need to figure out a way to make relative sorting possible

    this.helper.css("position", "absolute");
    this.cssPosition = this.helper.css("position"); //Generate the original position

    this.originalPosition = this._generatePosition(event);
    this.originalPageX = event.pageX;
    this.originalPageY = event.pageY; //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied

    o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt); //Cache the former DOM position

    this.domPosition = {
      prev: this.currentItem.prev()[0],
      parent: this.currentItem.parent()[0]
    }; //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way

    if (this.helper[0] != this.currentItem[0]) {
      this.currentItem.hide();
    } //Create the placeholder


    this._createPlaceholder(); //Set a containment if given in the options


    if (o.containment) this._setContainment();

    if (o.cursor) {
      // cursor option
      if ($('body').css("cursor")) this._storedCursor = $('body').css("cursor");
      $('body').css("cursor", o.cursor);
    }

    if (o.opacity) {
      // opacity option
      if (this.helper.css("opacity")) this._storedOpacity = this.helper.css("opacity");
      this.helper.css("opacity", o.opacity);
    }

    if (o.zIndex) {
      // zIndex option
      if (this.helper.css("zIndex")) this._storedZIndex = this.helper.css("zIndex");
      this.helper.css("zIndex", o.zIndex);
    } //Prepare scrolling


    if (this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') this.overflowOffset = this.scrollParent.offset(); //Call callbacks

    this._trigger("start", event, this._uiHash()); //Recache the helper size


    if (!this._preserveHelperProportions) this._cacheHelperProportions(); //Post 'activate' events to possible containers

    if (!noActivation) {
      for (var i = this.containers.length - 1; i >= 0; i--) {
        this.containers[i]._trigger("activate", event, this._uiHash(this));
      }
    } //Prepare possible droppables


    if ($.ui.ddmanager) $.ui.ddmanager.current = this;
    if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, event);
    this.dragging = true;
    this.helper.addClass("ui-sortable-helper");

    this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position


    return true;
  },
  _mouseDrag: function _mouseDrag(event) {
    //Compute the helpers position
    this.position = this._generatePosition(event);
    this.positionAbs = this._convertPositionTo("absolute");

    if (!this.lastPositionAbs) {
      this.lastPositionAbs = this.positionAbs;
    } //Do scrolling


    if (this.options.scroll) {
      var o = this.options,
          scrolled = false;

      if (this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') {
        if (this.overflowOffset.top + this.scrollParent[0].offsetHeight - event.pageY < o.scrollSensitivity) this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;else if (event.pageY - this.overflowOffset.top < o.scrollSensitivity) this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
        if (this.overflowOffset.left + this.scrollParent[0].offsetWidth - event.pageX < o.scrollSensitivity) this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;else if (event.pageX - this.overflowOffset.left < o.scrollSensitivity) this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
      } else {
        if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
        if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
      }

      if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, event);
    } //Regenerate the absolute position used for position checks


    this.positionAbs = this._convertPositionTo("absolute"); //Set the helper position

    if (!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left + 'px';
    if (!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top + 'px'; //Rearrange

    for (var i = this.items.length - 1; i >= 0; i--) {
      //Cache variables and intersection, continue if no intersection
      var item = this.items[i],
          itemElement = item.item[0],
          intersection = this._intersectsWithPointer(item);

      if (!intersection) continue; // Only put the placeholder inside the current Container, skip all
      // items form other containers. This works because when moving
      // an item from one container to another the
      // currentContainer is switched before the placeholder is moved.
      //
      // Without this moving items in "sub-sortables" can cause the placeholder to jitter
      // beetween the outer and inner container.

      if (item.instance !== this.currentContainer) continue;

      if (itemElement != this.currentItem[0] //cannot intersect with itself
      && this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
      && !$.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
      && (this.options.type == 'semi-dynamic' ? !$.contains(this.element[0], itemElement) : true) //&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container
      ) {
          this.direction = intersection == 1 ? "down" : "up";

          if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
            this._rearrange(event, item);
          } else {
            break;
          }

          this._trigger("change", event, this._uiHash());

          break;
        }
    } //Post events to containers


    this._contactContainers(event); //Interconnect with droppables


    if ($.ui.ddmanager) $.ui.ddmanager.drag(this, event); //Call callbacks

    this._trigger('sort', event, this._uiHash());

    this.lastPositionAbs = this.positionAbs;
    return false;
  },
  _mouseStop: function _mouseStop(event, noPropagation) {
    if (!event) return; //If we are using droppables, inform the manager about the drop

    if ($.ui.ddmanager && !this.options.dropBehaviour) $.ui.ddmanager.drop(this, event);

    if (this.options.revert) {
      var that = this;
      var cur = this.placeholder.offset();
      this.reverting = true;
      $(this.helper).animate({
        left: cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft),
        top: cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)
      }, parseInt(this.options.revert, 10) || 500, function () {
        that._clear(event);
      });
    } else {
      this._clear(event, noPropagation);
    }

    return false;
  },
  cancel: function cancel() {
    if (this.dragging) {
      this._mouseUp({
        target: null
      });

      if (this.options.helper == "original") this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");else this.currentItem.show(); //Post deactivating events to containers

      for (var i = this.containers.length - 1; i >= 0; i--) {
        this.containers[i]._trigger("deactivate", null, this._uiHash(this));

        if (this.containers[i].containerCache.over) {
          this.containers[i]._trigger("out", null, this._uiHash(this));

          this.containers[i].containerCache.over = 0;
        }
      }
    }

    if (this.placeholder) {
      //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
      if (this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
      if (this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove();
      $.extend(this, {
        helper: null,
        dragging: false,
        reverting: false,
        _noFinalSort: null
      });

      if (this.domPosition.prev) {
        $(this.domPosition.prev).after(this.currentItem);
      } else {
        $(this.domPosition.parent).prepend(this.currentItem);
      }
    }

    return this;
  },
  serialize: function serialize(o) {
    var items = this._getItemsAsjQuery(o && o.connected);

    var str = [];
    o = o || {};
    $(items).each(function () {
      var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || /(.+)[-=_](.+)/);
      if (res) str.push((o.key || res[1] + '[]') + '=' + (o.key && o.expression ? res[1] : res[2]));
    });

    if (!str.length && o.key) {
      str.push(o.key + '=');
    }

    return str.join('&');
  },
  toArray: function toArray(o) {
    var items = this._getItemsAsjQuery(o && o.connected);

    var ret = [];
    o = o || {};
    items.each(function () {
      ret.push($(o.item || this).attr(o.attribute || 'id') || '');
    });
    return ret;
  },

  /* Be careful with the following core functions */
  _intersectsWith: function _intersectsWith(item) {
    var x1 = this.positionAbs.left,
        x2 = x1 + this.helperProportions.width,
        y1 = this.positionAbs.top,
        y2 = y1 + this.helperProportions.height;
    var l = item.left,
        r = l + item.width,
        t = item.top,
        b = t + Math.max(10, item.height);
    var dyClick = this.offset.click.top,
        dxClick = this.offset.click.left;
    var isOverElement = y1 + dyClick > t && y1 + dyClick < b && x1 + dxClick > l && x1 + dxClick < r;

    if (this.options.tolerance == "pointer" || this.options.forcePointerForContainers || this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height']) {
      return isOverElement;
    } else {
      return l < x1 + this.helperProportions.width / 2 // Right Half
      && x2 - this.helperProportions.width / 2 < r // Left Half
      && t < y1 + this.helperProportions.height / 2 // Bottom Half
      && y2 - this.helperProportions.height / 2 < b; // Top Half
    }
  },
  _intersectsWithPointer: function _intersectsWithPointer(item) {
    var isOverElementHeight = this.options.axis === 'x' || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, Math.max(10, item.height)),
        isOverElementWidth = this.options.axis === 'y' || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
        isOverElement = isOverElementHeight && isOverElementWidth,
        verticalDirection = this._getDragVerticalDirection(),
        horizontalDirection = this._getDragHorizontalDirection();

    if (!isOverElement) return false;
    return this.floating ? horizontalDirection && horizontalDirection == "right" || verticalDirection == "down" ? 2 : 1 : verticalDirection && (verticalDirection == "down" ? 2 : 1);
  },
  _intersectsWithSides: function _intersectsWithSides(item) {
    var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + Math.max(10, item.height) / 2, Math.max(10, item.height)),
        isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + item.width / 2, item.width),
        verticalDirection = this._getDragVerticalDirection(),
        horizontalDirection = this._getDragHorizontalDirection();

    if (this.floating && horizontalDirection) {
      return horizontalDirection == "right" && isOverRightHalf || horizontalDirection == "left" && !isOverRightHalf;
    } else {
      return verticalDirection && (verticalDirection == "down" && isOverBottomHalf || verticalDirection == "up" && !isOverBottomHalf);
    }
  },
  _getDragVerticalDirection: function _getDragVerticalDirection() {
    var delta = this.positionAbs.top - this.lastPositionAbs.top;
    return delta != 0 && (delta > 0 ? "down" : "up");
  },
  _getDragHorizontalDirection: function _getDragHorizontalDirection() {
    var delta = this.positionAbs.left - this.lastPositionAbs.left;
    return delta != 0 && (delta > 0 ? "right" : "left");
  },
  refresh: function refresh(event) {
    this._refreshItems(event);

    this.refreshPositions();
    return this;
  },
  _connectWith: function _connectWith() {
    var options = this.options;
    return options.connectWith.constructor == String ? [options.connectWith] : options.connectWith;
  },
  _getItemsAsjQuery: function _getItemsAsjQuery(connected) {
    var items = [];
    var queries = [];

    var connectWith = this._connectWith();

    if (connectWith && connected) {
      for (var i = connectWith.length - 1; i >= 0; i--) {
        var cur = $(connectWith[i]);

        for (var j = cur.length - 1; j >= 0; j--) {
          var inst = $.data(cur[j], this.widgetName);

          if (inst && inst != this && !inst.options.disabled) {
            queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not('.ui-sortable-placeholder'), inst]);
          }
        }

        ;
      }

      ;
    }

    queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, {
      options: this.options,
      item: this.currentItem
    }) : $(this.options.items, this.element).not(".ui-sortable-helper").not('.ui-sortable-placeholder'), this]);

    for (var i = queries.length - 1; i >= 0; i--) {
      queries[i][0].each(function () {
        items.push(this);
      });
    }

    ;
    return $(items);
  },
  _removeCurrentsFromItems: function _removeCurrentsFromItems() {
    var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
    this.items = $.grep(this.items, function (item) {
      for (var j = 0; j < list.length; j++) {
        if (list[j] == item.item[0]) return false;
      }

      ;
      return true;
    });
  },
  _refreshItems: function _refreshItems(event) {
    this.items = [];
    this.containers = [this];
    var items = this.items;
    var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, {
      item: this.currentItem
    }) : $(this.options.items, this.element), this]];

    var connectWith = this._connectWith();

    if (connectWith && this.ready) {
      //Shouldn't be run the first time through due to massive slow-down
      for (var i = connectWith.length - 1; i >= 0; i--) {
        var cur = $(connectWith[i]);

        for (var j = cur.length - 1; j >= 0; j--) {
          var inst = $.data(cur[j], this.widgetName);

          if (inst && inst != this && !inst.options.disabled) {
            queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, {
              item: this.currentItem
            }) : $(inst.options.items, inst.element), inst]);
            this.containers.push(inst);
          }
        }

        ;
      }

      ;
    }

    for (var i = queries.length - 1; i >= 0; i--) {
      var targetData = queries[i][1];
      var _queries = queries[i][0];

      for (var j = 0, queriesLength = _queries.length; j < queriesLength; j++) {
        var item = $(_queries[j]);
        item.data(this.widgetName + '-item', targetData); // Data for target checking (mouse manager)

        items.push({
          item: item,
          instance: targetData,
          width: 0,
          height: 0,
          left: 0,
          top: 0
        });
      }

      ;
    }

    ;
  },
  refreshPositions: function refreshPositions(fast) {
    //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
    if (this.offsetParent && this.helper) {
      this.offset.parent = this._getParentOffset();
    }

    for (var i = this.items.length - 1; i >= 0; i--) {
      var item = this.items[i]; //We ignore calculating positions of all connected containers when we're not over them

      if (item.instance != this.currentContainer && this.currentContainer && item.item[0] != this.currentItem[0]) continue;
      var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;

      if (!fast) {
        item.width = t.outerWidth();
        item.height = t.outerHeight();
      }

      var p = t.offset();
      item.left = p.left;
      item.top = p.top;
    }

    ;

    if (this.options.custom && this.options.custom.refreshContainers) {
      this.options.custom.refreshContainers.call(this);
    } else {
      for (var i = this.containers.length - 1; i >= 0; i--) {
        var p = this.containers[i].element.offset();
        this.containers[i].containerCache.left = p.left;
        this.containers[i].containerCache.top = p.top;
        this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
        this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
      }

      ;
    }

    return this;
  },
  _createPlaceholder: function _createPlaceholder(that) {
    that = that || this;
    var o = that.options;

    if (!o.placeholder || o.placeholder.constructor == String) {
      var className = o.placeholder;
      o.placeholder = {
        element: function element() {
          var el = $(document.createElement(that.currentItem[0].nodeName)).addClass(className || that.currentItem[0].className + " ui-sortable-placeholder").removeClass("ui-sortable-helper")[0];
          if (!className) el.style.visibility = "hidden";
          return el;
        },
        update: function update(container, p) {
          // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
          // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
          if (className && !o.forcePlaceholderSize) return; //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item

          if (!p.height()) {
            p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css('paddingTop') || 0, 10) - parseInt(that.currentItem.css('paddingBottom') || 0, 10));
          }

          ;

          if (!p.width()) {
            p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css('paddingLeft') || 0, 10) - parseInt(that.currentItem.css('paddingRight') || 0, 10));
          }

          ;
        }
      };
    } //Create the placeholder


    that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem)); //Append it after the actual current item

    that.currentItem.after(that.placeholder); //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)

    o.placeholder.update(that, that.placeholder);
  },
  _contactContainers: function _contactContainers(event) {
    // get innermost container that intersects with item
    var innermostContainer = null,
        innermostIndex = null;

    for (var i = this.containers.length - 1; i >= 0; i--) {
      // never consider a container that's located within the item itself
      if ($.contains(this.currentItem[0], this.containers[i].element[0])) continue;

      if (this._intersectsWith(this.containers[i].containerCache)) {
        // if we've already found a container and it's more "inner" than this, then continue
        if (innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) continue;
        innermostContainer = this.containers[i];
        innermostIndex = i;
      } else {
        // container doesn't intersect. trigger "out" event if necessary
        if (this.containers[i].containerCache.over) {
          this.containers[i]._trigger("out", event, this._uiHash(this));

          this.containers[i].containerCache.over = 0;
        }
      }
    } // if no intersecting containers found, return


    if (!innermostContainer) return; // move the item into the container if it's not there already

    if (this.containers.length === 1) {
      this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));

      this.containers[innermostIndex].containerCache.over = 1;
    } else {
      //When entering a new container, we will find the item with the least distance and append our item near it
      var dist = 10000;
      var itemWithLeastDistance = null;
      var posProperty = this.containers[innermostIndex].floating ? 'left' : 'top';
      var sizeProperty = this.containers[innermostIndex].floating ? 'width' : 'height';
      var base = this.positionAbs[posProperty] + this.offset.click[posProperty];

      for (var j = this.items.length - 1; j >= 0; j--) {
        if (!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue;
        if (this.items[j].item[0] == this.currentItem[0]) continue;
        var cur = this.items[j].item.offset()[posProperty];
        var nearBottom = false;

        if (Math.abs(cur - base) > Math.abs(cur + Math.max(10, this.items[j][sizeProperty]) - base)) {
          nearBottom = true;
          cur += this.items[j][sizeProperty];
        }

        if (Math.abs(cur - base) < dist) {
          dist = Math.abs(cur - base);
          itemWithLeastDistance = this.items[j];
          this.direction = nearBottom ? "up" : "down";
        }
      }

      if (!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
        return;
      this.currentContainer = this.containers[innermostIndex];
      itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);

      this._trigger("change", event, this._uiHash());

      this.containers[innermostIndex]._trigger("change", event, this._uiHash(this)); //Update the placeholder


      this.options.placeholder.update(this.currentContainer, this.placeholder);

      this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));

      this.containers[innermostIndex].containerCache.over = 1;
    }
  },
  _createHelper: function _createHelper(event) {
    var o = this.options;
    var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : o.helper == 'clone' ? this.currentItem.clone() : this.currentItem;
    if (!helper.parents('body').length) //Add the helper to the DOM if that didn't happen already
      $(o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
    if (helper[0] == this.currentItem[0]) this._storedCSS = {
      width: this.currentItem[0].style.width,
      height: this.currentItem[0].style.height,
      position: this.currentItem.css("position"),
      top: this.currentItem.css("top"),
      left: this.currentItem.css("left")
    };
    if (helper[0].style.width == '' || o.forceHelperSize) helper.width(this.currentItem.width());
    if (helper[0].style.height == '' || o.forceHelperSize) helper.height(this.currentItem.height());
    return helper;
  },
  _adjustOffsetFromHelper: function _adjustOffsetFromHelper(obj) {
    if (typeof obj == 'string') {
      obj = obj.split(' ');
    }

    if ($.isArray(obj)) {
      obj = {
        left: +obj[0],
        top: +obj[1] || 0
      };
    }

    if ('left' in obj) {
      this.offset.click.left = obj.left + this.margins.left;
    }

    if ('right' in obj) {
      this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
    }

    if ('top' in obj) {
      this.offset.click.top = obj.top + this.margins.top;
    }

    if ('bottom' in obj) {
      this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
    }
  },
  _getParentOffset: function _getParentOffset() {
    //Get the offsetParent and cache its position
    this.offsetParent = this.helper.offsetParent();
    var po = this.offsetParent.offset(); // This is a special case where we need to modify a offset calculated on start, since the following happened:
    // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
    // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
    //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag

    if (this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
      po.left += this.scrollParent.scrollLeft();
      po.top += this.scrollParent.scrollTop();
    }

    if (this.offsetParent[0] == document.body || //This needs to be actually done for all browsers, since pageX/pageY includes this information
    this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.ui.ie) //Ugly IE fix
      po = {
        top: 0,
        left: 0
      };
    return {
      top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
      left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
    };
  },
  _getRelativeOffset: function _getRelativeOffset() {
    if (this.cssPosition == "relative") {
      var p = this.currentItem.position();
      return {
        top: p.top - (parseInt(this.helper.css("top"), 10) || 0) + this.scrollParent.scrollTop(),
        left: p.left - (parseInt(this.helper.css("left"), 10) || 0) + this.scrollParent.scrollLeft()
      };
    } else {
      return {
        top: 0,
        left: 0
      };
    }
  },
  _cacheMargins: function _cacheMargins() {
    this.margins = {
      left: parseInt(this.currentItem.css("marginLeft"), 10) || 0,
      top: parseInt(this.currentItem.css("marginTop"), 10) || 0
    };
  },
  _cacheHelperProportions: function _cacheHelperProportions() {
    this.helperProportions = {
      width: this.helper.outerWidth(),
      height: this.helper.outerHeight()
    };
  },
  _setContainment: function _setContainment() {
    var o = this.options;
    if (o.containment == 'parent') o.containment = this.helper[0].parentNode;
    if (o.containment == 'document' || o.containment == 'window') this.containment = [0 - this.offset.relative.left - this.offset.parent.left, 0 - this.offset.relative.top - this.offset.parent.top, $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left, ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top];

    if (!/^(document|window|parent)$/.test(o.containment)) {
      var ce = $(o.containment)[0];
      var co = $(o.containment).offset();
      var over = $(ce).css("overflow") != 'hidden';
      this.containment = [co.left + (parseInt($(ce).css("borderLeftWidth"), 10) || 0) + (parseInt($(ce).css("paddingLeft"), 10) || 0) - this.margins.left, co.top + (parseInt($(ce).css("borderTopWidth"), 10) || 0) + (parseInt($(ce).css("paddingTop"), 10) || 0) - this.margins.top, co.left + (over ? Math.max(ce.scrollWidth, ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"), 10) || 0) - (parseInt($(ce).css("paddingRight"), 10) || 0) - this.helperProportions.width - this.margins.left, co.top + (over ? Math.max(ce.scrollHeight, ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"), 10) || 0) - (parseInt($(ce).css("paddingBottom"), 10) || 0) - this.helperProportions.height - this.margins.top];
    }
  },
  _convertPositionTo: function _convertPositionTo(d, pos) {
    if (!pos) pos = this.position;
    var mod = d == "absolute" ? 1 : -1;
    var o = this.options,
        scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
        scrollIsRootNode = /(html|body)/i.test(scroll[0].tagName);
    return {
      top: pos.top // The absolute mouse position
      + this.offset.relative.top * mod // Only for relative positioned nodes: Relative offset from element to offset parent
      + this.offset.parent.top * mod // The offsetParent's offset without borders (offset + border)
      - (this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : scrollIsRootNode ? 0 : scroll.scrollTop()) * mod,
      left: pos.left // The absolute mouse position
      + this.offset.relative.left * mod // Only for relative positioned nodes: Relative offset from element to offset parent
      + this.offset.parent.left * mod // The offsetParent's offset without borders (offset + border)
      - (this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft()) * mod
    };
  },
  _generatePosition: function _generatePosition(event) {
    var o = this.options,
        scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
        scrollIsRootNode = /(html|body)/i.test(scroll[0].tagName); // This is another very weird special case that only happens for relative elements:
    // 1. If the css position is relative
    // 2. and the scroll parent is the document or similar to the offset parent
    // we have to refresh the relative offset during the scroll so there are no jumps

    if (this.cssPosition == 'relative' && !(this.scrollParent[0] != document && this.scrollParent[0] != this.offsetParent[0])) {
      this.offset.relative = this._getRelativeOffset();
    }

    var pageX = event.pageX;
    var pageY = event.pageY;
    /*
     * - Position constraining -
     * Constrain the position to a mix of grid, containment.
     */

    if (this.originalPosition) {
      //If we are not dragging yet, we won't check for options
      if (this.containment) {
        if (event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
        if (event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
        if (event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
        if (event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
      }

      if (o.grid) {
        var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
        pageY = this.containment ? !(top - this.offset.click.top < this.containment[1] || top - this.offset.click.top > this.containment[3]) ? top : !(top - this.offset.click.top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1] : top;
        var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
        pageX = this.containment ? !(left - this.offset.click.left < this.containment[0] || left - this.offset.click.left > this.containment[2]) ? left : !(left - this.offset.click.left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0] : left;
      }
    }

    return {
      top: pageY // The absolute mouse position
      - this.offset.click.top // Click offset (relative to the element)
      - this.offset.relative.top // Only for relative positioned nodes: Relative offset from element to offset parent
      - this.offset.parent.top // The offsetParent's offset without borders (offset + border)
      + (this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : scrollIsRootNode ? 0 : scroll.scrollTop()),
      left: pageX // The absolute mouse position
      - this.offset.click.left // Click offset (relative to the element)
      - this.offset.relative.left // Only for relative positioned nodes: Relative offset from element to offset parent
      - this.offset.parent.left // The offsetParent's offset without borders (offset + border)
      + (this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft())
    };
  },
  _rearrange: function _rearrange(event, i, a, hardRefresh) {
    a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], this.direction == 'down' ? i.item[0] : i.item[0].nextSibling); //Various things done here to improve the performance:
    // 1. we create a setTimeout, that calls refreshPositions
    // 2. on the instance, we have a counter variable, that get's higher after every append
    // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
    // 4. this lets only the last addition to the timeout stack through

    this.counter = this.counter ? ++this.counter : 1;
    var counter = this.counter;

    this._delay(function () {
      if (counter == this.counter) this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
    });
  },
  _clear: function _clear(event, noPropagation) {
    this.reverting = false; // We delay all events that have to be triggered to after the point where the placeholder has been removed and
    // everything else normalized again

    var delayedTriggers = []; // We first have to update the dom position of the actual currentItem
    // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)

    if (!this._noFinalSort && this.currentItem.parent().length) this.placeholder.before(this.currentItem);
    this._noFinalSort = null;

    if (this.helper[0] == this.currentItem[0]) {
      for (var i in this._storedCSS) {
        if (this._storedCSS[i] == 'auto' || this._storedCSS[i] == 'static') this._storedCSS[i] = '';
      }

      this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
    } else {
      this.currentItem.show();
    }

    if (this.fromOutside && !noPropagation) delayedTriggers.push(function (event) {
      this._trigger("receive", event, this._uiHash(this.fromOutside));
    });
    if ((this.fromOutside || this.domPosition.prev != this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent != this.currentItem.parent()[0]) && !noPropagation) delayedTriggers.push(function (event) {
      this._trigger("update", event, this._uiHash());
    }); //Trigger update callback if the DOM position has changed
    // Check if the items Container has Changed and trigger appropriate
    // events.

    if (this !== this.currentContainer) {
      if (!noPropagation) {
        delayedTriggers.push(function (event) {
          this._trigger("remove", event, this._uiHash());
        });
        delayedTriggers.push(function (c) {
          return function (event) {
            c._trigger("receive", event, this._uiHash(this));
          };
        }.call(this, this.currentContainer));
        delayedTriggers.push(function (c) {
          return function (event) {
            c._trigger("update", event, this._uiHash(this));
          };
        }.call(this, this.currentContainer));
      }
    } //Post events to containers


    for (var i = this.containers.length - 1; i >= 0; i--) {
      if (!noPropagation) delayedTriggers.push(function (c) {
        return function (event) {
          c._trigger("deactivate", event, this._uiHash(this));
        };
      }.call(this, this.containers[i]));

      if (this.containers[i].containerCache.over) {
        delayedTriggers.push(function (c) {
          return function (event) {
            c._trigger("out", event, this._uiHash(this));
          };
        }.call(this, this.containers[i]));
        this.containers[i].containerCache.over = 0;
      }
    } //Do what was originally in plugins


    if (this._storedCursor) $('body').css("cursor", this._storedCursor); //Reset cursor

    if (this._storedOpacity) this.helper.css("opacity", this._storedOpacity); //Reset opacity

    if (this._storedZIndex) this.helper.css("zIndex", this._storedZIndex == 'auto' ? '' : this._storedZIndex); //Reset z-index

    this.dragging = false;

    if (this.cancelHelperRemoval) {
      if (!noPropagation) {
        this._trigger("beforeStop", event, this._uiHash());

        for (var i = 0; i < delayedTriggers.length; i++) {
          delayedTriggers[i].call(this, event);
        }

        ; //Trigger all delayed events

        this._trigger("stop", event, this._uiHash());
      }

      this.fromOutside = false;
      return false;
    }

    if (!noPropagation) this._trigger("beforeStop", event, this._uiHash()); //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!

    this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
    if (this.helper[0] != this.currentItem[0]) this.helper.remove();
    this.helper = null;

    if (!noPropagation) {
      for (var i = 0; i < delayedTriggers.length; i++) {
        delayedTriggers[i].call(this, event);
      }

      ; //Trigger all delayed events

      this._trigger("stop", event, this._uiHash());
    }

    this.fromOutside = false;
    return true;
  },
  _trigger: function _trigger() {
    if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
      this.cancel();
    }
  },
  _delay: function _delay(handler, delay) {
    function handlerProxy() {
      return (typeof handler === "string" ? instance[handler] : handler).apply(instance, arguments);
    }

    var instance = this;
    return setTimeout(handlerProxy, delay || 0);
  },
  _uiHash: function _uiHash(_inst) {
    var inst = _inst || this;
    return {
      helper: inst.helper,
      placeholder: inst.placeholder || $([]),
      position: inst.position,
      originalPosition: inst.originalPosition,
      offset: inst.positionAbs,
      item: inst.currentItem,
      sender: _inst ? _inst.element : null
    };
  }
});

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/jquery.ui.nestedsortable.js":
/*!***************************************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/jquery.ui.nestedsortable.js ***!
  \***************************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.array.sort */ "./node_modules/core-js/modules/es6.array.sort.js");

__webpack_require__(/*! core-js/modules/es6.regexp.match */ "./node_modules/core-js/modules/es6.regexp.match.js");

__webpack_require__(/*! core-js/modules/es6.regexp.replace */ "./node_modules/core-js/modules/es6.regexp.replace.js");

__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");

__webpack_require__(/*! ./jquery.ui.djnsortable */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.ui.djnsortable.js");
/*
 * jQuery UI Nested Sortable
 * v 1.3.4 / 28 apr 2011
 * http://mjsarfatti.com/sandbox/nestedSortable
 *
 * Depends:
 *    jquery.ui.sortable.js 1.8+
 *
 * License CC BY-SA 3.0
 * Copyright 2010-2011, Manuele J Sarfatti
 */


if (typeof $.fn.nearest != 'function') {
  /**
   * Returns the descendant(s) matching a given selector which are the
   * shortest distance from the search context element (in otherwords,
   * $.fn.closest(), in reverse).
   */
  $.fn.nearest = function (selector) {
    var nearest = [],
        node = this,
        distance = 10000;
    node.find(selector).each(function () {
      var d = $(this).parentsUntil(node).length;

      if (d < distance) {
        distance = d;
        nearest = [this];
      } else if (d == distance) {
        nearest.push(this);
      }
    });
    return this.pushStack(nearest, 'nearest', [selector]);
  };
}

var counter = 0;
var expando = "djn" + ("" + Math.random()).replace(/\D/g, "");

var createChildNestedSortable = function createChildNestedSortable(parent, childContainer) {
  // Don't continue if the new element is the same as the old
  if (parent && parent.element && parent.element[0] == childContainer) {
    return;
  }

  var $childContainer = $(childContainer),
      options = $.extend({}, parent.options);
  options.connectWith = [parent.element];

  if ($childContainer.data(parent.widgetName)) {
    return;
  }

  var widgetConstructor = $childContainer[parent.widgetName];
  widgetConstructor.call($childContainer, options);
  var newInstance = $childContainer.data(parent.widgetName);

  for (var i = 0; i < parent.options.connectWith.length; i++) {
    var $otherContainer = parent.options.connectWith[i];
    newInstance.addToConnectWith($otherContainer);
    var otherInstance = $otherContainer.data(parent.widgetName);

    if (otherInstance) {
      otherInstance.addToConnectWith($childContainer);
    }
  }

  parent.addToConnectWith($childContainer);
  return newInstance;
};

$.widget("ui.nestedSortable", $.ui.djnsortable, {
  options: {
    tabSize: 20,
    disableNesting: 'ui-nestedSortable-no-nesting',
    errorClass: 'ui-nestedSortable-error',
    nestedContainerSelector: ':not(*)',
    // Whether to clear empty list item and container elements
    doNotClear: false,

    /**
     * Create a list container element if the draggable was dragged
     * to the top or bottom of the elements at its level.
     *
     * @param DOMElement parent - The element relative to which the
     *      new element will be inserted.
     * @return DOMElement - The new element.
     */
    createContainerElement: function createContainerElement(parent) {
      return $(document.createElement('ol'));
    },
    // Selector which matches all container elements in the nestedSortable
    containerElementSelector: 'ol',
    // Selector which matches all list items (draggables) in the nestedSortable
    listItemSelector: 'li',
    // Selector which, when applied to a container, returns its child list items
    items: '> li',
    maxLevels: 0,
    revertOnError: 1,
    protectRoot: false,
    rootID: null,
    rtl: false,
    // if true, you can not move nodes to different levels of nesting
    fixedNestingDepth: false,
    // show the error div or just not show a drop area
    showErrorDiv: true,
    // if true only allows you to rearrange within its parent container
    keepInParent: false,
    isAllowed: function isAllowed(item, parent) {
      return true;
    },
    canConnectWith: function canConnectWith(container1, container2, instance) {
      var model1 = container1.data('inlineModel');
      var model2 = container2.data('inlineModel');

      if (model1 !== model2) {
        return false;
      }

      var instance2 = container2.data(instance.widgetName);

      if (!instance.options.fixedNestingDepth) {
        if (!instance2 || !instance2.options.fixedNestingDepth) {
          return true;
        }
      }

      var container1Level = instance._getLevel(container1);

      var container2Level = instance._getLevel(container2);

      return container1Level === container2Level;
    }
  },
  _createWidget: function _createWidget(options, element) {
    var $element = $(element || this.defaultElement || this),
        dataOptions = $element.data('djnsortableOptions');
    element = $element[0];

    if (dataOptions) {
      options = $.extend({}, options, dataOptions);
    }

    return $.ui.djnsortable.prototype._createWidget.call(this, options, element);
  },
  _create: function _create() {
    if (this.element.data('uiNestedSortable')) {
      this.element.data('nestedSortable', this.element.data('uiNestedSortable'));
    }

    if (this.element.data('ui-nestedSortable')) {
      this.element.data('nestedSortable', this.element.data('ui-nestedSortable'));
    }

    this.element.data('djnsortable', this.element.data('nestedSortable'));

    if (this.element.data('uiNestedSortable')) {
      this.element.data('uiSortable', this.element.data('nestedSortable'));
    } // if (!this.element.is(this.options.containerElementSelector)) {
    //  throw new Error('nestedSortable: Please check that the ' +
    //                  'containerElementSelector option matches ' +
    //                  'the element passed to the constructor.');
    //             }


    $.ui.djnsortable.prototype._create.apply(this, arguments);

    this._connectWithMap = {};
    var self = this,
        o = this.options,
        $document = $(document);
    var originalConnectWith = o.connectWith;

    if (!originalConnectWith || typeof originalConnectWith == 'string') {
      this.options.connectWith = [];

      if (typeof originalConnectWith == 'string') {
        var connected = this._connectWith();

        for (var i = 0; i < connected.length; i++) {
          this.addToConnectWith($(connected[i]));
        }
      } // HACK!! FIX!! (django-specific logic)


      $document.on('djnesting:init.nestedSortable', o.containerElementSelector, function (event) {
        createChildNestedSortable(self, this);
      });
      this.element.find(o.containerElementSelector + ':not(.subarticle-wrapper)').each(function (i, el) {
        if ($(el).closest('[data-inline-formset]').attr('id').indexOf('-empty') > -1) {
          return;
        }

        createChildNestedSortable(self, el);
      });
    }

    $document.trigger('nestedSortable:created', [this]);
    $document.on('nestedSortable:created.nestedSortable', function (e, instance) {
      instance.addToConnectWith(self.element);
      self.addToConnectWith(instance.element);
    });
  },
  addToConnectWith: function addToConnectWith(element) {
    var self = this,
        $element = typeof element.selector != 'undefined' ? element : $(element),
        uniqueId;

    if ($element.length > 1) {
      $element.each(function (i, el) {
        self.addToConnectWith($(el));
      });
      return;
    }

    uniqueId = element[0][expando];

    if (typeof uniqueId == 'undefined') {
      uniqueId = element[0][expando] = ++counter;
    }

    if (typeof this.options.connectWith == 'string') {
      return;
    }

    if (this._connectWithMap[uniqueId]) {
      return;
    }

    this.options.connectWith.push(element);
    this._connectWithMap[uniqueId] = 1;
  },
  _destroy: function _destroy() {
    this.element.removeData("nestedSortable").unbind(".nestedSortable");
    $(document).unbind('.nestedSortable');
    return $.ui.djnsortable.prototype.destroy.apply(this, arguments);
  },

  /**
   * Override this method to add extra conditions on an item before it's
   * rearranged.
   */
  _intersectsWithPointer: function _intersectsWithPointer(item) {
    var itemElement = item.item[0],
        o = this.options,
        intersection = $.ui.djnsortable.prototype._intersectsWithPointer.apply(this, arguments);

    this.lastItemElement = null;

    if (!intersection) {
      return intersection;
    } // Only put the placeholder inside the current Container, skip all
    // items from other containers. This works because when moving
    // an item from one container to another the
    // currentContainer is switched before the placeholder is moved.
    //
    // Without this moving items in "sub-sortables" can cause the placeholder to jitter
    // between the outer and inner container.


    if (item.instance !== this.currentContainer) {
      return false;
    }

    var $itemElement = $(itemElement);

    if (o.fixedNestingDepth && this._getLevel(this.currentItem) === 1 + this._getLevel($itemElement)) {
      $itemElement = function () {
        var containerSel = o.containerElementSelector;
        var $childItems = $itemElement.find('.djn-item');

        if ($childItems.length != 1) {
          return $itemElement;
        }

        if (!$childItems.is('.djn-no-drag,.djn-thead')) {
          return $itemElement;
        }

        var itemElementClosestContainer = $itemElement.closest(containerSel);

        if (!itemElementClosestContainer.length) {
          return $itemElement;
        } // Make sure the item is only one level deeper


        if (itemElementClosestContainer[0] != $childItems.closest(containerSel).closest(containerSel)[0]) {
          return $itemElement;
        }

        return $($childItems[0]);
      }();

      itemElement = $itemElement[0];
    }

    if (itemElement != this.currentItem[0] //cannot intersect with itself
    && this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
    && !$.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
    && (this.options.type == 'semi-dynamic' ? !$.contains(this.element[0], itemElement) : true) && (!o.keepInParent || itemElement.parentNode == this.placeholder[0].parentNode) //only rearrange items within the same container
    && (!o.fixedNestingDepth || this._getLevel(this.currentItem) === this._getLevel($itemElement)) //maintain the nesting level of node
    && (o.showErrorDiv || o.isAllowed.call(this, this.currentItem[0], itemElement.parentNode, this.placeholder))) {
      this.lastItemElement = itemElement;
      return intersection;
    } else {
      return false;
    }
  },
  // This method is called after items have been iterated through.
  // Overriding this is cleaner than copying and pasting _mouseDrag()
  // and inserting logic in the middle.
  _contactContainers: function _contactContainers(event) {
    if (this.lastItemElement) {
      this._clearEmpty(this.lastItemElement);
    }

    var o = this.options,
        _parentItem = this.placeholder.closest(o.listItemSelector),
        parentItem = _parentItem.length && _parentItem.closest('.ui-sortable').length ? _parentItem : null,
        level = this._getLevel(this.placeholder),
        childLevels = this._getChildLevels(this.helper);

    var placeholderClassName = this.placeholder.attr('class');
    var phClassSearch = " " + placeholderClassName + " "; // If the current level class isn't already set

    if (phClassSearch.indexOf(" ui-sortable-nested-level-" + level + " ") == -1) {
      var phOrigClassName; // Check if another level class is set

      var phOrigClassNameEndPos = phClassSearch.indexOf(" ui-sortable-nested-level-") - 1;

      if (phOrigClassNameEndPos > -1) {
        phOrigClassName = placeholderClassName.substring(0, phOrigClassNameEndPos);
      } else {
        phOrigClassName = placeholderClassName;
      } // Add new level to class


      this.placeholder.attr('class', phOrigClassName + ' ui-sortable-nested-level-' + level);
    } // To find the previous sibling in the list, keep backtracking until we hit a valid list item.


    var previousItem = this.placeholder[0].previousSibling ? $(this.placeholder[0].previousSibling) : null;

    if (previousItem != null) {
      while (!previousItem.is(this.options.listItemSelector) || previousItem[0] == this.currentItem[0] || previousItem[0] == this.helper[0]) {
        if (previousItem[0].previousSibling) {
          previousItem = $(previousItem[0].previousSibling);
        } else {
          previousItem = null;
          break;
        }
      }
    } // To find the next sibling in the list, keep stepping forward until we hit a valid list item.


    var nextItem = this.placeholder[0].nextSibling ? $(this.placeholder[0].nextSibling) : null;

    if (nextItem != null) {
      while (!nextItem.is(this.options.listItemSelector) || nextItem[0] == this.currentItem[0] || nextItem[0] == this.helper[0]) {
        if (nextItem[0].nextSibling) {
          nextItem = $(nextItem[0].nextSibling);
        } else {
          nextItem = null;
          break;
        }
      }
    }

    this.beyondMaxLevels = 0; // We will change this to the instance of the nested container if
    // appropriate, so that the appropriate context is applied to the
    // super _contactContainers prototype method

    var containerInstance = this;
    this.refreshPositions(); // If the item is moved to the left, send it to its parent's level unless there are siblings below it.

    if (!o.fixedNestingDepth && parentItem != null && nextItem == null && (o.rtl && this.positionAbs.left + this.helper.outerWidth() > parentItem.offset().left + parentItem.outerWidth() || !o.rtl && this.positionAbs.left < parentItem.offset().left)) {
      parentItem.after(this.placeholder[0]);
      containerInstance = parentItem.closest(o.containerElementSelector).data(this.widgetName) || containerInstance;

      this._clearEmpty(parentItem[0]);

      this.refreshPositions();

      this._trigger("change", event, this._uiHash());
    } // If the item is below a sibling and is moved to the right, make it a child of that sibling.
    else if (!o.fixedNestingDepth && previousItem != null && !previousItem.is('.djn-no-drag,.djn-thead') && (o.rtl && this.positionAbs.left + this.helper.outerWidth() < previousItem.offset().left + previousItem.outerWidth() - o.tabSize || !o.rtl && this.positionAbs.left > previousItem.offset().left + o.tabSize)) {
        this._isAllowed(previousItem, level, level + childLevels);

        if (this.beyondMaxLevels > 0) {
          return $.ui.djnsortable.prototype._contactContainers.apply(this, arguments);
        }

        var $previousItemChildContainer;
        $previousItemChildContainer = previousItem.nearest(o.containerElementSelector).first();

        if (!$previousItemChildContainer.length && !previousItem.closest(o.nestedContainerSelector).length) {
          $previousItemChildContainer = this.options.createContainerElement(previousItem[0]);
          previousItem.append($previousItemChildContainer);
        }

        if ($previousItemChildContainer.length) {
          $previousItemChildContainer.append(this.placeholder);
          containerInstance = $previousItemChildContainer.data(this.widgetName);

          if (!containerInstance) {
            containerInstance = createChildNestedSortable(this, $previousItemChildContainer[0]);
          }

          this.refreshPositions();
        }

        this._trigger("change", event, this._uiHash());
      } else {
        this._isAllowed(parentItem, level, level + childLevels);
      }

    $.ui.djnsortable.prototype._contactContainers.call(this, event);
  },
  _rearrange: function _rearrange(event, item, a, hardRefresh) {
    // Cache the rearranged element for the call to _clear()
    var o = this.options;

    if (item && typeof item == 'object' && item.item) {
      this.lastRearrangedElement = item.item[0];
    }

    if (item && typeof item == 'object' && item.item && this.placeholder.closest(o.nestedContainerSelector).length) {
      // This means we have been dropped into a nested container down a level
      // from the parent.
      var placeholderParentItem = this.placeholder.closest(o.listItemSelector);
      var comparisonElement = this.direction == 'down' ? placeholderParentItem.next(o.nestedContainerSelector) : placeholderParentItem;

      if (comparisonElement.length && comparisonElement[0] == item.item[0]) {
        //Various things done here to improve the performance:
        // 1. we create a setTimeout, that calls refreshPositions
        // 2. on the instance, we have a counter variable, that get's higher after every append
        // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
        // 4. this lets only the last addition to the timeout stack through
        this.counter = this.counter ? ++this.counter : 1;
        var counter = this.counter;

        this._delay(function () {
          if (counter == this.counter) this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
        }); // The super method will pop the container out of its nested container,
        // which we don't want.


        return;
      }
    }

    $.ui.djnsortable.prototype._rearrange.apply(this, arguments);
  },
  _convertPositionTo: function _convertPositionTo(d, pos) {
    // Cache the top offset before rearrangement
    this.previousTopOffset = this.placeholder.offset().top;
    return $.ui.djnsortable.prototype._convertPositionTo.apply(this, arguments);
  },
  _clear: function _clear() {
    $.ui.djnsortable.prototype._clear.apply(this, arguments); // If lastRearrangedElement exists and is still attached to the document
    // (i.e., hasn't been removed)


    if (typeof this.lastRearrangedElement == 'object' && this.lastRearrangedElement.ownerDocument) {
      this._clearEmpty(this.lastRearrangedElement);
    }
  },
  _mouseStop: function _mouseStop(event, noPropagation) {
    // If the item is in a position not allowed, send it back
    if (this.beyondMaxLevels) {
      this.placeholder.removeClass(this.options.errorClass);

      if (this.domPosition.prev) {
        $(this.domPosition.prev).after(this.placeholder);
      } else {
        $(this.domPosition.parent).prepend(this.placeholder);
      }

      this._trigger("revert", event, this._uiHash());
    } // Clean last empty container/list item


    for (var i = this.items.length - 1; i >= 0; i--) {
      var item = this.items[i].item[0];

      this._clearEmpty(item);
    }

    $.ui.djnsortable.prototype._mouseStop.apply(this, arguments);
  },
  toArray: function toArray(o) {
    o = $.extend(true, {}, this.options, o || {});
    var sDepth = o.startDepthCount || 0,
        ret = [],
        left = 2;
    ret.push({
      "item_id": o.rootID,
      "parent_id": 'none',
      "depth": sDepth,
      "left": '1',
      "right": ($(o.listItemSelector, this.element).length + 1) * 2
    });

    var _recursiveArray = function _recursiveArray(item, depth, left) {
      var right = left + 1,
          id,
          pid;
      var $childItems = $(item).children(o.containerElementSelector).find(o.items);

      if ($childItems.length > 0) {
        depth++;
        $childItems.each(function () {
          right = _recursiveArray($(this), depth, right);
        });
        depth--;
      }

      id = $(item).attr(o.attribute || 'id').match(o.expression || /(.+)[-=_](.+)/);

      if (depth === sDepth + 1) {
        pid = o.rootID;
      } else {
        var parentItem = $(item).parent(o.containerElementSelector).parent(o.items).attr(o.attribute || 'id').match(o.expression || /(.+)[-=_](.+)/);
        pid = parentItem[2];
      }

      if (id) {
        ret.push({
          "item_id": id[2],
          "parent_id": pid,
          "depth": depth,
          "left": left,
          "right": right
        });
      }

      left = right + 1;
      return left;
    };

    $(this.element).children(o.listItemSelector).each(function () {
      left = _recursiveArray(this, sDepth + 1, left);
    });
    ret = ret.sort(function (a, b) {
      return a.left - b.left;
    });
    return ret;
  },
  _clearEmpty: function _clearEmpty(item) {
    if (this.options.doNotClear) {
      return;
    }

    var $item = $(item);
    var childContainers = $item.nearest(this.options.containerElementSelector);
    childContainers.each(function (i, childContainer) {
      var $childContainer = $(childContainer);

      if (!$childContainer.children().length) {
        var instance = $childContainer.data(this.widgetName);

        if (typeof instance == 'object' && instance.destroy) {
          instance.destroy();
        }

        $childContainer.remove();
      }
    });

    if (!$item.children().length) {
      $item.remove();
    }
  },
  _getLevel: function _getLevel(item) {
    var level = 1,
        o = this.options,
        list;

    if (o.containerElementSelector) {
      list = item.closest(o.containerElementSelector);

      while (list && list.length > 0 && !list.parent().is('.djn-group-root')) {
        // if (!list.is(o.nestedContainerSelector)) {
        level++; // }

        list = list.parent().closest(o.containerElementSelector);
      }
    }

    return level;
  },
  _getChildLevels: function _getChildLevels(parent, depth) {
    var self = this,
        o = this.options,
        result = 0;
    depth = depth || 0;
    $(parent).nearest(o.containerElementSelector).first().find(o.items).each(function (index, child) {
      if ($(child).is('.djn-no-drag,.djn-thead')) {
        return;
      }

      result = Math.max(self._getChildLevels(child, depth + 1), result);
    });
    return depth ? result + 1 : result;
  },
  _isAllowed: function _isAllowed(parentItem, level, levels) {
    var o = this.options,
        isRoot = $(this.domPosition.parent).hasClass('ui-sortable') ? true : false; // this takes into account the maxLevels set to the recipient list
    // var maxLevels = this.placeholder.closest('.ui-sortable').nestedSortable('option', 'maxLevels');

    var maxLevels = o.maxLevels; // Is the root protected?
    // Are we trying to nest under a no-nest?
    // Are we nesting too deep?

    if (parentItem && typeof parentItem == 'object' && typeof parentItem.selector == 'undefined') {
      parentItem = $(parentItem);
    }

    if (!o.isAllowed.call(this, this.currentItem, parentItem, this.placeholder) || parentItem && parentItem.hasClass(o.disableNesting) || o.protectRoot && (parentItem == null && !isRoot || isRoot && level > 1)) {
      this.placeholder.addClass(o.errorClass);

      if (maxLevels < levels && maxLevels != 0) {
        this.beyondMaxLevels = levels - maxLevels;
      } else {
        this.beyondMaxLevels = 1;
      }
    } else {
      if (maxLevels < levels && maxLevels != 0) {
        this.placeholder.addClass(o.errorClass);
        this.beyondMaxLevels = levels - maxLevels;
      } else {
        this.placeholder.removeClass(o.errorClass);
        this.beyondMaxLevels = 0;
      }
    }
  },
  _connectWith: function _connectWith() {
    var origConnectWith = $.ui.djnsortable.prototype._connectWith.apply(this, arguments),
        connectWith = [];

    var self = this;

    for (var i = 0; i < origConnectWith.length; i++) {
      var $elements = $(origConnectWith[i]);
      $elements.each(function (j, el) {
        if (el == self.element[0]) {
          return;
        }

        if (!self.options.canConnectWith(self.element, $(el), self)) {
          return;
        }

        connectWith.push(el);
      });
    }

    return connectWith;
  },
  _removeCurrentsFromItems: function _removeCurrentsFromItems() {
    var list = this.currentItem.find(":data(sortable-item)");

    for (var i = 0; i < this.items.length; i++) {
      for (var j = 0; j < list.length; j++) {
        if (list[j] == this.items[i].item[0]) {
          this.items.splice(i, 1);

          if (i >= this.items.length) {
            break;
          }
        }
      }
    }
  },
  createContainerElement: function createContainerElement(parent) {
    if (!parent.childNodes) {
      throw new Error("Invalid element 'parent' passed to " + "createContainerElement.");
    }

    var newContainer = this.options.createContainerElement.apply(this, arguments);
    parent.appendChild(newContainer[0]);
    return $(newContainer);
  }
});
$.ui.nestedSortable.prototype.options = $.extend({}, $.ui.djnsortable.prototype.options, $.ui.nestedSortable.prototype.options);

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/regexquote.js":
/*!*************************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/regexquote.js ***!
  \*************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.regexp.replace */ "./node_modules/core-js/modules/es6.regexp.replace.js");

module.exports = function regexQuote(str) {
  return (str + '').replace(/([\.\?\*\+\^\$\[\]\\\(\)\{\}\|\-])/g, '\\$1');
};

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/sortable.js":
/*!***********************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/sortable.js ***!
  \***********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__(/*! core-js/modules/es6.regexp.replace */ "./node_modules/core-js/modules/es6.regexp.replace.js");

__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

__webpack_require__(/*! core-js/modules/es6.regexp.match */ "./node_modules/core-js/modules/es6.regexp.match.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");

var regexQuote = __webpack_require__(/*! ./regexquote */ "./nested_admin/static/nested_admin/src/nested-admin/regexquote.js");

__webpack_require__(/*! ./jquery.ui.nestedsortable */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.ui.nestedsortable.js");

function updatePositions(prefix) {
  var position = 0,
      count = 1,
      $group = $('#' + prefix + '-group'),
      groupData = $group.djnData(),
      fieldNames = groupData.fieldNames,
      groupFkName = groupData.formsetFkName,
      parentPkVal,
      _ref = prefix.match(/^(.*)\-(\d+)-[^\-]+(?:\-\d+)?$/) || [],
      parentPrefix = _ref[1],
      index = _ref[2],
      sortableOptions = groupData.sortableOptions,
      sortableExcludes = (sortableOptions || {}).sortableExcludes || [];

  sortableExcludes.push(groupFkName);

  if (parentPrefix) {
    var $parentGroup = $('#' + parentPrefix + '-group');
    var parentFieldNames = $parentGroup.djnData('fieldNames');
    var parentPkFieldName = parentFieldNames.pk;
    var parentPkField = $parentGroup.filterDjangoField(parentPrefix, parentPkFieldName, index);
    parentPkVal = parentPkField.val();
  }

  if (groupFkName && typeof parentPkVal != 'undefined') {
    $group.filterDjangoField(prefix, groupFkName).val(parentPkVal).trigger('change');
  }

  $group.find('.djn-inline-form').each(function () {
    if (!this.id || this.id.substr(-6) == '-empty') {
      return true; // Same as continue
    }

    var regex = new RegExp('^(?:id_)?' + regexQuote(prefix) + '\\-\\d+$');

    if (!this.id.match(regex)) {
      return true;
    } // Cache jQuery object


    var $this = $(this),
        _ref2 = $this.djangoPrefixIndex() || [null, null],
        formPrefix = _ref2[0],
        index = _ref2[1],
        namePrefix = formPrefix + '-' + index + '-';

    if (!formPrefix) {
      return;
    } // Set header position for stacked inlines in Django 1.9+


    var $inlineLabel = $this.find('> h3 > .inline_label');

    if ($inlineLabel.length) {
      $inlineLabel.html($inlineLabel.html().replace(/(#\d+)/g, '#' + count));
    }

    count++;
    var $fields = $this.djangoFormField('*'),
        $positionField,
        setPosition = false; // position is being updated if
    // a) the field has a value
    // b) if the field is not exluded with sortable_excludes (e.g. with default values)

    $fields.each(function () {
      var $field = $(this);

      if (!$field.is(':input[type!=radio][type!=checkbox],input:checked')) {
        return;
      }

      var hasValue = $field.val() || $field.attr('type') == 'file' && $field.siblings('a').length,
          fieldName = $field.attr('name').substring(namePrefix.length);

      if (fieldName == fieldNames.position) {
        $positionField = $field;
      }

      if (hasValue && $.inArray(fieldName, sortableExcludes) === -1) {
        setPosition = true;
      }
    });

    if (!setPosition || !$positionField) {
      return;
    }

    $positionField.val(position).trigger('change');
    position++;
  });
}

function createSortable($group) {
  var isPolymorphic = $group.is('.djn-is-polymorphic');
  return $group.find('> .djn-items, > .djn-fieldset > .djn-items, > .tabular > .module > .djn-items').nestedSortable({
    handle: ['> h3.djn-drag-handler', '> .djn-tools .drag-handler', '> .djn-td > .djn-tools .djn-drag-handler', '> .djn-tr > .is-sortable > .djn-drag-handler', '> .djn-tr > .grp-tools-container .djn-drag-handler'].join(', '),

    /**
     * items: The selector for ONLY the items underneath a given
     *        container at that level. Not to be confused with
     *        listItemSelector, which is the selector for all list
     *        items in the nestedSortable
     */
    items: '> .djn-item',
    forcePlaceholderSize: true,
    placeholder: {
      element: function element($currentItem) {
        var el = $(document.createElement($currentItem[0].nodeName)).addClass($currentItem[0].className + ' ui-sortable-placeholder').removeClass('ui-sortable-helper')[0];

        if ($currentItem.is('.djn-tbody')) {
          var $originalTr = $currentItem.children('.djn-tr').eq(0);
          var trTagName = $originalTr.prop('tagName').toLowerCase();
          var $tr = $("<" + trTagName + "></" + trTagName + ">");
          $tr.addClass($originalTr.attr('class'));
          var $originalTd = $originalTr.children('.djn-td').eq(0);
          var tdTagName = $originalTd.prop('tagName').toLowerCase();
          var numColumns = 0;
          $originalTr.children('.djn-td').each(function (i, td) {
            numColumns += parseInt($(td).attr('colspan'), 10) || 1;
          });
          $tr.append($("<" + tdTagName + " colspan=\"" + numColumns + "\" class=\"djn-td grp-td\"></" + tdTagName + ">"));
          el.appendChild($tr[0]);
        }

        return el;
      },
      update: function update(instance, $placeholder) {
        var $currItem = instance.currentItem;

        if (!$currItem) {
          return;
        }

        var opts = instance.options; // 1. If a className is set as 'placeholder option, we
        //    don't force sizes - the class is responsible for that
        // 2. The option 'forcePlaceholderSize can be enabled to
        //    force it even if a class name is specified

        if (opts.className && !opts.forcePlaceholderSize) return;

        if ($placeholder.is('.djn-tbody')) {
          // debugger;
          $placeholder = $placeholder.children('.djn-tr').eq(0).children('.djn-td').eq(0);
        } // If the element doesn't have a actual height by itself
        // (without styles coming from a stylesheet), it receives
        // the inline height from the dragged item


        if (!$placeholder.height()) {
          var innerHeight = $currItem.innerHeight(),
              paddingTop = parseInt($currItem.css('paddingTop') || 0, 10),
              paddingBottom = parseInt($currItem.css('paddingBottom') || 0, 10);
          $placeholder.height(innerHeight - paddingTop - paddingBottom);
        }

        if (!$placeholder.width()) {
          var innerWidth = $currItem.innerWidth(),
              paddingLeft = parseInt($currItem.css('paddingLeft') || 0, 10),
              paddingRight = parseInt($currItem.css('paddingRight') || 0, 10);
          $placeholder.width(innerWidth - paddingLeft - paddingRight);
        }
      }
    },
    helper: 'clone',
    opacity: 0.6,
    maxLevels: 0,
    connectWith: '.djn-items',
    tolerance: 'intersection',
    // Don't allow dragging beneath an inline that is marked for deletion
    isAllowed: function isAllowed(currentItem, parentItem) {
      if (parentItem && parentItem.hasClass('predelete')) {
        return false;
      }

      var $parentGroup = parentItem.closest('.djn-group');
      var parentModel = $parentGroup.data('inlineModel');
      var childModels = $parentGroup.djnData('childModels');
      var currentModel = currentItem.data('inlineModel');
      var isPolymorphicChild = childModels && childModels.indexOf(currentModel) !== -1;

      if (currentModel !== parentModel && !isPolymorphicChild) {
        return false;
      }

      return true;
    },
    // fixedNestingDepth: not a standard ui.sortable parameter.
    // Prevents dragging items up or down levels
    fixedNestingDepth: true,
    // The selector for ALL list containers in the nested sortable.
    containerElementSelector: '.djn-items',
    // The selector for ALL list items in the nested sortable.
    listItemSelector: '.djn-item',
    start: function start(event, ui) {
      ui.item.addClass('djn-item-dragging');
      ui.item.show();
    },
    stop: function stop(event, ui) {
      ui.item.removeClass('djn-item-dragging');
    },

    /**
     * Triggered when a sortable is dropped into a container
     */
    receive: function receive(event, ui) {
      var $inline = $(this).closest('.djn-group');
      $inline.djangoFormset().spliceInto(ui.item);
      updatePositions(ui.item.djangoFormsetPrefix());
    },
    update: function update(event, ui) {
      // Ensure that <div class='djn-item djn-no-drag'/>
      // is the first child of the djn-items. If there
      // is another <div class='djn-item'/> before the
      // .do-not-drag element then the drag-and-drop placeholder
      // margins don't work correctly.
      var $nextItem = ui.item.nextAll('.djn-item').first();

      if ($nextItem.is('.djn-no-drag,.djn-thead')) {
        var nextItem = $nextItem[0];
        var parent = nextItem.parentNode;
        parent.insertBefore(nextItem, parent.firstChild);
      }

      var groupId = $(event.target).closest('.djn-group').attr('id'),
          $form = ui.item,
          $parentGroup = $form.closest('#' + groupId);

      if ($form.data('updateOperation') == 'removed') {
        $form.removeAttr('data-update-operation');
      } else if (!$parentGroup.length) {
        $form.attr('data-update-operation', 'removed');
      }

      updatePositions($form.djangoFormsetPrefix());
      $(document).trigger('djnesting:mutate', [$('#' + $form.djangoFormsetPrefix() + '-group')]);
    }
  });
}

module.exports = {
  updatePositions: updatePositions,
  createSortable: createSortable
};

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested-admin/utils.js":
/*!********************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested-admin/utils.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* globals SelectFilter, DateTimeShortcuts */

__webpack_require__(/*! core-js/modules/es6.function.name */ "./node_modules/core-js/modules/es6.function.name.js");

__webpack_require__(/*! core-js/modules/es6.regexp.split */ "./node_modules/core-js/modules/es6.regexp.split.js");

__webpack_require__(/*! core-js/modules/es6.regexp.match */ "./node_modules/core-js/modules/es6.regexp.match.js");

__webpack_require__(/*! core-js/modules/es6.regexp.replace */ "./node_modules/core-js/modules/es6.regexp.replace.js");

__webpack_require__(/*! core-js/modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");

var $ = __webpack_require__(/*! ./jquery.shim.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.shim.js");

__webpack_require__(/*! ./jquery.djnutils.js */ "./nested_admin/static/nested_admin/src/nested-admin/jquery.djnutils.js");

var _require = __webpack_require__(/*! ./sortable */ "./nested_admin/static/nested_admin/src/nested-admin/sortable.js"),
    createSortable = _require.createSortable,
    updatePositions = _require.updatePositions;

var regexQuote = __webpack_require__(/*! ./regexquote */ "./nested_admin/static/nested_admin/src/nested-admin/regexquote.js");

var grp$ = __webpack_require__(/*! ./grp$ */ "./nested_admin/static/nested_admin/src/nested-admin/grp$.js");

var DJNesting = typeof window.DJNesting != 'undefined' ? window.DJNesting : {};
DJNesting.regexQuote = regexQuote;
DJNesting.createSortable = createSortable;
DJNesting.updatePositions = updatePositions;
/**
 * Update attributes based on a regular expression
 */

DJNesting.updateFormAttributes = function ($elem, search, replace, selector) {
  if (!selector) {
    selector = [':input', 'span', 'table', 'iframe', 'label', 'a', 'ul', 'p', 'img', '.djn-group', '.djn-inline-form', '.cropduster-form', '.dal-forward-conf'].join(',');
  }

  var addBackMethod = $.fn.addBack ? 'addBack' : 'andSelf';
  $elem.find(selector)[addBackMethod]().each(function () {
    var $node = $(this),
        attrs = ['id', 'name', 'for', 'href', 'class', 'onclick', 'data-inline-formset'];
    $.each(attrs, function (i, attrName) {
      var attrVal = $node.attr(attrName);

      if (attrVal) {
        $node.attr(attrName, attrVal.replace(search, replace));

        if (attrName === 'data-inline-formset') {
          $node.data('inlineFormset', JSON.parse($node.attr(attrName)));
        }
      }
    });
  }); // update prepopulate ids for function initPrepopulatedFields

  $elem.find('.prepopulated_field').each(function () {
    var $node = grp$(this);
    var dependencyIds = $.makeArray($node.data('dependency_ids') || []);
    $node.data('dependency_ids', $.map(dependencyIds, function (id) {
      return id.replace(search, replace);
    }));
  });
};

DJNesting.createContainerElement = function () {
  return;
}; // Slight tweaks to the grappelli functions of the same name
// (initRelatedFields and initAutocompleteFields).
//
// The most notable tweak is the call to $.fn.grp_related_generic() (a
// jQuery method provided by django-curated) and the use of
// DJNesting.LOOKUP_URLS to determine the ajax lookup urls.
//
// We abstract this out using form prefix because the way grappelli does it
// (adding javascript at the bottom of each formset) doesn't really scale
// with nested formsets.
// The second parameter (groupData) is optional, and only exists to prevent
// redundant calls to jQuery() and jQuery.fn.data() in the calling context


DJNesting.initRelatedFields = function (prefix, groupData) {
  if (typeof DJNesting.LOOKUP_URLS != 'object' || !DJNesting.LOOKUP_URLS.related) {
    return;
  }

  var lookupUrls = DJNesting.LOOKUP_URLS;
  var $inline = $('#' + prefix + '-group');

  if (!groupData) {
    groupData = $inline.djnData();
  }

  var lookupFields = groupData.lookupRelated;
  $inline.djangoFormsetForms().each(function (i, form) {
    $.each(lookupFields.fk || [], function (i, fk) {
      $(form).djangoFormField(fk).each(function () {
        grp$(this).grp_related_fk({
          lookup_url: lookupUrls.related
        });
      });
    });
    $.each(lookupFields.m2m || [], function (i, m2m) {
      $(form).djangoFormField(m2m).each(function () {
        grp$(this).grp_related_m2m({
          lookup_url: lookupUrls.m2m
        });
      });
    });
    $.each(lookupFields.generic || [], function () {
      var _this = this,
          contentType = _this[0],
          objectId = _this[1];

      $(form).djangoFormField(objectId).each(function () {
        var $this = $(this);
        var index = $this.djangoFormIndex();

        if ($this.hasClass('grp-has-related-lookup')) {
          $this.parent().find('a.related-lookup').remove();
          $this.parent().find('.grp-placeholder-related-generic').remove();
        }

        grp$($this).grp_related_generic({
          content_type: "#id_" + prefix + "-" + index + "-" + contentType,
          object_id: "#id_" + prefix + "-" + index + "-" + objectId,
          lookup_url: lookupUrls.related
        });
      });
    });
  });
};

DJNesting.initAutocompleteFields = function (prefix, groupData) {
  if (typeof DJNesting.LOOKUP_URLS != 'object' || !DJNesting.LOOKUP_URLS.related) {
    return;
  }

  var lookupUrls = DJNesting.LOOKUP_URLS;
  var $inline = $('#' + prefix + '-group');

  if (!groupData) {
    groupData = $inline.djnData();
  }

  var lookupFields = groupData.lookupAutocomplete;
  $inline.djangoFormsetForms().each(function (i, form) {
    $.each(lookupFields.fk || [], function (i, fk) {
      $(form).djangoFormField(fk).each(function () {
        var $this = $(this),
            id = $this.attr('id'); // An autocomplete widget has already been initialized, return

        if ($('#' + id + '-autocomplete').length) {
          return;
        }

        grp$($this).grp_autocomplete_fk({
          lookup_url: lookupUrls.related,
          autocomplete_lookup_url: lookupUrls.autocomplete
        });
      });
    });
    $.each(lookupFields.m2m || [], function (i, m2m) {
      $(form).djangoFormField(m2m).each(function () {
        var $this = $(this),
            id = $this.attr('id'); // An autocomplete widget has already been initialized, return

        if ($('#' + id + '-autocomplete').length) {
          return;
        }

        grp$($this).grp_autocomplete_m2m({
          lookup_url: lookupUrls.m2m,
          autocomplete_lookup_url: lookupUrls.autocomplete
        });
      });
    });
    $.each(lookupFields.generic || [], function () {
      var _this2 = this,
          contentType = _this2[0],
          objectId = _this2[1];

      $(form).djangoFormField(objectId).each(function () {
        var $this = $(this);
        var index = $this.djangoFormIndex(); // An autocomplete widget has already been initialized, return

        if ($('#' + $this.attr('id') + '-autocomplete').length) {
          return;
        }

        grp$($this).grp_autocomplete_generic({
          content_type: "#id_" + prefix + "-" + index + "-" + contentType,
          object_id: "#id_" + prefix + "-" + index + "-" + objectId,
          lookup_url: lookupUrls.related,
          autocomplete_lookup_url: lookupUrls.m2m
        });
      });
    });
  });
}; // I very much regret that these are basically copy-pasted from django's
// inlines.js, but they're hidden in closure scope so I don't have much choice.


DJNesting.DjangoInlines = {
  initPrepopulatedFields: function initPrepopulatedFields(row) {
    row.find('.prepopulated_field').each(function () {
      var field = $(this),
          input = field.is(':input') ? field : field.find(':input'),
          $input = grp$(input),
          dependencyList = $input.data('dependency_list') || [],
          formPrefix = input.djangoFormPrefix(),
          dependencies = [];

      if (!formPrefix || formPrefix.match(/__prefix__/)) {
        return;
      }

      $.each(dependencyList, function (i, fieldName) {
        dependencies.push('#id_' + formPrefix + fieldName);
      });

      if (dependencies.length) {
        $input.prepopulate(dependencies, input.attr('maxlength'));
      }
    });
  },
  reinitDateTimeShortCuts: function reinitDateTimeShortCuts() {
    // Reinitialize the calendar and clock widgets by force
    if (typeof window.DateTimeShortcuts !== 'undefined') {
      $('.datetimeshortcuts').remove();
      DateTimeShortcuts.init();
    }
  },
  updateSelectFilter: function updateSelectFilter($form) {
    // If any SelectFilter widgets are a part of the new form,
    // instantiate a new SelectFilter instance for it.
    if (typeof window.SelectFilter !== 'undefined') {
      $form.find('.selectfilter').each(function (index, value) {
        var namearr = value.name.split('-');
        SelectFilter.init(value.id, namearr[namearr.length - 1], false);
      });
      $form.find('.selectfilterstacked').each(function (index, value) {
        var namearr = value.name.split('-');
        SelectFilter.init(value.id, namearr[namearr.length - 1], true);
      });
    }
  }
};

function patchSelectFilter() {
  window.SelectFilter.init = function (oldFn) {
    return function init(field_id, field_name, is_stacked) {
      if (field_id.match(/\-empty\-/)) {
        return;
      } else {
        oldFn.apply(this, arguments);
      }
    };
  }(window.SelectFilter.init);
}

if (typeof window.SelectFilter !== 'undefined') {
  patchSelectFilter();
} else {
  setTimeout(function () {
    if (typeof window.SelectFilter !== 'undefined') {
      patchSelectFilter();
    }
  }, 12);
}

var djangoFuncs = ['prepopulate', 'djangoAdminSelect2'];
djangoFuncs.forEach(function (funcName) {
  (function patchDjangoFunction(callCount) {
    if (callCount > 2) {
      return;
    }

    if (typeof $.fn[funcName] === 'undefined') {
      return setTimeout(function () {
        return patchDjangoFunction(callCount++);
      }, 12);
    }

    $.fn[funcName] = function (oldFn) {
      return function django_fn_patch() {
        return oldFn.apply(this.filter(':not([id*="-empty-"]):not([id$="-empty"]):not([id*="__prefix__"])'), arguments);
      };
    }($.fn[funcName]);
  })(0);
});
var grpFuncs = ['grp_autocomplete_fk', 'grp_autocomplete_generic', 'grp_autocomplete_m2m', 'grp_collapsible', 'grp_collapsible_group', 'grp_inline', 'grp_related_fk', 'grp_related_generic', 'grp_related_m2m', 'grp_timepicker', 'datepicker', 'prepopulate', 'djangoAdminSelect2'];
grpFuncs.forEach(function (funcName) {
  (function patchGrpFunction(callCount) {
    if (callCount > 2) {
      return;
    }

    if (typeof window.grp === 'undefined' || typeof window.grp.jQuery.fn[funcName] === 'undefined') {
      return setTimeout(function () {
        return patchGrpFunction(callCount++);
      }, 12);
    }

    window.grp.jQuery.fn[funcName] = function (oldFn) {
      return function grp_fn_patch() {
        return oldFn.apply(this.filter(':not([id*="-empty-"]):not([id$="-empty"]):not([id*="__prefix__"])'), arguments);
      };
    }(window.grp.jQuery.fn[funcName]);
  })(0);
});
module.exports = DJNesting;

/***/ }),

/***/ "./nested_admin/static/nested_admin/src/nested_admin.scss":
/*!****************************************************************!*\
  !*** ./nested_admin/static/nested_admin/src/nested_admin.scss ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),

/***/ "./node_modules/core-js/modules/_a-function.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_a-function.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (it) {
  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_add-to-unscopables.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/_add-to-unscopables.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.31 Array.prototype[@@unscopables]
var UNSCOPABLES = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('unscopables');
var ArrayProto = Array.prototype;
if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js")(ArrayProto, UNSCOPABLES, {});
module.exports = function (key) {
  ArrayProto[UNSCOPABLES][key] = true;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_an-object.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_an-object.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
module.exports = function (it) {
  if (!isObject(it)) throw TypeError(it + ' is not an object!');
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-methods.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_array-methods.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
// 4 -> Array#every
// 5 -> Array#find
// 6 -> Array#findIndex
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/core-js/modules/_iobject.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var asc = __webpack_require__(/*! ./_array-species-create */ "./node_modules/core-js/modules/_array-species-create.js");
module.exports = function (TYPE, $create) {
  var IS_MAP = TYPE == 1;
  var IS_FILTER = TYPE == 2;
  var IS_SOME = TYPE == 3;
  var IS_EVERY = TYPE == 4;
  var IS_FIND_INDEX = TYPE == 6;
  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
  var create = $create || asc;
  return function ($this, callbackfn, that) {
    var O = toObject($this);
    var self = IObject(O);
    var f = ctx(callbackfn, that, 3);
    var length = toLength(self.length);
    var index = 0;
    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
    var val, res;
    for (;length > index; index++) if (NO_HOLES || index in self) {
      val = self[index];
      res = f(val, index, O);
      if (TYPE) {
        if (IS_MAP) result[index] = res;   // map
        else if (res) switch (TYPE) {
          case 3: return true;             // some
          case 5: return val;              // find
          case 6: return index;            // findIndex
          case 2: result.push(val);        // filter
        } else if (IS_EVERY) return false; // every
      }
    }
    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-species-constructor.js":
/*!********************************************************************!*\
  !*** ./node_modules/core-js/modules/_array-species-constructor.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/core-js/modules/_is-array.js");
var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('species');

module.exports = function (original) {
  var C;
  if (isArray(original)) {
    C = original.constructor;
    // cross-realm fallback
    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
    if (isObject(C)) {
      C = C[SPECIES];
      if (C === null) C = undefined;
    }
  } return C === undefined ? Array : C;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-species-create.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/_array-species-create.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
var speciesConstructor = __webpack_require__(/*! ./_array-species-constructor */ "./node_modules/core-js/modules/_array-species-constructor.js");

module.exports = function (original, length) {
  return new (speciesConstructor(original))(length);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_cof.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_cof.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = function (it) {
  return toString.call(it).slice(8, -1);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_core.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_core.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var core = module.exports = { version: '2.5.5' };
if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef


/***/ }),

/***/ "./node_modules/core-js/modules/_ctx.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_ctx.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
module.exports = function (fn, that, length) {
  aFunction(fn);
  if (that === undefined) return fn;
  switch (length) {
    case 1: return function (a) {
      return fn.call(that, a);
    };
    case 2: return function (a, b) {
      return fn.call(that, a, b);
    };
    case 3: return function (a, b, c) {
      return fn.call(that, a, b, c);
    };
  }
  return function (/* ...args */) {
    return fn.apply(that, arguments);
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_defined.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_defined.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 7.2.1 RequireObjectCoercible(argument)
module.exports = function (it) {
  if (it == undefined) throw TypeError("Can't call method on  " + it);
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_descriptors.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_descriptors.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
});


/***/ }),

/***/ "./node_modules/core-js/modules/_dom-create.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_dom-create.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var document = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").document;
// typeof document.createElement is 'object' in old IE
var is = isObject(document) && isObject(document.createElement);
module.exports = function (it) {
  return is ? document.createElement(it) : {};
};


/***/ }),

/***/ "./node_modules/core-js/modules/_export.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_export.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var PROTOTYPE = 'prototype';

var $export = function (type, name, source) {
  var IS_FORCED = type & $export.F;
  var IS_GLOBAL = type & $export.G;
  var IS_STATIC = type & $export.S;
  var IS_PROTO = type & $export.P;
  var IS_BIND = type & $export.B;
  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
  var key, own, out, exp;
  if (IS_GLOBAL) source = name;
  for (key in source) {
    // contains in native
    own = !IS_FORCED && target && target[key] !== undefined;
    // export native or passed
    out = (own ? target : source)[key];
    // bind timers to global for call from export context
    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
    // extend global
    if (target) redefine(target, key, out, type & $export.U);
    // export
    if (exports[key] != out) hide(exports, key, exp);
    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
  }
};
global.core = core;
// type bitmap
$export.F = 1;   // forced
$export.G = 2;   // global
$export.S = 4;   // static
$export.P = 8;   // proto
$export.B = 16;  // bind
$export.W = 32;  // wrap
$export.U = 64;  // safe
$export.R = 128; // real proto method for `library`
module.exports = $export;


/***/ }),

/***/ "./node_modules/core-js/modules/_fails.js":
/*!************************************************!*\
  !*** ./node_modules/core-js/modules/_fails.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (exec) {
  try {
    return !!exec();
  } catch (e) {
    return true;
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_fix-re-wks.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_fix-re-wks.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
var wks = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js");

module.exports = function (KEY, length, exec) {
  var SYMBOL = wks(KEY);
  var fns = exec(defined, SYMBOL, ''[KEY]);
  var strfn = fns[0];
  var rxfn = fns[1];
  if (fails(function () {
    var O = {};
    O[SYMBOL] = function () { return 7; };
    return ''[KEY](O) != 7;
  })) {
    redefine(String.prototype, KEY, strfn);
    hide(RegExp.prototype, SYMBOL, length == 2
      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
      // 21.2.5.11 RegExp.prototype[@@split](string, limit)
      ? function (string, arg) { return rxfn.call(string, this, arg); }
      // 21.2.5.6 RegExp.prototype[@@match](string)
      // 21.2.5.9 RegExp.prototype[@@search](string)
      : function (string) { return rxfn.call(string, this); }
    );
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_global.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_global.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
  ? window : typeof self != 'undefined' && self.Math == Math ? self
  // eslint-disable-next-line no-new-func
  : Function('return this')();
if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef


/***/ }),

/***/ "./node_modules/core-js/modules/_has.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_has.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;
module.exports = function (it, key) {
  return hasOwnProperty.call(it, key);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_hide.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_hide.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
module.exports = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? function (object, key, value) {
  return dP.f(object, key, createDesc(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_ie8-dom-define.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/_ie8-dom-define.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = !__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return Object.defineProperty(__webpack_require__(/*! ./_dom-create */ "./node_modules/core-js/modules/_dom-create.js")('div'), 'a', { get: function () { return 7; } }).a != 7;
});


/***/ }),

/***/ "./node_modules/core-js/modules/_iobject.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_iobject.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
// eslint-disable-next-line no-prototype-builtins
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
  return cof(it) == 'String' ? it.split('') : Object(it);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-array.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_is-array.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.2 IsArray(argument)
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
module.exports = Array.isArray || function isArray(arg) {
  return cof(arg) == 'Array';
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-object.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_is-object.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (it) {
  return typeof it === 'object' ? it !== null : typeof it === 'function';
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-regexp.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_is-regexp.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.8 IsRegExp(argument)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
var MATCH = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('match');
module.exports = function (it) {
  var isRegExp;
  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-dp.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_object-dp.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var IE8_DOM_DEFINE = __webpack_require__(/*! ./_ie8-dom-define */ "./node_modules/core-js/modules/_ie8-dom-define.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var dP = Object.defineProperty;

exports.f = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? Object.defineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPrimitive(P, true);
  anObject(Attributes);
  if (IE8_DOM_DEFINE) try {
    return dP(O, P, Attributes);
  } catch (e) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_property-desc.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_property-desc.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_redefine.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_redefine.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var SRC = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js")('src');
var TO_STRING = 'toString';
var $toString = Function[TO_STRING];
var TPL = ('' + $toString).split(TO_STRING);

__webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js").inspectSource = function (it) {
  return $toString.call(it);
};

(module.exports = function (O, key, val, safe) {
  var isFunction = typeof val == 'function';
  if (isFunction) has(val, 'name') || hide(val, 'name', key);
  if (O[key] === val) return;
  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
  if (O === global) {
    O[key] = val;
  } else if (!safe) {
    delete O[key];
    hide(O, key, val);
  } else if (O[key]) {
    O[key] = val;
  } else {
    hide(O, key, val);
  }
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, TO_STRING, function toString() {
  return typeof this == 'function' && this[SRC] || $toString.call(this);
});


/***/ }),

/***/ "./node_modules/core-js/modules/_shared.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_shared.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var SHARED = '__core-js_shared__';
var store = global[SHARED] || (global[SHARED] = {});
module.exports = function (key) {
  return store[key] || (store[key] = {});
};


/***/ }),

/***/ "./node_modules/core-js/modules/_strict-method.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_strict-method.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");

module.exports = function (method, arg) {
  return !!method && fails(function () {
    // eslint-disable-next-line no-useless-call
    arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);
  });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-integer.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-integer.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 7.1.4 ToInteger
var ceil = Math.ceil;
var floor = Math.floor;
module.exports = function (it) {
  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-length.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-length.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.15 ToLength
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var min = Math.min;
module.exports = function (it) {
  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-object.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-object.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
module.exports = function (it) {
  return Object(defined(it));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-primitive.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/_to-primitive.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function (it, S) {
  if (!isObject(it)) return it;
  var fn, val;
  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
  throw TypeError("Can't convert object to primitive value");
};


/***/ }),

/***/ "./node_modules/core-js/modules/_uid.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_uid.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var id = 0;
var px = Math.random();
module.exports = function (key) {
  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_wks.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_wks.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var store = __webpack_require__(/*! ./_shared */ "./node_modules/core-js/modules/_shared.js")('wks');
var uid = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js");
var Symbol = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").Symbol;
var USE_SYMBOL = typeof Symbol == 'function';

var $exports = module.exports = function (name) {
  return store[name] || (store[name] =
    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
};

$exports.store = store;


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.find.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.find.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $find = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(5);
var KEY = 'find';
var forced = true;
// Shouldn't skip holes
if (KEY in []) Array(1)[KEY](function () { forced = false; });
$export($export.P + $export.F * forced, 'Array', {
  find: function find(callbackfn /* , that = undefined */) {
    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
  }
});
__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")(KEY);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.sort.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.sort.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var $sort = [].sort;
var test = [1, 2, 3];

$export($export.P + $export.F * (fails(function () {
  // IE8-
  test.sort(undefined);
}) || !fails(function () {
  // V8 bug
  test.sort(null);
  // Old WebKit
}) || !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")($sort)), 'Array', {
  // 22.1.3.25 Array.prototype.sort(comparefn)
  sort: function sort(comparefn) {
    return comparefn === undefined
      ? $sort.call(toObject(this))
      : $sort.call(toObject(this), aFunction(comparefn));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.function.name.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.function.name.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var FProto = Function.prototype;
var nameRE = /^\s*function ([^ (]*)/;
var NAME = 'name';

// 19.2.4.2 name
NAME in FProto || __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && dP(FProto, NAME, {
  configurable: true,
  get: function () {
    try {
      return ('' + this).match(nameRE)[1];
    } catch (e) {
      return '';
    }
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.match.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.match.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// @@match logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('match', 1, function (defined, MATCH, $match) {
  // 21.1.3.11 String.prototype.match(regexp)
  return [function match(regexp) {
    'use strict';
    var O = defined(this);
    var fn = regexp == undefined ? undefined : regexp[MATCH];
    return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
  }, $match];
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.replace.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.replace.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// @@replace logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('replace', 2, function (defined, REPLACE, $replace) {
  // 21.1.3.14 String.prototype.replace(searchValue, replaceValue)
  return [function replace(searchValue, replaceValue) {
    'use strict';
    var O = defined(this);
    var fn = searchValue == undefined ? undefined : searchValue[REPLACE];
    return fn !== undefined
      ? fn.call(searchValue, O, replaceValue)
      : $replace.call(String(O), searchValue, replaceValue);
  }, $replace];
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.split.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.split.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// @@split logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('split', 2, function (defined, SPLIT, $split) {
  'use strict';
  var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/core-js/modules/_is-regexp.js");
  var _split = $split;
  var $push = [].push;
  var $SPLIT = 'split';
  var LENGTH = 'length';
  var LAST_INDEX = 'lastIndex';
  if (
    'abbc'[$SPLIT](/(b)*/)[1] == 'c' ||
    'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 ||
    'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 ||
    '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 ||
    '.'[$SPLIT](/()()/)[LENGTH] > 1 ||
    ''[$SPLIT](/.?/)[LENGTH]
  ) {
    var NPCG = /()??/.exec('')[1] === undefined; // nonparticipating capturing group
    // based on es5-shim implementation, need to rework it
    $split = function (separator, limit) {
      var string = String(this);
      if (separator === undefined && limit === 0) return [];
      // If `separator` is not a regex, use native split
      if (!isRegExp(separator)) return _split.call(string, separator, limit);
      var output = [];
      var flags = (separator.ignoreCase ? 'i' : '') +
                  (separator.multiline ? 'm' : '') +
                  (separator.unicode ? 'u' : '') +
                  (separator.sticky ? 'y' : '');
      var lastLastIndex = 0;
      var splitLimit = limit === undefined ? 4294967295 : limit >>> 0;
      // Make `global` and avoid `lastIndex` issues by working with a copy
      var separatorCopy = new RegExp(separator.source, flags + 'g');
      var separator2, match, lastIndex, lastLength, i;
      // Doesn't need flags gy, but they don't hurt
      if (!NPCG) separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\s)', flags);
      while (match = separatorCopy.exec(string)) {
        // `separatorCopy.lastIndex` is not reliable cross-browser
        lastIndex = match.index + match[0][LENGTH];
        if (lastIndex > lastLastIndex) {
          output.push(string.slice(lastLastIndex, match.index));
          // Fix browsers whose `exec` methods don't consistently return `undefined` for NPCG
          // eslint-disable-next-line no-loop-func
          if (!NPCG && match[LENGTH] > 1) match[0].replace(separator2, function () {
            for (i = 1; i < arguments[LENGTH] - 2; i++) if (arguments[i] === undefined) match[i] = undefined;
          });
          if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1));
          lastLength = match[0][LENGTH];
          lastLastIndex = lastIndex;
          if (output[LENGTH] >= splitLimit) break;
        }
        if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++; // Avoid an infinite loop
      }
      if (lastLastIndex === string[LENGTH]) {
        if (lastLength || !separatorCopy.test('')) output.push('');
      } else output.push(string.slice(lastLastIndex));
      return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;
    };
  // Chakra, V8
  } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) {
    $split = function (separator, limit) {
      return separator === undefined && limit === 0 ? [] : _split.call(this, separator, limit);
    };
  }
  // 21.1.3.17 String.prototype.split(separator, limit)
  return [function split(separator, limit) {
    var O = defined(this);
    var fn = separator == undefined ? undefined : separator[SPLIT];
    return fn !== undefined ? fn.call(separator, O, limit) : $split.call(String(O), separator, limit);
  }, $split];
});


/***/ }),

/***/ 0:
/*!*******************************************************************************************************************************!*\
  !*** multi nested_admin/static/nested_admin/src/nested_admin.scss nested_admin/static/nested_admin/src/nested-admin/index.js ***!
  \*******************************************************************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! nested_admin/static/nested_admin/src/nested_admin.scss */"./nested_admin/static/nested_admin/src/nested_admin.scss");
module.exports = __webpack_require__(/*! nested_admin/static/nested_admin/src/nested-admin/index.js */"./nested_admin/static/nested_admin/src/nested-admin/index.js");


/***/ }),

/***/ "grappelli":
/*!****************************!*\
  !*** external "grappelli" ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports) {

(function() { module.exports = window["grappelli"]; }());

/***/ }),

/***/ "grp":
/*!**********************!*\
  !*** external "grp" ***!
  \**********************/
/*! no static exports found */
/***/ (function(module, exports) {

(function() { module.exports = window["grp"]; }());

/***/ })

/******/ });
//# sourceMappingURL=nested_admin.js.map