@pie-element/placement-ordering 10.8.1-next.9 → 11.0.3-esm.0

package/esm/configure.js

@@ -0,0 +1,4378 @@
+import { InsertImageEvent, DeleteImageEvent, ModelUpdatedEvent, InsertSoundEvent, DeleteSoundEvent } from '@pie-framework/pie-configure-events';
+import { AlertDialog, layout, InputContainer as InputContainer$1, FormSection, FeedbackConfig, settings } from '@pie-lib/config-ui';
+import EditableHtml, { DEFAULT_PLUGINS } from '@pie-lib/editable-html';
+import { withStyles } from '@material-ui/core/styles';
+import { withDragContext } from '@pie-lib/drag';
+import React, { createContext, isValidElement, cloneElement, createRef, Component } from 'react';
+import require$$3 from '@material-ui/core/SvgIcon';
+import Tooltip from '@material-ui/core/Tooltip';
+import debug from 'debug';
+import cloneDeep from 'lodash/cloneDeep';
+import PropTypes from 'prop-types';
+import CardActions from '@material-ui/core/CardActions';
+import classNames from 'classnames';
+import IconButton from '@material-ui/core/IconButton';
+import { color, InputContainer } from '@pie-lib/render-ui';
+import { jsx } from 'react/jsx-runtime';
+import isEmpty from 'lodash/isEmpty';
+import uniqueId from 'lodash/uniqueId';
+import shuffle from 'lodash/shuffle';
+import isEqual from 'lodash/isEqual';
+import Button from '@material-ui/core/Button';
+import ReactDOM from 'react-dom';
+import defaults from 'lodash/defaults';
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function commonjsRequire (path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var Info = {};
+
+var interopRequireDefault = {exports: {}};
+
+(function (module) {
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}
+
+module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(interopRequireDefault));
+
+var createSvgIcon$1 = {};
+
+var pure$1 = {};
+
+var shouldUpdate$1 = {};
+
+var inheritsLoose = {exports: {}};
+
+var setPrototypeOf = {exports: {}};
+
+(function (module) {
+function _setPrototypeOf(o, p) {
+  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  return _setPrototypeOf(o, p);
+}
+
+module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(setPrototypeOf));
+
+(function (module) {
+var setPrototypeOf$1 = setPrototypeOf.exports;
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  setPrototypeOf$1(subClass, superClass);
+}
+
+module.exports = _inheritsLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(inheritsLoose));
+
+var setDisplayName$1 = {};
+
+var setStatic$1 = {};
+
+setStatic$1.__esModule = true;
+setStatic$1.default = void 0;
+
+var setStatic = function setStatic(key, value) {
+  return function (BaseComponent) {
+    /* eslint-disable no-param-reassign */
+    BaseComponent[key] = value;
+    /* eslint-enable no-param-reassign */
+
+    return BaseComponent;
+  };
+};
+
+var _default$a = setStatic;
+setStatic$1.default = _default$a;
+
+var _interopRequireDefault$8 = interopRequireDefault.exports;
+
+setDisplayName$1.__esModule = true;
+setDisplayName$1.default = void 0;
+
+var _setStatic = _interopRequireDefault$8(setStatic$1);
+
+var setDisplayName = function setDisplayName(displayName) {
+  return (0, _setStatic.default)('displayName', displayName);
+};
+
+var _default$9 = setDisplayName;
+setDisplayName$1.default = _default$9;
+
+var wrapDisplayName$1 = {};
+
+var getDisplayName$1 = {};
+
+getDisplayName$1.__esModule = true;
+getDisplayName$1.default = void 0;
+
+var getDisplayName = function getDisplayName(Component) {
+  if (typeof Component === 'string') {
+    return Component;
+  }
+
+  if (!Component) {
+    return undefined;
+  }
+
+  return Component.displayName || Component.name || 'Component';
+};
+
+var _default$8 = getDisplayName;
+getDisplayName$1.default = _default$8;
+
+var _interopRequireDefault$7 = interopRequireDefault.exports;
+
+wrapDisplayName$1.__esModule = true;
+wrapDisplayName$1.default = void 0;
+
+var _getDisplayName = _interopRequireDefault$7(getDisplayName$1);
+
+var wrapDisplayName = function wrapDisplayName(BaseComponent, hocName) {
+  return hocName + "(" + (0, _getDisplayName.default)(BaseComponent) + ")";
+};
+
+var _default$7 = wrapDisplayName;
+wrapDisplayName$1.default = _default$7;
+
+var _interopRequireDefault$6 = interopRequireDefault.exports;
+
+shouldUpdate$1.__esModule = true;
+shouldUpdate$1.default = void 0;
+
+var _inheritsLoose2 = _interopRequireDefault$6(inheritsLoose.exports);
+
+var _react$4 = React;
+
+var _setDisplayName$1 = _interopRequireDefault$6(setDisplayName$1);
+
+var _wrapDisplayName$1 = _interopRequireDefault$6(wrapDisplayName$1);
+
+var shouldUpdate = function shouldUpdate(test) {
+  return function (BaseComponent) {
+    var factory = (0, _react$4.createFactory)(BaseComponent);
+
+    var ShouldUpdate =
+    /*#__PURE__*/
+    function (_Component) {
+      (0, _inheritsLoose2.default)(ShouldUpdate, _Component);
+
+      function ShouldUpdate() {
+        return _Component.apply(this, arguments) || this;
+      }
+
+      var _proto = ShouldUpdate.prototype;
+
+      _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
+        return test(this.props, nextProps);
+      };
+
+      _proto.render = function render() {
+        return factory(this.props);
+      };
+
+      return ShouldUpdate;
+    }(_react$4.Component);
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName$1.default)((0, _wrapDisplayName$1.default)(BaseComponent, 'shouldUpdate'))(ShouldUpdate);
+    }
+
+    return ShouldUpdate;
+  };
+};
+
+var _default$6 = shouldUpdate;
+shouldUpdate$1.default = _default$6;
+
+var shallowEqual$2 = {};
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @typechecks
+ * 
+ */
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  // SameValue algorithm
+  if (x === y) {
+    // Steps 1-5, 7-10
+    // Steps 6.b-6.e: +0 != -0
+    // Added the nonzero y check to make Flow happy, but it is redundant
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  } else {
+    // Step 6.a: NaN == NaN
+    return x !== x && y !== y;
+  }
+}
+
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
+function shallowEqual$1(objA, objB) {
+  if (is(objA, objB)) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  // Test for A's keys different from B.
+  for (var i = 0; i < keysA.length; i++) {
+    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+var shallowEqual_1 = shallowEqual$1;
+
+var _interopRequireDefault$5 = interopRequireDefault.exports;
+
+shallowEqual$2.__esModule = true;
+shallowEqual$2.default = void 0;
+
+var _shallowEqual$1 = _interopRequireDefault$5(shallowEqual_1);
+
+var _default$5 = _shallowEqual$1.default;
+shallowEqual$2.default = _default$5;
+
+var _interopRequireDefault$4 = interopRequireDefault.exports;
+
+pure$1.__esModule = true;
+pure$1.default = void 0;
+
+var _shouldUpdate = _interopRequireDefault$4(shouldUpdate$1);
+
+var _shallowEqual = _interopRequireDefault$4(shallowEqual$2);
+
+var _setDisplayName = _interopRequireDefault$4(setDisplayName$1);
+
+var _wrapDisplayName = _interopRequireDefault$4(wrapDisplayName$1);
+
+var pure = function pure(BaseComponent) {
+  var hoc = (0, _shouldUpdate.default)(function (props, nextProps) {
+    return !(0, _shallowEqual.default)(props, nextProps);
+  });
+
+  if (process.env.NODE_ENV !== 'production') {
+    return (0, _setDisplayName.default)((0, _wrapDisplayName.default)(BaseComponent, 'pure'))(hoc(BaseComponent));
+  }
+
+  return hoc(BaseComponent);
+};
+
+var _default$4 = pure;
+pure$1.default = _default$4;
+
+var _interopRequireDefault$3 = interopRequireDefault.exports;
+
+Object.defineProperty(createSvgIcon$1, "__esModule", {
+  value: true
+});
+createSvgIcon$1.default = void 0;
+
+var _react$3 = _interopRequireDefault$3(React);
+
+var _pure = _interopRequireDefault$3(pure$1);
+
+var _SvgIcon = _interopRequireDefault$3(require$$3);
+
+function createSvgIcon(path, displayName) {
+  var Icon = function Icon(props) {
+    return _react$3.default.createElement(_SvgIcon.default, props, path);
+  };
+
+  Icon.displayName = "".concat(displayName, "Icon");
+  Icon = (0, _pure.default)(Icon);
+  Icon.muiName = 'SvgIcon';
+  return Icon;
+}
+var _default$3 = createSvgIcon;
+createSvgIcon$1.default = _default$3;
+
+var _interopRequireDefault$2 = interopRequireDefault.exports;
+
+Object.defineProperty(Info, "__esModule", {
+  value: true
+});
+var default_1$2 = Info.default = void 0;
+
+var _react$2 = _interopRequireDefault$2(React);
+
+var _createSvgIcon$2 = _interopRequireDefault$2(createSvgIcon$1);
+
+var _default$2 = (0, _createSvgIcon$2.default)(_react$2.default.createElement(_react$2.default.Fragment, null, _react$2.default.createElement("path", {
+  fill: "none",
+  d: "M0 0h24v24H0z"
+}), _react$2.default.createElement("path", {
+  d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"
+})), 'Info');
+
+default_1$2 = Info.default = _default$2;
+
+/**
+* @license nested-property https://github.com/cosmosio/nested-property
+*
+* The MIT License (MIT)
+*
+* Copyright (c) 2014-2015 Olivier Scherrer <pode.fr@gmail.com>
+*/
+
+var nestedProperty = {
+  set: setNestedProperty,
+  get: getNestedProperty,
+  has: hasNestedProperty,
+  hasOwn: function (object, property, options) {
+      return this.has(object, property, options || {own: true});
+  },
+  isIn: isInNestedProperty
+};
+
+/**
+ * Get the property of an object nested in one or more objects
+ * given an object such as a.b.c.d = 5, getNestedProperty(a, "b.c.d") will return 5.
+ * @param {Object} object the object to get the property from
+ * @param {String} property the path to the property as a string
+ * @returns the object or the the property value if found
+ */
+function getNestedProperty(object, property) {
+    if (object && typeof object == "object") {
+        if (typeof property == "string" && property !== "") {
+            var split = property.split(".");
+            return split.reduce(function (obj, prop) {
+                return obj && obj[prop];
+            }, object);
+        } else if (typeof property == "number") {
+            return object[property];
+        } else {
+            return object;
+        }
+    } else {
+        return object;
+    }
+}
+
+/**
+ * Tell if a nested object has a given property (or array a given index)
+ * given an object such as a.b.c.d = 5, hasNestedProperty(a, "b.c.d") will return true.
+ * It also returns true if the property is in the prototype chain.
+ * @param {Object} object the object to get the property from
+ * @param {String} property the path to the property as a string
+ * @param {Object} options:
+ *  - own: set to reject properties from the prototype
+ * @returns true if has (property in object), false otherwise
+ */
+function hasNestedProperty(object, property, options) {
+    options = options || {};
+
+    if (object && typeof object == "object") {
+        if (typeof property == "string" && property !== "") {
+            var split = property.split(".");
+            return split.reduce(function (obj, prop, idx, array) {
+                if (idx == array.length - 1) {
+                    if (options.own) {
+                        return !!(obj && obj.hasOwnProperty(prop));
+                    } else {
+                        return !!(obj !== null && typeof obj == "object" && prop in obj);
+                    }
+                }
+                return obj && obj[prop];
+            }, object);
+        } else if (typeof property == "number") {
+            return property in object;
+        } else {
+            return false;
+        }
+    } else {
+        return false;
+    }
+}
+
+/**
+ * Set the property of an object nested in one or more objects
+ * If the property doesn't exist, it gets created.
+ * @param {Object} object
+ * @param {String} property
+ * @param value the value to set
+ * @returns object if no assignment was made or the value if the assignment was made
+ */
+function setNestedProperty(object, property, value) {
+    if (object && typeof object == "object") {
+        if (typeof property == "string" && property !== "") {
+            var split = property.split(".");
+            return split.reduce(function (obj, prop, idx) {
+                obj[prop] = obj[prop] || {};
+                if (split.length == (idx + 1)) {
+                    obj[prop] = value;
+                }
+                return obj[prop];
+            }, object);
+        } else if (typeof property == "number") {
+            object[property] = value;
+            return object[property];
+        } else {
+            return object;
+        }
+    } else {
+        return object;
+    }
+}
+
+/**
+ * Tell if an object is on the path to a nested property
+ * If the object is on the path, and the path exists, it returns true, and false otherwise.
+ * @param {Object} object to get the nested property from
+ * @param {String} property name of the nested property
+ * @param {Object} objectInPath the object to check
+ * @param {Object} options:
+ *  - validPath: return false if the path is invalid, even if the object is in the path
+ * @returns {boolean} true if the object is on the path
+ */
+function isInNestedProperty(object, property, objectInPath, options) {
+    options = options || {};
+
+    if (object && typeof object == "object") {
+        if (typeof property == "string" && property !== "") {
+            var split = property.split("."),
+                isIn = false,
+                pathExists;
+
+            pathExists = !!split.reduce(function (obj, prop) {
+                isIn = isIn || obj === objectInPath || (!!obj && obj[prop] === objectInPath);
+                return obj && obj[prop];
+            }, object);
+
+            if (options.validPath) {
+                return isIn && pathExists;
+            } else {
+                return isIn;
+            }
+        } else {
+            return false;
+        }
+    } else {
+        return false;
+    }
+}
+
+var pluralize$1 = {exports: {}};
+
+/* global define */
+
+(function (module, exports) {
+(function (root, pluralize) {
+  /* istanbul ignore else */
+  if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') {
+    // Node.
+    module.exports = pluralize();
+  } else {
+    // Browser global.
+    root.pluralize = pluralize();
+  }
+})(commonjsGlobal, function () {
+  // Rule storage - pluralize and singularize need to be run sequentially,
+  // while other rules can be optimized using an object for instant lookups.
+  var pluralRules = [];
+  var singularRules = [];
+  var uncountables = {};
+  var irregularPlurals = {};
+  var irregularSingles = {};
+
+  /**
+   * Sanitize a pluralization rule to a usable regular expression.
+   *
+   * @param  {(RegExp|string)} rule
+   * @return {RegExp}
+   */
+  function sanitizeRule (rule) {
+    if (typeof rule === 'string') {
+      return new RegExp('^' + rule + '$', 'i');
+    }
+
+    return rule;
+  }
+
+  /**
+   * Pass in a word token to produce a function that can replicate the case on
+   * another word.
+   *
+   * @param  {string}   word
+   * @param  {string}   token
+   * @return {Function}
+   */
+  function restoreCase (word, token) {
+    // Tokens are an exact match.
+    if (word === token) return token;
+
+    // Lower cased words. E.g. "hello".
+    if (word === word.toLowerCase()) return token.toLowerCase();
+
+    // Upper cased words. E.g. "WHISKY".
+    if (word === word.toUpperCase()) return token.toUpperCase();
+
+    // Title cased words. E.g. "Title".
+    if (word[0] === word[0].toUpperCase()) {
+      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+    }
+
+    // Lower cased words. E.g. "test".
+    return token.toLowerCase();
+  }
+
+  /**
+   * Interpolate a regexp string.
+   *
+   * @param  {string} str
+   * @param  {Array}  args
+   * @return {string}
+   */
+  function interpolate (str, args) {
+    return str.replace(/\$(\d{1,2})/g, function (match, index) {
+      return args[index] || '';
+    });
+  }
+
+  /**
+   * Replace a word using a rule.
+   *
+   * @param  {string} word
+   * @param  {Array}  rule
+   * @return {string}
+   */
+  function replace (word, rule) {
+    return word.replace(rule[0], function (match, index) {
+      var result = interpolate(rule[1], arguments);
+
+      if (match === '') {
+        return restoreCase(word[index - 1], result);
+      }
+
+      return restoreCase(match, result);
+    });
+  }
+
+  /**
+   * Sanitize a word by passing in the word and sanitization rules.
+   *
+   * @param  {string}   token
+   * @param  {string}   word
+   * @param  {Array}    rules
+   * @return {string}
+   */
+  function sanitizeWord (token, word, rules) {
+    // Empty string or doesn't need fixing.
+    if (!token.length || uncountables.hasOwnProperty(token)) {
+      return word;
+    }
+
+    var len = rules.length;
+
+    // Iterate over the sanitization rules and use the first one to match.
+    while (len--) {
+      var rule = rules[len];
+
+      if (rule[0].test(word)) return replace(word, rule);
+    }
+
+    return word;
+  }
+
+  /**
+   * Replace a word with the updated word.
+   *
+   * @param  {Object}   replaceMap
+   * @param  {Object}   keepMap
+   * @param  {Array}    rules
+   * @return {Function}
+   */
+  function replaceWord (replaceMap, keepMap, rules) {
+    return function (word) {
+      // Get the correct token and case restoration functions.
+      var token = word.toLowerCase();
+
+      // Check against the keep object map.
+      if (keepMap.hasOwnProperty(token)) {
+        return restoreCase(word, token);
+      }
+
+      // Check against the replacement map for a direct word replacement.
+      if (replaceMap.hasOwnProperty(token)) {
+        return restoreCase(word, replaceMap[token]);
+      }
+
+      // Run all the rules against the word.
+      return sanitizeWord(token, word, rules);
+    };
+  }
+
+  /**
+   * Check if a word is part of the map.
+   */
+  function checkWord (replaceMap, keepMap, rules, bool) {
+    return function (word) {
+      var token = word.toLowerCase();
+
+      if (keepMap.hasOwnProperty(token)) return true;
+      if (replaceMap.hasOwnProperty(token)) return false;
+
+      return sanitizeWord(token, token, rules) === token;
+    };
+  }
+
+  /**
+   * Pluralize or singularize a word based on the passed in count.
+   *
+   * @param  {string}  word      The word to pluralize
+   * @param  {number}  count     How many of the word exist
+   * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+   * @return {string}
+   */
+  function pluralize (word, count, inclusive) {
+    var pluralized = count === 1
+      ? pluralize.singular(word) : pluralize.plural(word);
+
+    return (inclusive ? count + ' ' : '') + pluralized;
+  }
+
+  /**
+   * Pluralize a word.
+   *
+   * @type {Function}
+   */
+  pluralize.plural = replaceWord(
+    irregularSingles, irregularPlurals, pluralRules
+  );
+
+  /**
+   * Check if a word is plural.
+   *
+   * @type {Function}
+   */
+  pluralize.isPlural = checkWord(
+    irregularSingles, irregularPlurals, pluralRules
+  );
+
+  /**
+   * Singularize a word.
+   *
+   * @type {Function}
+   */
+  pluralize.singular = replaceWord(
+    irregularPlurals, irregularSingles, singularRules
+  );
+
+  /**
+   * Check if a word is singular.
+   *
+   * @type {Function}
+   */
+  pluralize.isSingular = checkWord(
+    irregularPlurals, irregularSingles, singularRules
+  );
+
+  /**
+   * Add a pluralization rule to the collection.
+   *
+   * @param {(string|RegExp)} rule
+   * @param {string}          replacement
+   */
+  pluralize.addPluralRule = function (rule, replacement) {
+    pluralRules.push([sanitizeRule(rule), replacement]);
+  };
+
+  /**
+   * Add a singularization rule to the collection.
+   *
+   * @param {(string|RegExp)} rule
+   * @param {string}          replacement
+   */
+  pluralize.addSingularRule = function (rule, replacement) {
+    singularRules.push([sanitizeRule(rule), replacement]);
+  };
+
+  /**
+   * Add an uncountable word rule.
+   *
+   * @param {(string|RegExp)} word
+   */
+  pluralize.addUncountableRule = function (word) {
+    if (typeof word === 'string') {
+      uncountables[word.toLowerCase()] = true;
+      return;
+    }
+
+    // Set singular and plural references for the word.
+    pluralize.addPluralRule(word, '$0');
+    pluralize.addSingularRule(word, '$0');
+  };
+
+  /**
+   * Add an irregular word definition.
+   *
+   * @param {string} single
+   * @param {string} plural
+   */
+  pluralize.addIrregularRule = function (single, plural) {
+    plural = plural.toLowerCase();
+    single = single.toLowerCase();
+
+    irregularSingles[single] = plural;
+    irregularPlurals[plural] = single;
+  };
+
+  /**
+   * Irregular rules.
+   */
+  [
+    // Pronouns.
+    ['I', 'we'],
+    ['me', 'us'],
+    ['he', 'they'],
+    ['she', 'they'],
+    ['them', 'them'],
+    ['myself', 'ourselves'],
+    ['yourself', 'yourselves'],
+    ['itself', 'themselves'],
+    ['herself', 'themselves'],
+    ['himself', 'themselves'],
+    ['themself', 'themselves'],
+    ['is', 'are'],
+    ['was', 'were'],
+    ['has', 'have'],
+    ['this', 'these'],
+    ['that', 'those'],
+    // Words ending in with a consonant and `o`.
+    ['echo', 'echoes'],
+    ['dingo', 'dingoes'],
+    ['volcano', 'volcanoes'],
+    ['tornado', 'tornadoes'],
+    ['torpedo', 'torpedoes'],
+    // Ends with `us`.
+    ['genus', 'genera'],
+    ['viscus', 'viscera'],
+    // Ends with `ma`.
+    ['stigma', 'stigmata'],
+    ['stoma', 'stomata'],
+    ['dogma', 'dogmata'],
+    ['lemma', 'lemmata'],
+    ['schema', 'schemata'],
+    ['anathema', 'anathemata'],
+    // Other irregular rules.
+    ['ox', 'oxen'],
+    ['axe', 'axes'],
+    ['die', 'dice'],
+    ['yes', 'yeses'],
+    ['foot', 'feet'],
+    ['eave', 'eaves'],
+    ['goose', 'geese'],
+    ['tooth', 'teeth'],
+    ['quiz', 'quizzes'],
+    ['human', 'humans'],
+    ['proof', 'proofs'],
+    ['carve', 'carves'],
+    ['valve', 'valves'],
+    ['looey', 'looies'],
+    ['thief', 'thieves'],
+    ['groove', 'grooves'],
+    ['pickaxe', 'pickaxes'],
+    ['passerby', 'passersby']
+  ].forEach(function (rule) {
+    return pluralize.addIrregularRule(rule[0], rule[1]);
+  });
+
+  /**
+   * Pluralization rules.
+   */
+  [
+    [/s?$/i, 's'],
+    [/[^\u0000-\u007F]$/i, '$0'],
+    [/([^aeiou]ese)$/i, '$1'],
+    [/(ax|test)is$/i, '$1es'],
+    [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],
+    [/(e[mn]u)s?$/i, '$1s'],
+    [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],
+    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],
+    [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'],
+    [/(seraph|cherub)(?:im)?$/i, '$1im'],
+    [/(her|at|gr)o$/i, '$1oes'],
+    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],
+    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],
+    [/sis$/i, 'ses'],
+    [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],
+    [/([^aeiouy]|qu)y$/i, '$1ies'],
+    [/([^ch][ieo][ln])ey$/i, '$1ies'],
+    [/(x|ch|ss|sh|zz)$/i, '$1es'],
+    [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],
+    [/\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'],
+    [/(pe)(?:rson|ople)$/i, '$1ople'],
+    [/(child)(?:ren)?$/i, '$1ren'],
+    [/eaux$/i, '$0'],
+    [/m[ae]n$/i, 'men'],
+    ['thou', 'you']
+  ].forEach(function (rule) {
+    return pluralize.addPluralRule(rule[0], rule[1]);
+  });
+
+  /**
+   * Singularization rules.
+   */
+  [
+    [/s$/i, ''],
+    [/(ss)$/i, '$1'],
+    [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, '$1fe'],
+    [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'],
+    [/ies$/i, 'y'],
+    [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],
+    [/\b(mon|smil)ies$/i, '$1ey'],
+    [/\b((?:tit)?m|l)ice$/i, '$1ouse'],
+    [/(seraph|cherub)im$/i, '$1'],
+    [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],
+    [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],
+    [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'],
+    [/(test)(?:is|es)$/i, '$1is'],
+    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],
+    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],
+    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],
+    [/(alumn|alg|vertebr)ae$/i, '$1a'],
+    [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],
+    [/(matr|append)ices$/i, '$1ix'],
+    [/(pe)(rson|ople)$/i, '$1rson'],
+    [/(child)ren$/i, '$1'],
+    [/(eau)x?$/i, '$1'],
+    [/men$/i, 'man']
+  ].forEach(function (rule) {
+    return pluralize.addSingularRule(rule[0], rule[1]);
+  });
+
+  /**
+   * Uncountable rules.
+   */
+  [
+    // Singular words with no plurals.
+    'adulthood',
+    'advice',
+    'agenda',
+    'aid',
+    'aircraft',
+    'alcohol',
+    'ammo',
+    'analytics',
+    'anime',
+    'athletics',
+    'audio',
+    'bison',
+    'blood',
+    'bream',
+    'buffalo',
+    'butter',
+    'carp',
+    'cash',
+    'chassis',
+    'chess',
+    'clothing',
+    'cod',
+    'commerce',
+    'cooperation',
+    'corps',
+    'debris',
+    'diabetes',
+    'digestion',
+    'elk',
+    'energy',
+    'equipment',
+    'excretion',
+    'expertise',
+    'firmware',
+    'flounder',
+    'fun',
+    'gallows',
+    'garbage',
+    'graffiti',
+    'hardware',
+    'headquarters',
+    'health',
+    'herpes',
+    'highjinks',
+    'homework',
+    'housework',
+    'information',
+    'jeans',
+    'justice',
+    'kudos',
+    'labour',
+    'literature',
+    'machinery',
+    'mackerel',
+    'mail',
+    'media',
+    'mews',
+    'moose',
+    'music',
+    'mud',
+    'manga',
+    'news',
+    'only',
+    'personnel',
+    'pike',
+    'plankton',
+    'pliers',
+    'police',
+    'pollution',
+    'premises',
+    'rain',
+    'research',
+    'rice',
+    'salmon',
+    'scissors',
+    'series',
+    'sewage',
+    'shambles',
+    'shrimp',
+    'software',
+    'species',
+    'staff',
+    'swine',
+    'tennis',
+    'traffic',
+    'transportation',
+    'trout',
+    'tuna',
+    'wealth',
+    'welfare',
+    'whiting',
+    'wildebeest',
+    'wildlife',
+    'you',
+    /pok[eé]mon$/i,
+    // Regexes.
+    /[^aeiou]ese$/i, // "chinese", "japanese"
+    /deer$/i, // "deer", "reindeer"
+    /fish$/i, // "fish", "blowfish", "angelfish"
+    /measles$/i,
+    /o[iu]s$/i, // "carnivorous"
+    /pox$/i, // "chickpox", "smallpox"
+    /sheep$/i
+  ].forEach(pluralize.addUncountableRule);
+
+  return pluralize;
+});
+}(pluralize$1));
+
+var pluralize = pluralize$1.exports;
+
+var DragHandle = {};
+
+var _interopRequireDefault$1 = interopRequireDefault.exports;
+
+Object.defineProperty(DragHandle, "__esModule", {
+  value: true
+});
+var default_1$1 = DragHandle.default = void 0;
+
+var _react$1 = _interopRequireDefault$1(React);
+
+var _createSvgIcon$1 = _interopRequireDefault$1(createSvgIcon$1);
+
+var _default$1 = (0, _createSvgIcon$1.default)(_react$1.default.createElement(_react$1.default.Fragment, null, _react$1.default.createElement("defs", null, _react$1.default.createElement("path", {
+  id: "a",
+  d: "M0 0h24v24H0V0z"
+})), _react$1.default.createElement("path", {
+  d: "M20 9H4v2h16V9zM4 15h16v-2H4v2z"
+})), 'DragHandle');
+
+default_1$1 = DragHandle.default = _default$1;
+
+/**
+ * Create the React Context
+ */
+
+var DndContext = createContext({
+  dragDropManager: undefined
+});
+
+/**
+ * Use invariant() to assert state which your program assumes to be true.
+ *
+ * Provide sprintf-style format (only %s is supported) and arguments
+ * to provide information about what broke and what you were
+ * expecting.
+ *
+ * The invariant message will be stripped in production, but the invariant
+ * will remain to ensure logic does not differ in production.
+ */
+function invariant(condition, format) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (format === undefined) {
+      throw new Error('invariant requires an error message argument');
+    }
+  }
+
+  if (!condition) {
+    var error;
+
+    if (format === undefined) {
+      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+    } else {
+      var argIndex = 0;
+      error = new Error(format.replace(/%s/g, function () {
+        return args[argIndex++];
+      }));
+      error.name = 'Invariant Violation';
+    }
+
+    error.framesToPop = 1; // we don't care about invariant's own frame
+
+    throw error;
+  }
+}
+
+function _classCallCheck$7(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$7(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$7(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$7(Constructor.prototype, protoProps); if (staticProps) _defineProperties$7(Constructor, staticProps); return Constructor; }
+
+function _defineProperty$7(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var isCallingCanDrag = false;
+var isCallingIsDragging = false;
+var DragSourceMonitorImpl = /*#__PURE__*/function () {
+  function DragSourceMonitorImpl(manager) {
+    _classCallCheck$7(this, DragSourceMonitorImpl);
+
+    _defineProperty$7(this, "internalMonitor", void 0);
+
+    _defineProperty$7(this, "sourceId", null);
+
+    this.internalMonitor = manager.getMonitor();
+  }
+
+  _createClass$7(DragSourceMonitorImpl, [{
+    key: "receiveHandlerId",
+    value: function receiveHandlerId(sourceId) {
+      this.sourceId = sourceId;
+    }
+  }, {
+    key: "getHandlerId",
+    value: function getHandlerId() {
+      return this.sourceId;
+    }
+  }, {
+    key: "canDrag",
+    value: function canDrag() {
+      invariant(!isCallingCanDrag, 'You may not call monitor.canDrag() inside your canDrag() implementation. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source-monitor');
+
+      try {
+        isCallingCanDrag = true;
+        return this.internalMonitor.canDragSource(this.sourceId);
+      } finally {
+        isCallingCanDrag = false;
+      }
+    }
+  }, {
+    key: "isDragging",
+    value: function isDragging() {
+      if (!this.sourceId) {
+        return false;
+      }
+
+      invariant(!isCallingIsDragging, 'You may not call monitor.isDragging() inside your isDragging() implementation. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source-monitor');
+
+      try {
+        isCallingIsDragging = true;
+        return this.internalMonitor.isDraggingSource(this.sourceId);
+      } finally {
+        isCallingIsDragging = false;
+      }
+    }
+  }, {
+    key: "subscribeToStateChange",
+    value: function subscribeToStateChange(listener, options) {
+      return this.internalMonitor.subscribeToStateChange(listener, options);
+    }
+  }, {
+    key: "isDraggingSource",
+    value: function isDraggingSource(sourceId) {
+      return this.internalMonitor.isDraggingSource(sourceId);
+    }
+  }, {
+    key: "isOverTarget",
+    value: function isOverTarget(targetId, options) {
+      return this.internalMonitor.isOverTarget(targetId, options);
+    }
+  }, {
+    key: "getTargetIds",
+    value: function getTargetIds() {
+      return this.internalMonitor.getTargetIds();
+    }
+  }, {
+    key: "isSourcePublic",
+    value: function isSourcePublic() {
+      return this.internalMonitor.isSourcePublic();
+    }
+  }, {
+    key: "getSourceId",
+    value: function getSourceId() {
+      return this.internalMonitor.getSourceId();
+    }
+  }, {
+    key: "subscribeToOffsetChange",
+    value: function subscribeToOffsetChange(listener) {
+      return this.internalMonitor.subscribeToOffsetChange(listener);
+    }
+  }, {
+    key: "canDragSource",
+    value: function canDragSource(sourceId) {
+      return this.internalMonitor.canDragSource(sourceId);
+    }
+  }, {
+    key: "canDropOnTarget",
+    value: function canDropOnTarget(targetId) {
+      return this.internalMonitor.canDropOnTarget(targetId);
+    }
+  }, {
+    key: "getItemType",
+    value: function getItemType() {
+      return this.internalMonitor.getItemType();
+    }
+  }, {
+    key: "getItem",
+    value: function getItem() {
+      return this.internalMonitor.getItem();
+    }
+  }, {
+    key: "getDropResult",
+    value: function getDropResult() {
+      return this.internalMonitor.getDropResult();
+    }
+  }, {
+    key: "didDrop",
+    value: function didDrop() {
+      return this.internalMonitor.didDrop();
+    }
+  }, {
+    key: "getInitialClientOffset",
+    value: function getInitialClientOffset() {
+      return this.internalMonitor.getInitialClientOffset();
+    }
+  }, {
+    key: "getInitialSourceClientOffset",
+    value: function getInitialSourceClientOffset() {
+      return this.internalMonitor.getInitialSourceClientOffset();
+    }
+  }, {
+    key: "getSourceClientOffset",
+    value: function getSourceClientOffset() {
+      return this.internalMonitor.getSourceClientOffset();
+    }
+  }, {
+    key: "getClientOffset",
+    value: function getClientOffset() {
+      return this.internalMonitor.getClientOffset();
+    }
+  }, {
+    key: "getDifferenceFromInitialOffset",
+    value: function getDifferenceFromInitialOffset() {
+      return this.internalMonitor.getDifferenceFromInitialOffset();
+    }
+  }]);
+
+  return DragSourceMonitorImpl;
+}();
+
+function _classCallCheck$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$6(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$6(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$6(Constructor.prototype, protoProps); if (staticProps) _defineProperties$6(Constructor, staticProps); return Constructor; }
+
+function _defineProperty$6(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var isCallingCanDrop = false;
+var DropTargetMonitorImpl = /*#__PURE__*/function () {
+  function DropTargetMonitorImpl(manager) {
+    _classCallCheck$6(this, DropTargetMonitorImpl);
+
+    _defineProperty$6(this, "internalMonitor", void 0);
+
+    _defineProperty$6(this, "targetId", null);
+
+    this.internalMonitor = manager.getMonitor();
+  }
+
+  _createClass$6(DropTargetMonitorImpl, [{
+    key: "receiveHandlerId",
+    value: function receiveHandlerId(targetId) {
+      this.targetId = targetId;
+    }
+  }, {
+    key: "getHandlerId",
+    value: function getHandlerId() {
+      return this.targetId;
+    }
+  }, {
+    key: "subscribeToStateChange",
+    value: function subscribeToStateChange(listener, options) {
+      return this.internalMonitor.subscribeToStateChange(listener, options);
+    }
+  }, {
+    key: "canDrop",
+    value: function canDrop() {
+      // Cut out early if the target id has not been set. This should prevent errors
+      // where the user has an older version of dnd-core like in
+      // https://github.com/react-dnd/react-dnd/issues/1310
+      if (!this.targetId) {
+        return false;
+      }
+
+      invariant(!isCallingCanDrop, 'You may not call monitor.canDrop() inside your canDrop() implementation. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target-monitor');
+
+      try {
+        isCallingCanDrop = true;
+        return this.internalMonitor.canDropOnTarget(this.targetId);
+      } finally {
+        isCallingCanDrop = false;
+      }
+    }
+  }, {
+    key: "isOver",
+    value: function isOver(options) {
+      if (!this.targetId) {
+        return false;
+      }
+
+      return this.internalMonitor.isOverTarget(this.targetId, options);
+    }
+  }, {
+    key: "getItemType",
+    value: function getItemType() {
+      return this.internalMonitor.getItemType();
+    }
+  }, {
+    key: "getItem",
+    value: function getItem() {
+      return this.internalMonitor.getItem();
+    }
+  }, {
+    key: "getDropResult",
+    value: function getDropResult() {
+      return this.internalMonitor.getDropResult();
+    }
+  }, {
+    key: "didDrop",
+    value: function didDrop() {
+      return this.internalMonitor.didDrop();
+    }
+  }, {
+    key: "getInitialClientOffset",
+    value: function getInitialClientOffset() {
+      return this.internalMonitor.getInitialClientOffset();
+    }
+  }, {
+    key: "getInitialSourceClientOffset",
+    value: function getInitialSourceClientOffset() {
+      return this.internalMonitor.getInitialSourceClientOffset();
+    }
+  }, {
+    key: "getSourceClientOffset",
+    value: function getSourceClientOffset() {
+      return this.internalMonitor.getSourceClientOffset();
+    }
+  }, {
+    key: "getClientOffset",
+    value: function getClientOffset() {
+      return this.internalMonitor.getClientOffset();
+    }
+  }, {
+    key: "getDifferenceFromInitialOffset",
+    value: function getDifferenceFromInitialOffset() {
+      return this.internalMonitor.getDifferenceFromInitialOffset();
+    }
+  }]);
+
+  return DropTargetMonitorImpl;
+}();
+
+function throwIfCompositeComponentElement(element) {
+  // Custom components can no longer be wrapped directly in React DnD 2.0
+  // so that we don't need to depend on findDOMNode() from react-dom.
+  if (typeof element.type === 'string') {
+    return;
+  }
+
+  var displayName = element.type.displayName || element.type.name || 'the component';
+  throw new Error('Only native element nodes can now be passed to React DnD connectors.' + "You can either wrap ".concat(displayName, " into a <div>, or turn it into a ") + 'drag source or a drop target itself.');
+}
+
+function wrapHookToRecognizeElement(hook) {
+  return function () {
+    var elementOrNode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+    // When passed a node, call the hook straight away.
+    if (!isValidElement(elementOrNode)) {
+      var node = elementOrNode;
+      hook(node, options); // return the node so it can be chained (e.g. when within callback refs
+      // <div ref={node => connectDragSource(connectDropTarget(node))}/>
+
+      return node;
+    } // If passed a ReactElement, clone it and attach this function as a ref.
+    // This helps us achieve a neat API where user doesn't even know that refs
+    // are being used under the hood.
+
+
+    var element = elementOrNode;
+    throwIfCompositeComponentElement(element); // When no options are passed, use the hook directly
+
+    var ref = options ? function (node) {
+      return hook(node, options);
+    } : hook;
+    return cloneWithRef(element, ref);
+  };
+}
+
+function wrapConnectorHooks(hooks) {
+  var wrappedHooks = {};
+  Object.keys(hooks).forEach(function (key) {
+    var hook = hooks[key]; // ref objects should be passed straight through without wrapping
+
+    if (key.endsWith('Ref')) {
+      wrappedHooks[key] = hooks[key];
+    } else {
+      var wrappedHook = wrapHookToRecognizeElement(hook);
+
+      wrappedHooks[key] = function () {
+        return wrappedHook;
+      };
+    }
+  });
+  return wrappedHooks;
+}
+
+function setRef(ref, node) {
+  if (typeof ref === 'function') {
+    ref(node);
+  } else {
+    ref.current = node;
+  }
+}
+
+function cloneWithRef(element, newRef) {
+  var previousRef = element.ref;
+  invariant(typeof previousRef !== 'string', 'Cannot connect React DnD to an element with an existing string ref. ' + 'Please convert it to use a callback ref instead, or wrap it into a <span> or <div>. ' + 'Read more: https://reactjs.org/docs/refs-and-the-dom.html#callback-refs');
+
+  if (!previousRef) {
+    // When there is no ref on the element, use the new ref directly
+    return cloneElement(element, {
+      ref: newRef
+    });
+  } else {
+    return cloneElement(element, {
+      ref: function ref(node) {
+        setRef(previousRef, node);
+        setRef(newRef, node);
+      }
+    });
+  }
+}
+
+function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
+
+function isRef(obj) {
+  return (// eslint-disable-next-line no-prototype-builtins
+    obj !== null && _typeof$2(obj) === 'object' && Object.prototype.hasOwnProperty.call(obj, 'current')
+  );
+}
+
+function shallowEqual(objA, objB, compare, compareContext) {
+  var compareResult = compare ? compare.call(compareContext, objA, objB) : void 0;
+
+  if (compareResult !== void 0) {
+    return !!compareResult;
+  }
+
+  if (objA === objB) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || !objA || typeof objB !== 'object' || !objB) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB); // Test for A's keys different from B.
+
+  for (var idx = 0; idx < keysA.length; idx++) {
+    var key = keysA[idx];
+
+    if (!bHasOwnProperty(key)) {
+      return false;
+    }
+
+    var valueA = objA[key];
+    var valueB = objB[key];
+    compareResult = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
+
+    if (compareResult === false || compareResult === void 0 && valueA !== valueB) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$5(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$5(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$5(Constructor.prototype, protoProps); if (staticProps) _defineProperties$5(Constructor, staticProps); return Constructor; }
+
+function _defineProperty$5(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var SourceConnector = /*#__PURE__*/function () {
+  // The drop target may either be attached via ref or connect function
+  // The drag preview may either be attached via ref or connect function
+  function SourceConnector(backend) {
+    var _this = this;
+
+    _classCallCheck$5(this, SourceConnector);
+
+    _defineProperty$5(this, "hooks", wrapConnectorHooks({
+      dragSource: function dragSource(node, options) {
+        _this.clearDragSource();
+
+        _this.dragSourceOptions = options || null;
+
+        if (isRef(node)) {
+          _this.dragSourceRef = node;
+        } else {
+          _this.dragSourceNode = node;
+        }
+
+        _this.reconnectDragSource();
+      },
+      dragPreview: function dragPreview(node, options) {
+        _this.clearDragPreview();
+
+        _this.dragPreviewOptions = options || null;
+
+        if (isRef(node)) {
+          _this.dragPreviewRef = node;
+        } else {
+          _this.dragPreviewNode = node;
+        }
+
+        _this.reconnectDragPreview();
+      }
+    }));
+
+    _defineProperty$5(this, "handlerId", null);
+
+    _defineProperty$5(this, "dragSourceRef", null);
+
+    _defineProperty$5(this, "dragSourceNode", void 0);
+
+    _defineProperty$5(this, "dragSourceOptionsInternal", null);
+
+    _defineProperty$5(this, "dragSourceUnsubscribe", void 0);
+
+    _defineProperty$5(this, "dragPreviewRef", null);
+
+    _defineProperty$5(this, "dragPreviewNode", void 0);
+
+    _defineProperty$5(this, "dragPreviewOptionsInternal", null);
+
+    _defineProperty$5(this, "dragPreviewUnsubscribe", void 0);
+
+    _defineProperty$5(this, "lastConnectedHandlerId", null);
+
+    _defineProperty$5(this, "lastConnectedDragSource", null);
+
+    _defineProperty$5(this, "lastConnectedDragSourceOptions", null);
+
+    _defineProperty$5(this, "lastConnectedDragPreview", null);
+
+    _defineProperty$5(this, "lastConnectedDragPreviewOptions", null);
+
+    _defineProperty$5(this, "backend", void 0);
+
+    this.backend = backend;
+  }
+
+  _createClass$5(SourceConnector, [{
+    key: "receiveHandlerId",
+    value: function receiveHandlerId(newHandlerId) {
+      if (this.handlerId === newHandlerId) {
+        return;
+      }
+
+      this.handlerId = newHandlerId;
+      this.reconnect();
+    }
+  }, {
+    key: "connectTarget",
+    get: function get() {
+      return this.dragSource;
+    }
+  }, {
+    key: "dragSourceOptions",
+    get: function get() {
+      return this.dragSourceOptionsInternal;
+    },
+    set: function set(options) {
+      this.dragSourceOptionsInternal = options;
+    }
+  }, {
+    key: "dragPreviewOptions",
+    get: function get() {
+      return this.dragPreviewOptionsInternal;
+    },
+    set: function set(options) {
+      this.dragPreviewOptionsInternal = options;
+    }
+  }, {
+    key: "reconnect",
+    value: function reconnect() {
+      this.reconnectDragSource();
+      this.reconnectDragPreview();
+    }
+  }, {
+    key: "reconnectDragSource",
+    value: function reconnectDragSource() {
+      var dragSource = this.dragSource; // if nothing has changed then don't resubscribe
+
+      var didChange = this.didHandlerIdChange() || this.didConnectedDragSourceChange() || this.didDragSourceOptionsChange();
+
+      if (didChange) {
+        this.disconnectDragSource();
+      }
+
+      if (!this.handlerId) {
+        return;
+      }
+
+      if (!dragSource) {
+        this.lastConnectedDragSource = dragSource;
+        return;
+      }
+
+      if (didChange) {
+        this.lastConnectedHandlerId = this.handlerId;
+        this.lastConnectedDragSource = dragSource;
+        this.lastConnectedDragSourceOptions = this.dragSourceOptions;
+        this.dragSourceUnsubscribe = this.backend.connectDragSource(this.handlerId, dragSource, this.dragSourceOptions);
+      }
+    }
+  }, {
+    key: "reconnectDragPreview",
+    value: function reconnectDragPreview() {
+      var dragPreview = this.dragPreview; // if nothing has changed then don't resubscribe
+
+      var didChange = this.didHandlerIdChange() || this.didConnectedDragPreviewChange() || this.didDragPreviewOptionsChange();
+
+      if (didChange) {
+        this.disconnectDragPreview();
+      }
+
+      if (!this.handlerId) {
+        return;
+      }
+
+      if (!dragPreview) {
+        this.lastConnectedDragPreview = dragPreview;
+        return;
+      }
+
+      if (didChange) {
+        this.lastConnectedHandlerId = this.handlerId;
+        this.lastConnectedDragPreview = dragPreview;
+        this.lastConnectedDragPreviewOptions = this.dragPreviewOptions;
+        this.dragPreviewUnsubscribe = this.backend.connectDragPreview(this.handlerId, dragPreview, this.dragPreviewOptions);
+      }
+    }
+  }, {
+    key: "didHandlerIdChange",
+    value: function didHandlerIdChange() {
+      return this.lastConnectedHandlerId !== this.handlerId;
+    }
+  }, {
+    key: "didConnectedDragSourceChange",
+    value: function didConnectedDragSourceChange() {
+      return this.lastConnectedDragSource !== this.dragSource;
+    }
+  }, {
+    key: "didConnectedDragPreviewChange",
+    value: function didConnectedDragPreviewChange() {
+      return this.lastConnectedDragPreview !== this.dragPreview;
+    }
+  }, {
+    key: "didDragSourceOptionsChange",
+    value: function didDragSourceOptionsChange() {
+      return !shallowEqual(this.lastConnectedDragSourceOptions, this.dragSourceOptions);
+    }
+  }, {
+    key: "didDragPreviewOptionsChange",
+    value: function didDragPreviewOptionsChange() {
+      return !shallowEqual(this.lastConnectedDragPreviewOptions, this.dragPreviewOptions);
+    }
+  }, {
+    key: "disconnectDragSource",
+    value: function disconnectDragSource() {
+      if (this.dragSourceUnsubscribe) {
+        this.dragSourceUnsubscribe();
+        this.dragSourceUnsubscribe = undefined;
+      }
+    }
+  }, {
+    key: "disconnectDragPreview",
+    value: function disconnectDragPreview() {
+      if (this.dragPreviewUnsubscribe) {
+        this.dragPreviewUnsubscribe();
+        this.dragPreviewUnsubscribe = undefined;
+        this.dragPreviewNode = null;
+        this.dragPreviewRef = null;
+      }
+    }
+  }, {
+    key: "dragSource",
+    get: function get() {
+      return this.dragSourceNode || this.dragSourceRef && this.dragSourceRef.current;
+    }
+  }, {
+    key: "dragPreview",
+    get: function get() {
+      return this.dragPreviewNode || this.dragPreviewRef && this.dragPreviewRef.current;
+    }
+  }, {
+    key: "clearDragSource",
+    value: function clearDragSource() {
+      this.dragSourceNode = null;
+      this.dragSourceRef = null;
+    }
+  }, {
+    key: "clearDragPreview",
+    value: function clearDragPreview() {
+      this.dragPreviewNode = null;
+      this.dragPreviewRef = null;
+    }
+  }]);
+
+  return SourceConnector;
+}();
+
+function _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$4(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; }
+
+function _defineProperty$4(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var TargetConnector = /*#__PURE__*/function () {
+  // The drop target may either be attached via ref or connect function
+  function TargetConnector(backend) {
+    var _this = this;
+
+    _classCallCheck$4(this, TargetConnector);
+
+    _defineProperty$4(this, "hooks", wrapConnectorHooks({
+      dropTarget: function dropTarget(node, options) {
+        _this.clearDropTarget();
+
+        _this.dropTargetOptions = options;
+
+        if (isRef(node)) {
+          _this.dropTargetRef = node;
+        } else {
+          _this.dropTargetNode = node;
+        }
+
+        _this.reconnect();
+      }
+    }));
+
+    _defineProperty$4(this, "handlerId", null);
+
+    _defineProperty$4(this, "dropTargetRef", null);
+
+    _defineProperty$4(this, "dropTargetNode", void 0);
+
+    _defineProperty$4(this, "dropTargetOptionsInternal", null);
+
+    _defineProperty$4(this, "unsubscribeDropTarget", void 0);
+
+    _defineProperty$4(this, "lastConnectedHandlerId", null);
+
+    _defineProperty$4(this, "lastConnectedDropTarget", null);
+
+    _defineProperty$4(this, "lastConnectedDropTargetOptions", null);
+
+    _defineProperty$4(this, "backend", void 0);
+
+    this.backend = backend;
+  }
+
+  _createClass$4(TargetConnector, [{
+    key: "connectTarget",
+    get: function get() {
+      return this.dropTarget;
+    }
+  }, {
+    key: "reconnect",
+    value: function reconnect() {
+      // if nothing has changed then don't resubscribe
+      var didChange = this.didHandlerIdChange() || this.didDropTargetChange() || this.didOptionsChange();
+
+      if (didChange) {
+        this.disconnectDropTarget();
+      }
+
+      var dropTarget = this.dropTarget;
+
+      if (!this.handlerId) {
+        return;
+      }
+
+      if (!dropTarget) {
+        this.lastConnectedDropTarget = dropTarget;
+        return;
+      }
+
+      if (didChange) {
+        this.lastConnectedHandlerId = this.handlerId;
+        this.lastConnectedDropTarget = dropTarget;
+        this.lastConnectedDropTargetOptions = this.dropTargetOptions;
+        this.unsubscribeDropTarget = this.backend.connectDropTarget(this.handlerId, dropTarget, this.dropTargetOptions);
+      }
+    }
+  }, {
+    key: "receiveHandlerId",
+    value: function receiveHandlerId(newHandlerId) {
+      if (newHandlerId === this.handlerId) {
+        return;
+      }
+
+      this.handlerId = newHandlerId;
+      this.reconnect();
+    }
+  }, {
+    key: "dropTargetOptions",
+    get: function get() {
+      return this.dropTargetOptionsInternal;
+    },
+    set: function set(options) {
+      this.dropTargetOptionsInternal = options;
+    }
+  }, {
+    key: "didHandlerIdChange",
+    value: function didHandlerIdChange() {
+      return this.lastConnectedHandlerId !== this.handlerId;
+    }
+  }, {
+    key: "didDropTargetChange",
+    value: function didDropTargetChange() {
+      return this.lastConnectedDropTarget !== this.dropTarget;
+    }
+  }, {
+    key: "didOptionsChange",
+    value: function didOptionsChange() {
+      return !shallowEqual(this.lastConnectedDropTargetOptions, this.dropTargetOptions);
+    }
+  }, {
+    key: "disconnectDropTarget",
+    value: function disconnectDropTarget() {
+      if (this.unsubscribeDropTarget) {
+        this.unsubscribeDropTarget();
+        this.unsubscribeDropTarget = undefined;
+      }
+    }
+  }, {
+    key: "dropTarget",
+    get: function get() {
+      return this.dropTargetNode || this.dropTargetRef && this.dropTargetRef.current;
+    }
+  }, {
+    key: "clearDropTarget",
+    value: function clearDropTarget() {
+      this.dropTargetRef = null;
+      this.dropTargetNode = null;
+    }
+  }]);
+
+  return TargetConnector;
+}();
+
+function registerTarget(type, target, manager) {
+  var registry = manager.getRegistry();
+  var targetId = registry.addTarget(type, target);
+  return [targetId, function () {
+    return registry.removeTarget(targetId);
+  }];
+}
+function registerSource(type, source, manager) {
+  var registry = manager.getRegistry();
+  var sourceId = registry.addSource(type, source);
+  return [sourceId, function () {
+    return registry.removeSource(sourceId);
+  }];
+}
+
+function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+
+function getDecoratedComponent(instanceRef) {
+  var currentRef = instanceRef.current;
+
+  if (currentRef == null) {
+    return null;
+  } else if (currentRef.decoratedRef) {
+    // go through the private field in decorateHandler to avoid the invariant hit
+    return currentRef.decoratedRef.current;
+  } else {
+    return currentRef;
+  }
+}
+function isClassComponent(Component) {
+  return Component && Component.prototype && typeof Component.prototype.render === 'function';
+}
+function isRefForwardingComponent(C) {
+  var _item$$$typeof;
+
+  var item = C;
+  return (item === null || item === void 0 ? void 0 : (_item$$$typeof = item.$$typeof) === null || _item$$$typeof === void 0 ? void 0 : _item$$$typeof.toString()) === 'Symbol(react.forward_ref)';
+}
+function isRefable(C) {
+  return isClassComponent(C) || isRefForwardingComponent(C);
+}
+function checkDecoratorArguments(functionName, signature) {
+  if (process.env.NODE_ENV !== 'production') {
+    for (var i = 0; i < (arguments.length <= 2 ? 0 : arguments.length - 2); i++) {
+      var arg = i + 2 < 2 || arguments.length <= i + 2 ? undefined : arguments[i + 2];
+
+      if (arg && arg.prototype && arg.prototype.render) {
+        // eslint-disable-next-line no-console
+        console.error('You seem to be applying the arguments in the wrong order. ' + "It should be ".concat(functionName, "(").concat(signature, ")(Component), not the other way around. ") + 'Read more: http://react-dnd.github.io/react-dnd/docs/troubleshooting#you-seem-to-be-applying-the-arguments-in-the-wrong-order');
+        return;
+      }
+    }
+  }
+}
+function isFunction(input) {
+  return typeof input === 'function';
+}
+function noop() {// noop
+}
+
+function isObjectLike(input) {
+  return _typeof$1(input) === 'object' && input !== null;
+}
+
+function isPlainObject(input) {
+  if (!isObjectLike(input)) {
+    return false;
+  }
+
+  if (Object.getPrototypeOf(input) === null) {
+    return true;
+  }
+
+  var proto = input;
+
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return Object.getPrototypeOf(input) === proto;
+}
+function isValidType(type, allowArray) {
+  return typeof type === 'string' || _typeof$1(type) === 'symbol' || !!allowArray && Array.isArray(type) && type.every(function (t) {
+    return isValidType(t, false);
+  });
+}
+
+function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$3(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); if (staticProps) _defineProperties$3(Constructor, staticProps); return Constructor; }
+
+function _defineProperty$3(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+/**
+ * Provides a set of static methods for creating Disposables.
+ * @param {Function} action Action to run during the first call to dispose.
+ * The action is guaranteed to be run at most once.
+ */
+
+var Disposable = /*#__PURE__*/function () {
+  function Disposable(action) {
+    _classCallCheck$3(this, Disposable);
+
+    _defineProperty$3(this, "isDisposed", false);
+
+    _defineProperty$3(this, "action", void 0);
+
+    this.action = isFunction(action) ? action : noop;
+  }
+  /** Performs the task of cleaning up resources. */
+
+
+  _createClass$3(Disposable, [{
+    key: "dispose",
+    value: function dispose() {
+      if (!this.isDisposed) {
+        this.action();
+        this.isDisposed = true;
+      }
+    }
+  }], [{
+    key: "isDisposable",
+    value:
+    /**
+     * Gets the disposable that does nothing when disposed.
+     */
+
+    /**
+     * Validates whether the given object is a disposable
+     * @param {Object} Object to test whether it has a dispose method
+     * @returns {Boolean} true if a disposable object, else false.
+     */
+    function isDisposable(d) {
+      return Boolean(d && isFunction(d.dispose));
+    }
+  }, {
+    key: "_fixup",
+    value: function _fixup(result) {
+      return Disposable.isDisposable(result) ? result : Disposable.empty;
+    }
+    /**
+     * Creates a disposable object that invokes the specified action when disposed.
+     * @param {Function} dispose Action to run during the first call to dispose.
+     * The action is guaranteed to be run at most once.
+     * @return {Disposable} The disposable object that runs the given action upon disposal.
+     */
+
+  }, {
+    key: "create",
+    value: function create(action) {
+      return new Disposable(action);
+    }
+  }]);
+
+  return Disposable;
+}();
+/**
+ * Represents a group of disposable resources that are disposed together.
+ * @constructor
+ */
+
+_defineProperty$3(Disposable, "empty", {
+  dispose: noop
+});
+
+var CompositeDisposable = /*#__PURE__*/function () {
+  function CompositeDisposable() {
+    _classCallCheck$3(this, CompositeDisposable);
+
+    _defineProperty$3(this, "isDisposed", false);
+
+    _defineProperty$3(this, "disposables", void 0);
+
+    for (var _len = arguments.length, disposables = new Array(_len), _key = 0; _key < _len; _key++) {
+      disposables[_key] = arguments[_key];
+    }
+
+    this.disposables = disposables;
+  }
+  /**
+   * Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.
+   * @param {Any} item Disposable to add.
+   */
+
+
+  _createClass$3(CompositeDisposable, [{
+    key: "add",
+    value: function add(item) {
+      if (this.isDisposed) {
+        item.dispose();
+      } else {
+        this.disposables.push(item);
+      }
+    }
+    /**
+     * Removes and disposes the first occurrence of a disposable from the CompositeDisposable.
+     * @param {Any} item Disposable to remove.
+     * @returns {Boolean} true if found; false otherwise.
+     */
+
+  }, {
+    key: "remove",
+    value: function remove(item) {
+      var shouldDispose = false;
+
+      if (!this.isDisposed) {
+        var idx = this.disposables.indexOf(item);
+
+        if (idx !== -1) {
+          shouldDispose = true;
+          this.disposables.splice(idx, 1);
+          item.dispose();
+        }
+      }
+
+      return shouldDispose;
+    }
+    /**
+     *  Disposes all disposables in the group and removes them from the group but
+     *  does not dispose the CompositeDisposable.
+     */
+
+  }, {
+    key: "clear",
+    value: function clear() {
+      if (!this.isDisposed) {
+        var len = this.disposables.length;
+        var currentDisposables = new Array(len);
+
+        for (var i = 0; i < len; i++) {
+          currentDisposables[i] = this.disposables[i];
+        }
+
+        this.disposables = [];
+
+        for (var _i = 0; _i < len; _i++) {
+          currentDisposables[_i].dispose();
+        }
+      }
+    }
+    /**
+     *  Disposes all disposables in the group and removes them from the group.
+     */
+
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (!this.isDisposed) {
+        this.isDisposed = true;
+        var len = this.disposables.length;
+        var currentDisposables = new Array(len);
+
+        for (var i = 0; i < len; i++) {
+          currentDisposables[i] = this.disposables[i];
+        }
+
+        this.disposables = [];
+
+        for (var _i2 = 0; _i2 < len; _i2++) {
+          currentDisposables[_i2].dispose();
+        }
+      }
+    }
+  }]);
+
+  return CompositeDisposable;
+}();
+/**
+ * Represents a disposable resource whose underlying disposable resource can
+ * be replaced by another disposable resource, causing automatic disposal of
+ * the previous underlying disposable resource.
+ */
+
+var SerialDisposable = /*#__PURE__*/function () {
+  function SerialDisposable() {
+    _classCallCheck$3(this, SerialDisposable);
+
+    _defineProperty$3(this, "isDisposed", false);
+
+    _defineProperty$3(this, "current", void 0);
+  }
+
+  _createClass$3(SerialDisposable, [{
+    key: "getDisposable",
+    value:
+    /**
+     * Gets the underlying disposable.
+     * @returns {Any} the underlying disposable.
+     */
+    function getDisposable() {
+      return this.current;
+    }
+  }, {
+    key: "setDisposable",
+    value: function setDisposable(value) {
+      var shouldDispose = this.isDisposed;
+
+      if (!shouldDispose) {
+        var old = this.current;
+        this.current = value;
+
+        if (old) {
+          old.dispose();
+        }
+      }
+
+      if (shouldDispose && value) {
+        value.dispose();
+      }
+    }
+    /** Performs the task of cleaning up resources. */
+
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (!this.isDisposed) {
+        this.isDisposed = true;
+        var old = this.current;
+        this.current = undefined;
+
+        if (old) {
+          old.dispose();
+        }
+      }
+    }
+  }]);
+
+  return SerialDisposable;
+}();
+
+var reactIs$1 = {exports: {}};
+
+var reactIs_production_min = {};
+
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
+Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
+function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=t;reactIs_production_min.Memo=r;reactIs_production_min.Portal=d;
+reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min.isConcurrentMode=A;reactIs_production_min.isContextConsumer=function(a){return z(a)===k};reactIs_production_min.isContextProvider=function(a){return z(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return z(a)===n};reactIs_production_min.isFragment=function(a){return z(a)===e};reactIs_production_min.isLazy=function(a){return z(a)===t};
+reactIs_production_min.isMemo=function(a){return z(a)===r};reactIs_production_min.isPortal=function(a){return z(a)===d};reactIs_production_min.isProfiler=function(a){return z(a)===g};reactIs_production_min.isStrictMode=function(a){return z(a)===f};reactIs_production_min.isSuspense=function(a){return z(a)===p};
+reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min.typeOf=z;
+
+var reactIs_development = {};
+
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+// (unstable) APIs that have been removed. Can we remove the symbols?
+
+var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+function isValidElementType(type) {
+  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_ASYNC_MODE_TYPE:
+          case REACT_CONCURRENT_MODE_TYPE:
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+} // AsyncMode is deprecated along with isAsyncMode
+
+var AsyncMode = REACT_ASYNC_MODE_TYPE;
+var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+    }
+  }
+
+  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+}
+function isConcurrentMode(object) {
+  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+
+reactIs_development.AsyncMode = AsyncMode;
+reactIs_development.ConcurrentMode = ConcurrentMode;
+reactIs_development.ContextConsumer = ContextConsumer;
+reactIs_development.ContextProvider = ContextProvider;
+reactIs_development.Element = Element;
+reactIs_development.ForwardRef = ForwardRef;
+reactIs_development.Fragment = Fragment;
+reactIs_development.Lazy = Lazy;
+reactIs_development.Memo = Memo;
+reactIs_development.Portal = Portal;
+reactIs_development.Profiler = Profiler;
+reactIs_development.StrictMode = StrictMode;
+reactIs_development.Suspense = Suspense;
+reactIs_development.isAsyncMode = isAsyncMode;
+reactIs_development.isConcurrentMode = isConcurrentMode;
+reactIs_development.isContextConsumer = isContextConsumer;
+reactIs_development.isContextProvider = isContextProvider;
+reactIs_development.isElement = isElement;
+reactIs_development.isForwardRef = isForwardRef;
+reactIs_development.isFragment = isFragment;
+reactIs_development.isLazy = isLazy;
+reactIs_development.isMemo = isMemo;
+reactIs_development.isPortal = isPortal;
+reactIs_development.isProfiler = isProfiler;
+reactIs_development.isStrictMode = isStrictMode;
+reactIs_development.isSuspense = isSuspense;
+reactIs_development.isValidElementType = isValidElementType;
+reactIs_development.typeOf = typeOf;
+  })();
+}
+
+if (process.env.NODE_ENV === 'production') {
+  reactIs$1.exports = reactIs_production_min;
+} else {
+  reactIs$1.exports = reactIs_development;
+}
+
+var reactIs = reactIs$1.exports;
+
+/**
+ * Copyright 2015, Yahoo! Inc.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+var REACT_STATICS = {
+  childContextTypes: true,
+  contextType: true,
+  contextTypes: true,
+  defaultProps: true,
+  displayName: true,
+  getDefaultProps: true,
+  getDerivedStateFromError: true,
+  getDerivedStateFromProps: true,
+  mixins: true,
+  propTypes: true,
+  type: true
+};
+var KNOWN_STATICS = {
+  name: true,
+  length: true,
+  prototype: true,
+  caller: true,
+  callee: true,
+  arguments: true,
+  arity: true
+};
+var FORWARD_REF_STATICS = {
+  '$$typeof': true,
+  render: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true
+};
+var MEMO_STATICS = {
+  '$$typeof': true,
+  compare: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true,
+  type: true
+};
+var TYPE_STATICS = {};
+TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+
+function getStatics(component) {
+  // React v16.11 and below
+  if (reactIs.isMemo(component)) {
+    return MEMO_STATICS;
+  } // React v16.12 and above
+
+
+  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
+}
+
+var defineProperty = Object.defineProperty;
+var getOwnPropertyNames = Object.getOwnPropertyNames;
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var getPrototypeOf = Object.getPrototypeOf;
+var objectPrototype = Object.prototype;
+function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+  if (typeof sourceComponent !== 'string') {
+    // don't hoist over string (html) components
+    if (objectPrototype) {
+      var inheritedComponent = getPrototypeOf(sourceComponent);
+
+      if (inheritedComponent && inheritedComponent !== objectPrototype) {
+        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+      }
+    }
+
+    var keys = getOwnPropertyNames(sourceComponent);
+
+    if (getOwnPropertySymbols) {
+      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+    }
+
+    var targetStatics = getStatics(targetComponent);
+    var sourceStatics = getStatics(sourceComponent);
+
+    for (var i = 0; i < keys.length; ++i) {
+      var key = keys[i];
+
+      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+
+        try {
+          // Avoid failures from read-only properties
+          defineProperty(targetComponent, key, descriptor);
+        } catch (e) {}
+      }
+    }
+  }
+
+  return targetComponent;
+}
+
+var hoistNonReactStatics_cjs = hoistNonReactStatics;
+
+var hoistStatics = hoistNonReactStatics_cjs;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function decorateHandler(_ref) {
+  var DecoratedComponent = _ref.DecoratedComponent,
+      createHandler = _ref.createHandler,
+      createMonitor = _ref.createMonitor,
+      createConnector = _ref.createConnector,
+      registerHandler = _ref.registerHandler,
+      containerDisplayName = _ref.containerDisplayName,
+      getType = _ref.getType,
+      collect = _ref.collect,
+      options = _ref.options;
+  var _options$arePropsEqua = options.arePropsEqual,
+      arePropsEqual = _options$arePropsEqua === void 0 ? shallowEqual : _options$arePropsEqua;
+  var Decorated = DecoratedComponent;
+  var displayName = DecoratedComponent.displayName || DecoratedComponent.name || 'Component';
+
+  var DragDropContainer = /*#__PURE__*/function (_Component) {
+    _inherits(DragDropContainer, _Component);
+
+    var _super = _createSuper(DragDropContainer);
+
+    function DragDropContainer(props) {
+      var _this;
+
+      _classCallCheck$2(this, DragDropContainer);
+
+      _this = _super.call(this, props);
+
+      _defineProperty$2(_assertThisInitialized(_this), "decoratedRef", createRef());
+
+      _defineProperty$2(_assertThisInitialized(_this), "handlerId", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "manager", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "handlerMonitor", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "handlerConnector", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "handler", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "disposable", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "currentType", void 0);
+
+      _defineProperty$2(_assertThisInitialized(_this), "handleChange", function () {
+        var nextState = _this.getCurrentState();
+
+        if (!shallowEqual(nextState, _this.state)) {
+          _this.setState(nextState);
+        }
+      });
+
+      _this.disposable = new SerialDisposable();
+
+      _this.receiveProps(props);
+
+      _this.dispose();
+
+      return _this;
+    }
+
+    _createClass$2(DragDropContainer, [{
+      key: "getHandlerId",
+      value: function getHandlerId() {
+        return this.handlerId;
+      }
+    }, {
+      key: "getDecoratedComponentInstance",
+      value: function getDecoratedComponentInstance() {
+        invariant(this.decoratedRef.current, 'In order to access an instance of the decorated component, it must either be a class component or use React.forwardRef()');
+        return this.decoratedRef.current;
+      }
+    }, {
+      key: "shouldComponentUpdate",
+      value: function shouldComponentUpdate(nextProps, nextState) {
+        return !arePropsEqual(nextProps, this.props) || !shallowEqual(nextState, this.state);
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.disposable = new SerialDisposable();
+        this.currentType = undefined;
+        this.receiveProps(this.props);
+        this.handleChange();
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        if (!arePropsEqual(this.props, prevProps)) {
+          this.receiveProps(this.props);
+          this.handleChange();
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.dispose();
+      }
+    }, {
+      key: "receiveProps",
+      value: function receiveProps(props) {
+        if (!this.handler) {
+          return;
+        }
+
+        this.handler.receiveProps(props);
+        this.receiveType(getType(props));
+      }
+    }, {
+      key: "receiveType",
+      value: function receiveType(type) {
+        if (!this.handlerMonitor || !this.manager || !this.handlerConnector) {
+          return;
+        }
+
+        if (type === this.currentType) {
+          return;
+        }
+
+        this.currentType = type;
+
+        var _registerHandler = registerHandler(type, this.handler, this.manager),
+            _registerHandler2 = _slicedToArray(_registerHandler, 2),
+            handlerId = _registerHandler2[0],
+            unregister = _registerHandler2[1];
+
+        this.handlerId = handlerId;
+        this.handlerMonitor.receiveHandlerId(handlerId);
+        this.handlerConnector.receiveHandlerId(handlerId);
+        var globalMonitor = this.manager.getMonitor();
+        var unsubscribe = globalMonitor.subscribeToStateChange(this.handleChange, {
+          handlerIds: [handlerId]
+        });
+        this.disposable.setDisposable(new CompositeDisposable(new Disposable(unsubscribe), new Disposable(unregister)));
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.disposable.dispose();
+
+        if (this.handlerConnector) {
+          this.handlerConnector.receiveHandlerId(null);
+        }
+      }
+    }, {
+      key: "getCurrentState",
+      value: function getCurrentState() {
+        if (!this.handlerConnector) {
+          return {};
+        }
+
+        var nextState = collect(this.handlerConnector.hooks, this.handlerMonitor, this.props);
+
+        if (process.env.NODE_ENV !== 'production') {
+          invariant(isPlainObject(nextState), 'Expected `collect` specified as the second argument to ' + '%s for %s to return a plain object of props to inject. ' + 'Instead, received %s.', containerDisplayName, displayName, nextState);
+        }
+
+        return nextState;
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        return jsx(DndContext.Consumer, {
+          children: function children(_ref2) {
+            var dragDropManager = _ref2.dragDropManager;
+
+            _this2.receiveDragDropManager(dragDropManager);
+
+            if (typeof requestAnimationFrame !== 'undefined') {
+              requestAnimationFrame(function () {
+                var _this2$handlerConnect;
+
+                return (_this2$handlerConnect = _this2.handlerConnector) === null || _this2$handlerConnect === void 0 ? void 0 : _this2$handlerConnect.reconnect();
+              });
+            }
+
+            return jsx(Decorated, Object.assign({}, _this2.props, _this2.getCurrentState(), {
+              // NOTE: if Decorated is a Function Component, decoratedRef will not be populated unless it's a refforwarding component.
+              ref: isRefable(Decorated) ? _this2.decoratedRef : null
+            }), void 0);
+          }
+        }, void 0);
+      }
+    }, {
+      key: "receiveDragDropManager",
+      value: function receiveDragDropManager(dragDropManager) {
+        if (this.manager !== undefined) {
+          return;
+        }
+
+        invariant(dragDropManager !== undefined, 'Could not find the drag and drop manager in the context of %s. ' + 'Make sure to render a DndProvider component in your top-level component. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/troubleshooting#could-not-find-the-drag-and-drop-manager-in-the-context', displayName, displayName);
+
+        if (dragDropManager === undefined) {
+          return;
+        }
+
+        this.manager = dragDropManager;
+        this.handlerMonitor = createMonitor(dragDropManager);
+        this.handlerConnector = createConnector(dragDropManager.getBackend());
+        this.handler = createHandler(this.handlerMonitor, this.decoratedRef);
+      }
+    }]);
+
+    return DragDropContainer;
+  }(Component);
+
+  _defineProperty$2(DragDropContainer, "DecoratedComponent", DecoratedComponent);
+
+  _defineProperty$2(DragDropContainer, "displayName", "".concat(containerDisplayName, "(").concat(displayName, ")"));
+
+  return hoistStatics(DragDropContainer, DecoratedComponent);
+}
+
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
+
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var ALLOWED_SPEC_METHODS$1 = ['canDrag', 'beginDrag', 'isDragging', 'endDrag'];
+var REQUIRED_SPEC_METHODS = ['beginDrag'];
+
+var SourceImpl = /*#__PURE__*/function () {
+  function SourceImpl(spec, monitor, ref) {
+    var _this = this;
+
+    _classCallCheck$1(this, SourceImpl);
+
+    _defineProperty$1(this, "props", null);
+
+    _defineProperty$1(this, "spec", void 0);
+
+    _defineProperty$1(this, "monitor", void 0);
+
+    _defineProperty$1(this, "ref", void 0);
+
+    _defineProperty$1(this, "beginDrag", function () {
+      if (!_this.props) {
+        return;
+      }
+
+      var item = _this.spec.beginDrag(_this.props, _this.monitor, _this.ref.current);
+
+      if (process.env.NODE_ENV !== 'production') {
+        invariant(isPlainObject(item), 'beginDrag() must return a plain object that represents the dragged item. ' + 'Instead received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', item);
+      }
+
+      return item;
+    });
+
+    this.spec = spec;
+    this.monitor = monitor;
+    this.ref = ref;
+  }
+
+  _createClass$1(SourceImpl, [{
+    key: "receiveProps",
+    value: function receiveProps(props) {
+      this.props = props;
+    }
+  }, {
+    key: "canDrag",
+    value: function canDrag() {
+      if (!this.props) {
+        return false;
+      }
+
+      if (!this.spec.canDrag) {
+        return true;
+      }
+
+      return this.spec.canDrag(this.props, this.monitor);
+    }
+  }, {
+    key: "isDragging",
+    value: function isDragging(globalMonitor, sourceId) {
+      if (!this.props) {
+        return false;
+      }
+
+      if (!this.spec.isDragging) {
+        return sourceId === globalMonitor.getSourceId();
+      }
+
+      return this.spec.isDragging(this.props, this.monitor);
+    }
+  }, {
+    key: "endDrag",
+    value: function endDrag() {
+      if (!this.props) {
+        return;
+      }
+
+      if (!this.spec.endDrag) {
+        return;
+      }
+
+      this.spec.endDrag(this.props, this.monitor, getDecoratedComponent(this.ref));
+    }
+  }]);
+
+  return SourceImpl;
+}();
+
+function createSourceFactory(spec) {
+  Object.keys(spec).forEach(function (key) {
+    invariant(ALLOWED_SPEC_METHODS$1.indexOf(key) > -1, 'Expected the drag source specification to only have ' + 'some of the following keys: %s. ' + 'Instead received a specification with an unexpected "%s" key. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', ALLOWED_SPEC_METHODS$1.join(', '), key);
+    invariant(typeof spec[key] === 'function', 'Expected %s in the drag source specification to be a function. ' + 'Instead received a specification with %s: %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', key, key, spec[key]);
+  });
+  REQUIRED_SPEC_METHODS.forEach(function (key) {
+    invariant(typeof spec[key] === 'function', 'Expected %s in the drag source specification to be a function. ' + 'Instead received a specification with %s: %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', key, key, spec[key]);
+  });
+  return function createSource(monitor, ref) {
+    return new SourceImpl(spec, monitor, ref);
+  };
+}
+
+/**
+ * Decorates a component as a dragsource
+ * @param type The dragsource type
+ * @param spec The drag source specification
+ * @param collect The props collector function
+ * @param options DnD options
+ */
+
+function DragSource(type, spec, collect) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  checkDecoratorArguments('DragSource', 'type, spec, collect[, options]', type, spec, collect, options);
+  var getType = type;
+
+  if (typeof type !== 'function') {
+    invariant(isValidType(type), 'Expected "type" provided as the first argument to DragSource to be ' + 'a string, or a function that returns a string given the current props. ' + 'Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', type);
+
+    getType = function getType() {
+      return type;
+    };
+  }
+
+  invariant(isPlainObject(spec), 'Expected "spec" provided as the second argument to DragSource to be ' + 'a plain object. Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', spec);
+  var createSource = createSourceFactory(spec);
+  invariant(typeof collect === 'function', 'Expected "collect" provided as the third argument to DragSource to be ' + 'a function that returns a plain object of props to inject. ' + 'Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', collect);
+  invariant(isPlainObject(options), 'Expected "options" provided as the fourth argument to DragSource to be ' + 'a plain object when specified. ' + 'Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', collect);
+  return function decorateSource(DecoratedComponent) {
+    return decorateHandler({
+      containerDisplayName: 'DragSource',
+      createHandler: createSource,
+      registerHandler: registerSource,
+      createConnector: function createConnector(backend) {
+        return new SourceConnector(backend);
+      },
+      createMonitor: function createMonitor(manager) {
+        return new DragSourceMonitorImpl(manager);
+      },
+      DecoratedComponent: DecoratedComponent,
+      getType: getType,
+      collect: collect,
+      options: options
+    });
+  };
+}
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var ALLOWED_SPEC_METHODS = ['canDrop', 'hover', 'drop'];
+
+var TargetImpl = /*#__PURE__*/function () {
+  function TargetImpl(spec, monitor, ref) {
+    _classCallCheck(this, TargetImpl);
+
+    _defineProperty(this, "props", null);
+
+    _defineProperty(this, "spec", void 0);
+
+    _defineProperty(this, "monitor", void 0);
+
+    _defineProperty(this, "ref", void 0);
+
+    this.spec = spec;
+    this.monitor = monitor;
+    this.ref = ref;
+  }
+
+  _createClass(TargetImpl, [{
+    key: "receiveProps",
+    value: function receiveProps(props) {
+      this.props = props;
+    }
+  }, {
+    key: "receiveMonitor",
+    value: function receiveMonitor(monitor) {
+      this.monitor = monitor;
+    }
+  }, {
+    key: "canDrop",
+    value: function canDrop() {
+      if (!this.spec.canDrop) {
+        return true;
+      }
+
+      return this.spec.canDrop(this.props, this.monitor);
+    }
+  }, {
+    key: "hover",
+    value: function hover() {
+      if (!this.spec.hover || !this.props) {
+        return;
+      }
+
+      this.spec.hover(this.props, this.monitor, getDecoratedComponent(this.ref));
+    }
+  }, {
+    key: "drop",
+    value: function drop() {
+      if (!this.spec.drop) {
+        return undefined;
+      }
+
+      var dropResult = this.spec.drop(this.props, this.monitor, this.ref.current);
+
+      if (process.env.NODE_ENV !== 'production') {
+        invariant(typeof dropResult === 'undefined' || isPlainObject(dropResult), 'drop() must either return undefined, or an object that represents the drop result. ' + 'Instead received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', dropResult);
+      }
+
+      return dropResult;
+    }
+  }]);
+
+  return TargetImpl;
+}();
+
+function createTargetFactory(spec) {
+  Object.keys(spec).forEach(function (key) {
+    invariant(ALLOWED_SPEC_METHODS.indexOf(key) > -1, 'Expected the drop target specification to only have ' + 'some of the following keys: %s. ' + 'Instead received a specification with an unexpected "%s" key. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', ALLOWED_SPEC_METHODS.join(', '), key);
+    invariant(typeof spec[key] === 'function', 'Expected %s in the drop target specification to be a function. ' + 'Instead received a specification with %s: %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', key, key, spec[key]);
+  });
+  return function createTarget(monitor, ref) {
+    return new TargetImpl(spec, monitor, ref);
+  };
+}
+
+/**
+ * @param type The accepted target type
+ * @param spec The DropTarget specification
+ * @param collect The props collector function
+ * @param options Options
+ */
+
+function DropTarget(type, spec, collect) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  checkDecoratorArguments('DropTarget', 'type, spec, collect[, options]', type, spec, collect, options);
+  var getType = type;
+
+  if (typeof type !== 'function') {
+    invariant(isValidType(type, true), 'Expected "type" provided as the first argument to DropTarget to be ' + 'a string, an array of strings, or a function that returns either given ' + 'the current props. Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', type);
+
+    getType = function getType() {
+      return type;
+    };
+  }
+
+  invariant(isPlainObject(spec), 'Expected "spec" provided as the second argument to DropTarget to be ' + 'a plain object. Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', spec);
+  var createTarget = createTargetFactory(spec);
+  invariant(typeof collect === 'function', 'Expected "collect" provided as the third argument to DropTarget to be ' + 'a function that returns a plain object of props to inject. ' + 'Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', collect);
+  invariant(isPlainObject(options), 'Expected "options" provided as the fourth argument to DropTarget to be ' + 'a plain object when specified. ' + 'Instead, received %s. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target', collect);
+  return function decorateTarget(DecoratedComponent) {
+    return decorateHandler({
+      containerDisplayName: 'DropTarget',
+      createHandler: createTarget,
+      registerHandler: registerTarget,
+      createMonitor: function createMonitor(manager) {
+        return new DropTargetMonitorImpl(manager);
+      },
+      createConnector: function createConnector(backend) {
+        return new TargetConnector(backend);
+      },
+      DecoratedComponent: DecoratedComponent,
+      getType: getType,
+      collect: collect,
+      options: options
+    });
+  };
+}
+
+var RemoveCircle = {};
+
+var _interopRequireDefault = interopRequireDefault.exports;
+
+Object.defineProperty(RemoveCircle, "__esModule", {
+  value: true
+});
+var default_1 = RemoveCircle.default = void 0;
+
+var _react = _interopRequireDefault(React);
+
+var _createSvgIcon = _interopRequireDefault(createSvgIcon$1);
+
+var _default = (0, _createSvgIcon.default)(_react.default.createElement(_react.default.Fragment, null, _react.default.createElement("path", {
+  fill: "none",
+  d: "M0 0h24v24H0z"
+}), _react.default.createElement("path", {
+  d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11H7v-2h10v2z"
+})), 'RemoveCircle');
+
+default_1 = RemoveCircle.default = _default;
+
+const log$2 = debug('@pie-element:placement-ordering:configure:choice-tile');
+class ChoiceTile extends React.Component {
+  constructor(...args) {
+    super(...args);
+
+    this.onLabelChange = label => {
+      const {
+        choice,
+        onChoiceChange
+      } = this.props;
+      choice.label = label;
+      onChoiceChange(choice);
+    };
+  }
+
+  render() {
+    const {
+      choice: {
+        label,
+        editable,
+        type
+      },
+      isDragging,
+      connectDragSource,
+      connectDropTarget,
+      classes,
+      onDelete,
+      imageSupport,
+      spellCheck,
+      toolbarOpts,
+      pluginProps,
+      maxImageWidth,
+      maxImageHeight,
+      error,
+      mathMlOptions = {}
+    } = this.props;
+    const dragSourceOpts = {}; //dropEffect: moveOnDrag ? 'move' : 'copy'};
+
+    const filteredDefaultPlugins = (DEFAULT_PLUGINS || []).filter(p => p !== 'bulleted-list' && p !== 'numbered-list');
+    const opacity = isDragging ? 0 : 1;
+    const markup = /*#__PURE__*/React.createElement("div", {
+      className: classes.choiceTile,
+      style: {
+        opacity: opacity,
+        width: '100%'
+      }
+    }, /*#__PURE__*/React.createElement("div", {
+      style: {
+        width: '100%',
+        display: 'flex'
+      }
+    }, /*#__PURE__*/React.createElement(CardActions, null, /*#__PURE__*/React.createElement("span", {
+      className: classNames(classes.dragHandle)
+    }, /*#__PURE__*/React.createElement(default_1$1, {
+      className: classes.actions
+    }))), /*#__PURE__*/React.createElement(EditableHtml, {
+      disabled: !editable,
+      className: classNames(classes.prompt, !editable && classes.targetPrompt),
+      placeholder: type !== 'target' && !label.includes('data-latex') ? 'Enter a choice' : '',
+      markup: label,
+      imageSupport: imageSupport || undefined,
+      onChange: this.onLabelChange,
+      pluginProps: pluginProps,
+      toolbarOpts: toolbarOpts,
+      activePlugins: filteredDefaultPlugins,
+      spellCheck: spellCheck,
+      autoWidthToolbar: true,
+      maxImageWidth: maxImageWidth,
+      maxImageHeight: maxImageHeight,
+      languageCharactersProps: [{
+        language: 'spanish'
+      }, {
+        language: 'special'
+      }],
+      error: editable && error,
+      mathMlOptions: mathMlOptions
+    }), editable && /*#__PURE__*/React.createElement("div", {
+      className: classes.controls
+    }, /*#__PURE__*/React.createElement(IconButton, {
+      className: classes.customColor,
+      onClick: onDelete
+    }, /*#__PURE__*/React.createElement(default_1, {
+      classes: {
+        root: classes.removeCircle
+      }
+    })))), editable && error && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, error));
+    return connectDragSource(connectDropTarget( /*#__PURE__*/React.createElement("div", null, markup)), dragSourceOpts);
+  }
+
+}
+ChoiceTile.propTypes = {
+  connectDragSource: PropTypes.func.isRequired,
+  connectDropTarget: PropTypes.func.isRequired,
+  isDragging: PropTypes.bool.isRequired,
+  id: PropTypes.any,
+  maxImageHeight: PropTypes.object,
+  maxImageWidth: PropTypes.object,
+  label: PropTypes.string,
+  isOver: PropTypes.bool,
+  classes: PropTypes.object.isRequired,
+  type: PropTypes.string,
+  empty: PropTypes.bool,
+  disabled: PropTypes.bool,
+  outcome: PropTypes.object,
+  index: PropTypes.number,
+  imageSupport: PropTypes.shape({
+    add: PropTypes.func.isRequired,
+    delete: PropTypes.func.isRequired
+  }),
+  choice: PropTypes.object,
+  choices: PropTypes.array.isRequired,
+  onChoiceChange: PropTypes.func.isRequired,
+  onDelete: PropTypes.func.isRequired,
+  toolbarOpts: PropTypes.object,
+  pluginProps: PropTypes.object,
+  choicesLabel: PropTypes.string,
+  error: PropTypes.string,
+  spellCheck: PropTypes.bool
+};
+const Styled = withStyles(theme => ({
+  removeCircle: {
+    fill: theme.palette.error[500]
+  },
+  choiceTile: {
+    cursor: 'move',
+    backgroundColor: theme.palette.common.white,
+    margin: `${theme.spacing.unit}px 0`,
+    display: 'flex',
+    flexDirection: 'column'
+  },
+  controls: {
+    display: 'flex',
+    justifyContent: 'flex-end'
+  },
+  prompt: {
+    width: '80%',
+    border: 'none',
+    borderRadius: '4px'
+  },
+  targetPrompt: {
+    backgroundColor: theme.palette.error['A100']
+  },
+  actions: {
+    color: theme.palette.error[400]
+  },
+  errorText: {
+    fontSize: theme.typography.fontSize - 2,
+    color: theme.palette.error.main,
+    marginLeft: theme.spacing.unit * 5,
+    marginTop: theme.spacing.unit
+  },
+  correctOrder: {
+    position: 'absolute',
+    top: 0,
+    fontSize: theme.typography.fontSize - 2,
+    color: color.disabled()
+  },
+  customColor: {
+    color: `${color.tertiary()} !important`
+  }
+}))(ChoiceTile);
+const NAME = 'choice-config';
+const choiceSource = {
+  beginDrag(props) {
+    return {
+      id: props.choice.id,
+      index: props.index,
+      type: props.choice.type,
+      instanceId: props.choice.instanceId
+    };
+  }
+
+};
+const StyledSource = DragSource(NAME, choiceSource, (connect, monitor) => ({
+  connectDragSource: connect.dragSource(),
+  isDragging: monitor.isDragging()
+}))(Styled);
+const choiceTarget = {
+  hover() {
+    log$2('[hover]');
+  },
+
+  drop(props, monitor) {
+    const item = monitor.getItem();
+    log$2('[drop] item: ', item, 'didDrop?', monitor.didDrop());
+    props.onDropChoice(item, props.index);
+  }
+
+};
+const StyledSourceAndTarget = DropTarget(NAME, choiceTarget, (connect, monitor) => ({
+  connectDropTarget: connect.dropTarget(),
+  isOver: monitor.isOver()
+}))(StyledSource);
+
+function findFreeChoiceSlot(choices) {
+  let slot = 1;
+  const ids = choices.map(c => c.id);
+
+  while (ids.includes(`c${slot}`)) {
+    slot++;
+  }
+
+  return slot;
+}
+
+const log$1 = debug('@pie-element:placement-ordering:configure:choice-editor');
+
+function updateResponseOrChoices(response, choices, from, to) {
+  const {
+    type: fromType,
+    index: fromIndex
+  } = from;
+  const {
+    type: toType,
+    index: placeAtIndex
+  } = to;
+
+  if (fromType === 'target' && toType === 'target') {
+    const updatedResponse = cloneDeep(response) || [];
+    const {
+      movedItem,
+      remainingItems
+    } = updatedResponse.reduce((acc, item, index) => {
+      if (index === fromIndex) {
+        acc.movedItem = item;
+      } else {
+        acc.remainingItems.push(item);
+      }
+
+      return acc;
+    }, {
+      movedItem: null,
+      remainingItems: []
+    });
+    return {
+      response: [...remainingItems.slice(0, placeAtIndex), movedItem, ...remainingItems.slice(placeAtIndex)],
+      choices
+    };
+  }
+
+  if (fromType === 'choice' && toType === 'choice') {
+    const updatedChoices = cloneDeep(choices) || [];
+    const {
+      movedItem,
+      remainingItems,
+      toIndex
+    } = updatedChoices.reduce((acc, item, index) => {
+      if (item.id === from.id) {
+        acc.movedItem = item;
+      } else {
+        acc.remainingItems.push(item);
+      }
+
+      if (item.id === to.id) {
+        acc.toIndex = index;
+      }
+
+      return acc;
+    }, {
+      movedItem: null,
+      remainingItems: [],
+      toIndex: null
+    });
+    return {
+      response,
+      choices: [...remainingItems.slice(0, toIndex), movedItem, ...remainingItems.slice(toIndex)]
+    };
+  }
+
+  return {
+    response,
+    choices
+  };
+}
+
+function buildTiles(choices, response, instanceId) {
+  const targets = response.map((r, index) => {
+    const respId = r && r.id;
+    const choice = choices.find(c => respId !== undefined && respId !== null && c.id === respId);
+    return _extends({
+      type: 'target',
+      instanceId
+    }, choice, {
+      draggable: true,
+      index,
+      editable: false
+    });
+  });
+  const processedChoices = choices.map(m => {
+    return Object.assign({}, m, {
+      type: 'choice',
+      droppable: false,
+      draggable: true,
+      instanceId,
+      editable: true
+    });
+  });
+  return processedChoices.concat(targets);
+}
+
+class ChoiceEditor extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      warning: {
+        open: false
+      }
+    };
+    this.instanceId = uniqueId();
+
+    this.onChoiceChange = choice => {
+      const {
+        choices,
+        onChange,
+        correctResponse
+      } = this.props;
+      const index = choices.findIndex(c => c.id === choice.id);
+      choices.splice(index, 1, _extends({}, choices[index], {
+        label: choice.label
+      }));
+      onChange(choices, correctResponse);
+    };
+
+    this.onDelete = choice => {
+      const {
+        choices,
+        onChange,
+        correctResponse,
+        choicesLabel
+      } = this.props;
+
+      if (choices && choices.length === 3) {
+        this.setState({
+          warning: {
+            open: true,
+            text: `There have to be at least 3 ${choicesLabel}.`
+          }
+        });
+      } else {
+        const updatedChoices = choices.filter(c => c.id !== choice.id);
+        const updatedCorrectResponse = correctResponse.filter(v => v.id !== choice.id);
+        onChange(updatedChoices, updatedCorrectResponse);
+      }
+    };
+
+    this.addChoice = () => {
+      const {
+        choices,
+        correctResponse,
+        onChange,
+        choicesLabel
+      } = this.props;
+
+      if (choices && choices.length === 10) {
+        this.setState({
+          warning: {
+            open: true,
+            text: `There can be maximum 10 ${choicesLabel}.`
+          }
+        });
+      } else {
+        const freeId = findFreeChoiceSlot(choices);
+        const id = `c${freeId}`;
+        const newChoice = {
+          id,
+          label: ''
+        };
+        const newCorrectResponse = {
+          id,
+
+          /**
+           * Note: weights are not configurable in the existing component
+           * so we'll want do disable this in the controller and ignore it for now.
+           */
+          weight: 0
+        };
+        const updatedChoices = choices.concat([newChoice]);
+        const updatedCorrectResponse = correctResponse.concat([newCorrectResponse]);
+        onChange(updatedChoices, updatedCorrectResponse);
+      }
+    };
+
+    this.shuffleChoices = () => {
+      const {
+        onChange,
+        choices,
+        correctResponse,
+        placementArea
+      } = this.props;
+      let shuffled = shuffle(choices); // if placementArea is disabled, make sure we don't shuffle choices in the correct order
+
+      const shuffledCorrect = !placementArea && isEqual(shuffled.map(item => item.id), correctResponse.map(item => item.id));
+
+      if (shuffledCorrect) {
+        const shuffledTwice = shuffle(shuffled);
+        onChange(shuffledTwice, correctResponse);
+      } else {
+        onChange(shuffled, correctResponse);
+      }
+    };
+
+    this.onDropChoice = (ordering, target, source) => {
+      const {
+        onChange
+      } = this.props;
+      const from = ordering.tiles.find(t => t.id === source.id && t.type === source.type);
+      const to = target;
+      log$1('[onDropChoice] ', from, to);
+      const {
+        response,
+        choices
+      } = updateResponseOrChoices(ordering.response, ordering.choices, from, to);
+      onChange(choices, response);
+    };
+  }
+
+  render() {
+    const {
+      classes,
+      correctResponse,
+      choices,
+      imageSupport,
+      toolbarOpts,
+      pluginProps,
+      singularChoiceLabel,
+      pluralChoiceLabel,
+      choicesLabel,
+      spellCheck,
+      maxImageWidth,
+      maxImageHeight,
+      errors,
+      mathMlOptions = {}
+    } = this.props;
+    const {
+      warning
+    } = this.state;
+    const {
+      choicesErrors,
+      orderError
+    } = errors || {};
+    const ordering = {
+      choices,
+      response: !correctResponse || isEmpty(correctResponse) ? new Array(choices.length) : correctResponse,
+      tiles: buildTiles(choices, correctResponse, this.instanceId)
+    };
+    const vTilerStyle = {
+      gridTemplateColumns: 'repeat(2, 1fr)',
+      gridTemplateRows: `repeat(${choices.length}, 1fr)`
+    };
+    return /*#__PURE__*/React.createElement("div", {
+      className: classes.choiceEditor
+    }, /*#__PURE__*/React.createElement("div", {
+      className: classes.vtiler,
+      style: {
+        gridTemplateColumns: 'repeat(2, 1fr)'
+      }
+    }, /*#__PURE__*/React.createElement(InputContainer, {
+      label: `Student ${choicesLabel || 'Choices'}`,
+      className: classes.columnLabel
+    }), /*#__PURE__*/React.createElement(InputContainer, {
+      label: "Correct Order",
+      className: classes.columnLabel
+    })), /*#__PURE__*/React.createElement("div", {
+      className: classes.vtiler,
+      style: vTilerStyle
+    }, ordering.tiles.map((choice, index) => /*#__PURE__*/React.createElement(StyledSourceAndTarget, {
+      choice: choice,
+      index: index,
+      key: index,
+      imageSupport: imageSupport,
+      onDelete: this.onDelete.bind(this, choice),
+      onChoiceChange: this.onChoiceChange,
+      onDropChoice: (source, index) => this.onDropChoice(ordering, choice, source, index),
+      toolbarOpts: toolbarOpts,
+      pluginProps: pluginProps,
+      choices: choices,
+      choicesLabel: choicesLabel,
+      spellCheck: spellCheck,
+      maxImageWidth: maxImageWidth,
+      maxImageHeight: maxImageHeight,
+      error: (choicesErrors == null ? void 0 : choicesErrors[choice.id]) || orderError && ' ' || null,
+      mathMlOptions: mathMlOptions
+    }))), orderError && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, orderError), /*#__PURE__*/React.createElement("div", {
+      className: classes.controls
+    }, /*#__PURE__*/React.createElement(Button, {
+      onClick: this.shuffleChoices,
+      size: "small",
+      variant: "contained",
+      color: "default",
+      classes: {
+        root: classes.addButtonRoot,
+        label: classes.addButtonLabel
+      }
+    }, `SHUFFLE ${pluralChoiceLabel}`.toUpperCase()), /*#__PURE__*/React.createElement(Button, {
+      onClick: this.addChoice,
+      size: "small",
+      variant: "contained",
+      color: "default",
+      classes: {
+        root: classes.addButtonRoot,
+        label: classes.addButtonLabel
+      }
+    }, `ADD ${singularChoiceLabel}`.toUpperCase())), /*#__PURE__*/React.createElement(AlertDialog, {
+      open: warning.open,
+      title: "Warning",
+      text: warning.text,
+      onConfirm: () => this.setState({
+        warning: {
+          open: false
+        }
+      })
+    }));
+  }
+
+}
+
+ChoiceEditor.propTypes = {
+  classes: PropTypes.object.isRequired,
+  correctResponse: PropTypes.array.isRequired,
+  choices: PropTypes.array.isRequired,
+  onChange: PropTypes.func.isRequired,
+  imageSupport: PropTypes.shape({
+    add: PropTypes.func.isRequired,
+    delete: PropTypes.func.isRequired
+  }),
+  maxImageHeight: PropTypes.object,
+  maxImageWidth: PropTypes.object,
+  toolbarOpts: PropTypes.object,
+  pluginProps: PropTypes.object,
+  placementArea: PropTypes.bool,
+  singularChoiceLabel: PropTypes.string,
+  pluralChoiceLabel: PropTypes.string,
+  choicesLabel: PropTypes.string,
+  errors: PropTypes.object,
+  spellCheck: PropTypes.bool
+};
+
+const styles = theme => ({
+  allToggle: {},
+  choiceEditor: {},
+  controls: {
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between'
+  },
+  root: {
+    width: '30px',
+    height: '30px',
+    fill: theme.palette.primary[500]
+  },
+  addButtonRoot: {
+    marginTop: theme.spacing.unit * 2.5,
+    paddingHorizontal: theme.spacing.unit * 1.5
+  },
+  addButtonLabel: {
+    transition: 'opacity 200ms linear',
+    '&:hover': {
+      opacity: 0.3
+    }
+  },
+  vtiler: {
+    gridAutoFlow: 'column',
+    display: 'grid',
+    gridGap: '10px',
+    alignItems: 'center'
+  },
+  columnLabel: {
+    width: '100%',
+    paddingTop: theme.spacing.unit * 2
+  },
+  errorText: {
+    fontSize: theme.typography.fontSize - 2,
+    color: theme.palette.error.main,
+    paddingTop: theme.spacing.unit
+  }
+});
+
+var ChoiceEditor$1 = withStyles(styles)(ChoiceEditor);
+
+const generateValidationMessage = () => {
+  const answersMessage = '\nThere should be at least 3 tokens.' + '\nThe tokens should not be empty and should be unique.' + '\nThe correct ordering should not be identical to the initial ordering.';
+  return 'Validation requirements:' + answersMessage;
+};
+
+const log = debug('@pie-element:placement-ordering:design');
+const {
+  Panel,
+  toggle,
+  radio,
+  dropdown
+} = settings;
+
+const getSingularAndPlural = label => !pluralize.isPlural(label) ? {
+  singularLabel: label,
+  pluralLabel: pluralize(label)
+} : {
+  singularLabel: pluralize.singular(label),
+  pluralLabel: label
+};
+
+class Design extends React.Component {
+  constructor(props) {
+    super(props);
+
+    this.applyUpdate = modelFn => {
+      const {
+        model,
+        onModelChanged
+      } = this.props;
+      const update = modelFn(cloneDeep(model));
+      onModelChanged(update);
+    };
+
+    this.changeHandler = (modelPath, valuePath) => {
+      return value => {
+        log('[changeHandler] value: ', value);
+        const v = valuePath ? nestedProperty.get(value, valuePath) : value;
+        this.applyUpdate(model => {
+          nestedProperty.set(model, modelPath, v);
+          return model;
+        });
+      };
+    };
+
+    this.onPromptChange = this.changeHandler('prompt');
+    this.onTeacherInstructionsChange = this.changeHandler('teacherInstructions');
+    this.onRationaleChange = this.changeHandler('rationale');
+    this.onChoiceAreaLabelChange = this.changeHandler('choiceLabel', 'target.value');
+    this.onAnswerAreaLabelChange = this.changeHandler('targetLabel', 'target.value');
+    this.onFeedbackChange = this.changeHandler('feedback');
+
+    this.onChoiceEditorChange = (choices, correctResponse) => {
+      const {
+        model,
+        onModelChanged
+      } = this.props;
+      const update = cloneDeep(model);
+      update.choices = choices;
+      update.correctResponse = correctResponse;
+      onModelChanged(update);
+    };
+  }
+
+  componentDidMount() {
+    const {
+      model,
+      onModelChanged
+    } = this.props || {};
+    const {
+      feedback
+    } = model || {};
+    const update = cloneDeep(model); // requirement made in PD-2182
+
+    if (!feedback) {
+      update.feedbackEnabled = false;
+      onModelChanged(update);
+    }
+  }
+
+  render() {
+    const {
+      model,
+      classes,
+      imageSupport,
+      uploadSoundSupport,
+      onModelChanged,
+      configuration,
+      onConfigurationChanged
+    } = this.props;
+    const {
+      baseInputConfiguration = {},
+      choiceLabel = {},
+      choices = {},
+      contentDimensions = {},
+      feedback = {},
+      prompt = {},
+      placementArea = {},
+      maxImageWidth = {},
+      maxImageHeight = {},
+      numberedGuides = {},
+      orientation = {},
+      partialScoring = {},
+      rationale = {},
+      removeTilesAfterPlacing = {},
+      settingsPanelDisabled,
+      studentInstructions = {},
+      spellCheck = {},
+      scoringType = {},
+      targetLabel = {},
+      teacherInstructions = {},
+      withRubric = {},
+      mathMlOptions = {},
+      language = {},
+      languageChoices = {}
+    } = configuration || {};
+    const {
+      choiceLabelEnabled,
+      errors,
+      extraCSSRules,
+      feedbackEnabled,
+      promptEnabled,
+      rationaleEnabled,
+      spellCheckEnabled,
+      teacherInstructionsEnabled,
+      toolbarEditorPosition
+    } = model || {};
+    const {
+      prompt: promptError,
+      rationale: rationaleError,
+      teacherInstructions: teacherInstructionsError
+    } = errors || {};
+    const validationMessage = generateValidationMessage();
+    const {
+      singularLabel = '',
+      pluralLabel = ''
+    } = (choices == null ? void 0 : choices.label) && getSingularAndPlural(choices.label) || {};
+    const defaultImageMaxWidth = maxImageWidth && maxImageWidth.prompt;
+    const defaultImageMaxHeight = maxImageHeight && maxImageHeight.prompt;
+    const maxChoicesImageWidth = maxImageWidth && model.placementArea ? maxImageWidth.choicesWithPlacementArea : maxImageWidth.choicesWithoutPlacementArea || defaultImageMaxWidth;
+    const maxChoicesImageHeight = maxImageHeight && maxImageHeight.choices || defaultImageMaxHeight;
+    const toolbarOpts = {
+      position: toolbarEditorPosition === 'top' ? 'top' : 'bottom'
+    };
+    const panelSettings = {
+      choiceLabelEnabled: choiceLabel.settings && toggle(choiceLabel.label),
+      placementArea: placementArea.settings && toggle(placementArea.label),
+      numberedGuides: numberedGuides.settings && model.placementArea && toggle(numberedGuides.label),
+      orientation: orientation.settings && radio(orientation.label, ['vertical', 'horizontal']),
+      removeTilesAfterPlacing: removeTilesAfterPlacing.settings && toggle(removeTilesAfterPlacing.label),
+      partialScoring: partialScoring.settings && toggle(partialScoring.label),
+      feedbackEnabled: feedback.settings && toggle(feedback.label),
+      'language.enabled': language.settings && toggle(language.label, true),
+      language: language.settings && language.enabled && dropdown(languageChoices.label, languageChoices.options)
+    };
+    const panelProperties = {
+      teacherInstructionsEnabled: teacherInstructions.settings && toggle(teacherInstructions.label),
+      studentInstructionsEnabled: studentInstructions.settings && toggle(studentInstructions.label),
+      rationaleEnabled: rationale.settings && toggle(rationale.label),
+      promptEnabled: prompt.settings && toggle(prompt.label),
+      spellCheckEnabled: spellCheck.settings && toggle(spellCheck.label),
+      scoringType: scoringType.settings && radio(scoringType.label, ['auto', 'rubric']),
+      rubricEnabled: (withRubric == null ? void 0 : withRubric.settings) && toggle(withRubric == null ? void 0 : withRubric.label)
+    };
+
+    const getPluginProps = (props = {}) => _extends({}, baseInputConfiguration, props);
+
+    return /*#__PURE__*/React.createElement(layout.ConfigLayout, {
+      extraCSSRules: extraCSSRules,
+      dimensions: contentDimensions,
+      hideSettings: settingsPanelDisabled,
+      settings: /*#__PURE__*/React.createElement(Panel, {
+        model: model,
+        configuration: configuration,
+        onChangeModel: model => onModelChanged(model),
+        onChangeConfiguration: configuration => onConfigurationChanged(configuration, true),
+        groups: {
+          Settings: panelSettings,
+          Properties: panelProperties
+        }
+      })
+    }, teacherInstructionsEnabled && /*#__PURE__*/React.createElement(InputContainer$1, {
+      label: teacherInstructions.label,
+      className: classes.promptHolder
+    }, /*#__PURE__*/React.createElement(EditableHtml, {
+      className: classes.prompt,
+      markup: model.teacherInstructions || '',
+      onChange: this.onTeacherInstructionsChange,
+      imageSupport: imageSupport,
+      nonEmpty: false,
+      error: teacherInstructionsError,
+      toolbarOpts: toolbarOpts,
+      pluginProps: getPluginProps(teacherInstructions == null ? void 0 : teacherInstructions.inputConfiguration),
+      spellCheck: spellCheckEnabled,
+      maxImageWidth: maxImageWidth && maxImageWidth.teacherInstructions || defaultImageMaxWidth,
+      maxImageHeight: maxImageHeight && maxImageHeight.teacherInstructions || defaultImageMaxHeight,
+      uploadSoundSupport: uploadSoundSupport,
+      languageCharactersProps: [{
+        language: 'spanish'
+      }, {
+        language: 'special'
+      }],
+      mathMlOptions: mathMlOptions
+    }), teacherInstructionsError && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, teacherInstructionsError)), promptEnabled && /*#__PURE__*/React.createElement(InputContainer$1, {
+      label: prompt && prompt.label,
+      className: classes.promptHolder
+    }, /*#__PURE__*/React.createElement(EditableHtml, {
+      className: classes.prompt,
+      markup: model.prompt,
+      onChange: this.onPromptChange,
+      imageSupport: imageSupport,
+      error: promptError,
+      toolbarOpts: toolbarOpts,
+      pluginProps: getPluginProps(prompt == null ? void 0 : prompt.inputConfiguration),
+      spellCheck: spellCheckEnabled,
+      maxImageWidth: maxImageWidth && maxImageWidth.prompt,
+      maxImageHeight: maxImageHeight && maxImageHeight.prompt,
+      uploadSoundSupport: uploadSoundSupport,
+      languageCharactersProps: [{
+        language: 'spanish'
+      }, {
+        language: 'special'
+      }],
+      mathMlOptions: mathMlOptions
+    }), promptError && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, promptError)), /*#__PURE__*/React.createElement(FormSection, {
+      className: classes.choicesWrapper,
+      label: `Define ${pluralLabel}`,
+      labelExtraStyle: {
+        display: 'inline-flex'
+      }
+    }, /*#__PURE__*/React.createElement("div", {
+      className: classes.inlineFlexContainer
+    }, /*#__PURE__*/React.createElement(Tooltip, {
+      classes: {
+        tooltip: classes.tooltip
+      },
+      disableFocusListener: true,
+      disableTouchListener: true,
+      placement: 'right',
+      title: validationMessage
+    }, /*#__PURE__*/React.createElement(default_1$2, {
+      fontSize: 'small',
+      color: 'primary',
+      style: {
+        marginLeft: '8px'
+      }
+    }))), /*#__PURE__*/React.createElement("div", {
+      className: classes.row
+    }, choiceLabelEnabled && /*#__PURE__*/React.createElement(InputContainer$1, {
+      label: choiceLabel && choiceLabel.label && `${singularLabel} label`,
+      className: classes.promptHolder
+    }, /*#__PURE__*/React.createElement(EditableHtml, _extends({}, model.placementArea && {
+      autoWidthToolbar: true
+    }, {
+      className: classes.prompt,
+      markup: model.choiceLabel,
+      onChange: this.onChoiceAreaLabelChange,
+      toolbarOpts: toolbarOpts,
+      pluginProps: getPluginProps(choiceLabel == null ? void 0 : choiceLabel.inputConfiguration),
+      spellCheck: spellCheckEnabled,
+      maxImageWidth: maxChoicesImageWidth,
+      maxImageHeight: maxChoicesImageHeight,
+      uploadSoundSupport: uploadSoundSupport,
+      languageCharactersProps: [{
+        language: 'spanish'
+      }, {
+        language: 'special'
+      }],
+      mathMlOptions: mathMlOptions
+    }))), targetLabel.settings && model.placementArea && /*#__PURE__*/React.createElement(InputContainer$1, {
+      label: targetLabel && targetLabel.label && targetLabel.label,
+      className: classes.promptHolder
+    }, /*#__PURE__*/React.createElement(EditableHtml, {
+      autoWidthToolbar: true,
+      className: classes.prompt,
+      markup: model.targetLabel,
+      onChange: this.onAnswerAreaLabelChange,
+      toolbarOpts: toolbarOpts,
+      spellCheck: spellCheckEnabled,
+      maxImageWidth: maxImageWidth && maxImageWidth.choicesWithPlacementArea || defaultImageMaxWidth,
+      maxImageHeight: maxChoicesImageHeight,
+      uploadSoundSupport: uploadSoundSupport,
+      languageCharactersProps: [{
+        language: 'spanish'
+      }, {
+        language: 'special'
+      }],
+      mathMlOptions: mathMlOptions
+    }))), choices.settings && /*#__PURE__*/React.createElement(ChoiceEditor$1, {
+      correctResponse: model.correctResponse,
+      choices: model.choices,
+      onChange: this.onChoiceEditorChange,
+      imageSupport: imageSupport,
+      toolbarOpts: toolbarOpts,
+      pluginProps: getPluginProps(choices == null ? void 0 : choices.inputConfiguration),
+      choicesLabel: choices.label,
+      placementArea: model.placementArea,
+      singularChoiceLabel: singularLabel,
+      pluralChoiceLabel: pluralLabel,
+      spellCheck: spellCheckEnabled,
+      maxImageWidth: maxChoicesImageWidth,
+      maxImageHeight: maxChoicesImageHeight,
+      errors: errors || {},
+      mathMlOptions: mathMlOptions
+    })), rationaleEnabled && /*#__PURE__*/React.createElement(InputContainer$1, {
+      label: rationale.label,
+      className: classes.promptHolder
+    }, /*#__PURE__*/React.createElement(EditableHtml, {
+      className: classes.prompt,
+      markup: model.rationale || '',
+      onChange: this.onRationaleChange,
+      imageSupport: imageSupport,
+      error: rationaleError,
+      toolbarOpts: toolbarOpts,
+      pluginProps: getPluginProps(rationale == null ? void 0 : rationale.inputConfiguration),
+      spellCheck: spellCheckEnabled,
+      maxImageWidth: maxImageWidth && maxImageWidth.rationale || defaultImageMaxWidth,
+      maxImageHeight: maxImageHeight && maxImageHeight.rationale || defaultImageMaxHeight,
+      uploadSoundSupport: uploadSoundSupport,
+      languageCharactersProps: [{
+        language: 'spanish'
+      }, {
+        language: 'special'
+      }],
+      mathMlOptions: mathMlOptions
+    }), rationaleError && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, rationaleError)), feedbackEnabled && /*#__PURE__*/React.createElement(FeedbackConfig, {
+      feedback: model.feedback,
+      onChange: this.onFeedbackChange,
+      imageSupport: imageSupport,
+      toolbarOpts: toolbarOpts
+    }));
+  }
+
+}
+Design.propTypes = {
+  uploadSoundSupport: PropTypes.object
+};
+Design.defaultProps = {};
+Design.defaultProps = {
+  onModelChanged: () => {},
+  onConfigurationChanged: () => {}
+};
+Design.propTypes = {
+  model: PropTypes.object.isRequired,
+  configuration: PropTypes.object.isRequired,
+  onModelChanged: PropTypes.func,
+  onConfigurationChanged: PropTypes.func,
+  classes: PropTypes.object.isRequired,
+  imageSupport: PropTypes.object
+};
+var Main = withDragContext(withStyles(theme => ({
+  promptHolder: {
+    width: '100%',
+    paddingTop: theme.spacing.unit * 2,
+    marginBottom: theme.spacing.unit * 2
+  },
+  row: {
+    display: 'grid',
+    gridAutoFlow: 'column',
+    gridAutoColumns: '1fr',
+    gridGap: '8px'
+  },
+  choicesWrapper: {
+    marginTop: 0,
+    marginBottom: theme.spacing.unit * 2.5
+  },
+  tooltip: {
+    fontSize: theme.typography.fontSize - 2,
+    whiteSpace: 'pre',
+    maxWidth: '500px'
+  },
+  inlineFlexContainer: {
+    display: 'inline-flex',
+    position: 'absolute'
+  },
+  errorText: {
+    fontSize: theme.typography.fontSize - 2,
+    color: theme.palette.error.main,
+    paddingTop: theme.spacing.unit
+  }
+}))(Design));
+
+/** NOTE: teacherInstructions, studentInstructions, rationale & scoringType
+ * functionalities are not defined yet - the value for those can belong to
+ * model or to configuration
+ */
+var defaultValues = {
+  model: {
+    choiceLabel: '',
+    choiceLabelEnabled: true,
+    choices: [],
+    correctResponse: [],
+    feedbackEnabled: false,
+    numberedGuides: false,
+    orientation: 'vertical',
+    partialScoring: true,
+    placementArea: false,
+    prompt: '',
+    promptEnabled: true,
+    rationale: '',
+    rationaleEnabled: true,
+    removeTilesAfterPlacing: true,
+    scoringType: 'auto',
+    studentInstructionsEnabled: true,
+    targetLabel: '',
+    teacherInstructions: '',
+    teacherInstructionsEnabled: true,
+    toolbarEditorPosition: 'bottom'
+  },
+  configuration: {
+    baseInputConfiguration: {
+      audio: {
+        disabled: false
+      },
+      video: {
+        disabled: false
+      },
+      image: {
+        disabled: false
+      },
+      textAlign: {
+        disabled: true
+      },
+      showParagraphs: {
+        disabled: false
+      },
+      separateParagraphs: {
+        disabled: true
+      }
+    },
+    choiceLabel: {
+      settings: true,
+      label: 'Choice label',
+      inputConfiguration: {
+        audio: {
+          disabled: false
+        },
+        video: {
+          disabled: false
+        },
+        image: {
+          disabled: false
+        }
+      }
+    },
+    choices: {
+      settings: true,
+      label: 'Choices',
+      inputConfiguration: {
+        audio: {
+          disabled: true
+        },
+        video: {
+          disabled: true
+        },
+        image: {
+          disabled: true
+        }
+      }
+    },
+    feedback: {
+      settings: true,
+      label: 'Feedback',
+      enabled: true
+    },
+    prompt: {
+      settings: true,
+      label: 'Item Stem',
+      required: false,
+      inputConfiguration: {
+        audio: {
+          disabled: false
+        },
+        video: {
+          disabled: false
+        },
+        image: {
+          disabled: false
+        }
+      }
+    },
+    numberedGuides: {
+      settings: true,
+      label: 'Numbered guides'
+    },
+    orientation: {
+      settings: true,
+      label: 'Orientation'
+    },
+    partialScoring: {
+      settings: false,
+      label: 'Allow Partial Scoring'
+    },
+    placementArea: {
+      settings: true,
+      label: 'Placement Area'
+    },
+    rationale: {
+      settings: true,
+      label: 'Rationale',
+      required: false,
+      inputConfiguration: {
+        audio: {
+          disabled: false
+        },
+        video: {
+          disabled: false
+        },
+        image: {
+          disabled: false
+        }
+      }
+    },
+    removeTilesAfterPlacing: {
+      settings: false,
+      label: 'Remove Tiles after placing'
+    },
+    settingsPanelDisabled: false,
+    scoringType: {
+      settings: false,
+      label: 'Scoring Type'
+    },
+    studentInstructions: {
+      settings: false,
+      label: 'Student Instructions'
+    },
+    targetLabel: {
+      settings: true,
+      label: 'Target label'
+    },
+    spellCheck: {
+      label: 'Spellcheck',
+      settings: false,
+      enabled: true
+    },
+    teacherInstructions: {
+      settings: true,
+      label: 'Teacher Instructions',
+      required: false,
+      inputConfiguration: {
+        audio: {
+          disabled: false
+        },
+        video: {
+          disabled: false
+        },
+        image: {
+          disabled: false
+        }
+      }
+    },
+    maxImageWidth: {
+      teacherInstructions: 300,
+      prompt: 300,
+      rationale: 300,
+      choicesWithPlacementArea: 240,
+      choicesWithoutPlacementArea: 300
+    },
+    maxImageHeight: {
+      teacherInstructions: 300,
+      prompt: 300,
+      rationale: 300,
+      choices: 150
+    },
+    withRubric: {
+      settings: false,
+      label: 'Add Rubric'
+    },
+    mathMlOptions: {
+      mmlOutput: false,
+      mmlEditing: false
+    },
+    language: {
+      settings: false,
+      label: 'Specify Language',
+      enabled: false
+    },
+    languageChoices: {
+      label: 'Language Choices',
+      options: []
+    }
+  }
+};
+
+const prepareCustomizationObject = (config, model) => {
+  const configuration = defaults(config, defaultValues.configuration);
+  return {
+    configuration,
+    model
+  };
+};
+
+const addWeightToCorrectResponse = correctResponse => correctResponse && correctResponse.map(correct => {
+  // if weight is set
+  if (correct.weight !== undefined) {
+    return {
+      id: correct.id,
+      weight: correct.weight
+    };
+  } else {
+    return {
+      id: correct.id || correct,
+      weight: 0
+    };
+  }
+});
+/**
+ * assuming that the correct response will be set via ui, not via config,
+ * correctResponse (if not set) will be initialized with choices default order
+ */
+
+class PlacementOrdering extends HTMLElement {
+  constructor() {
+    super();
+    this._model = PlacementOrdering.createDefaultModel();
+    this._configuration = defaultValues.configuration;
+
+    this.onModelChanged = (model, resetSession) => {
+      this._model = model;
+
+      this._rerender();
+
+      this.dispatchUpdate(resetSession);
+    };
+
+    this.onConfigurationChanged = configuration => {
+      this._configuration = prepareCustomizationObject(configuration).configuration;
+      this.onModelChanged(this._model);
+
+      this._rerender();
+    };
+
+    this.insertImage = handler => {
+      this.dispatchEvent(new InsertImageEvent(handler));
+    };
+
+    this.deleteImage = (src, done) => {
+      this.dispatchEvent(new DeleteImageEvent(src, done));
+    };
+  }
+
+  dispatchUpdate(reset) {
+    this.dispatchEvent(new ModelUpdatedEvent(this._model, reset));
+  }
+
+  set model(s) {
+    this._model = PlacementOrdering.createDefaultModel(s);
+
+    this._rerender();
+  }
+
+  set configuration(c) {
+    var _newConfiguration$lan;
+
+    const info = prepareCustomizationObject(c, this._model);
+    this.onModelChanged(info.model);
+
+    const newConfiguration = _extends({}, defaultValues.configuration, info.configuration);
+
+    this._configuration = newConfiguration; // if language:enabled is true, then the corresponding default item model should include a language value;
+    // if it is false, then the language field should be omitted from the item model.
+    // if a default item model includes a language value (e.g., en_US) and the corresponding authoring view settings have language:settings = true,
+    // then (a) language:enabled should also be true, and (b) that default language value should be represented in languageChoices[] (as a key).
+
+    if (newConfiguration != null && (_newConfiguration$lan = newConfiguration.language) != null && _newConfiguration$lan.enabled) {
+      var _newConfiguration$lan2, _newConfiguration$lan3;
+
+      if (newConfiguration != null && (_newConfiguration$lan2 = newConfiguration.languageChoices) != null && (_newConfiguration$lan3 = _newConfiguration$lan2.options) != null && _newConfiguration$lan3.length) {
+        this._model.language = newConfiguration == null ? void 0 : newConfiguration.languageChoices.options[0].value;
+      }
+    } else if (newConfiguration.language.settings && this._model.language) {
+      this._configuration.language.enabled = true;
+
+      if (!this._configuration.languageChoices.options || !this._configuration.languageChoices.options.length) {
+        this._configuration.languageChoices.options = [];
+      } // check if the language is already included in the languageChoices.options array
+      // and if not, then add it.
+
+
+      if (!this._configuration.languageChoices.options.find(option => option.value === this._model.language)) {
+        this._configuration.languageChoices.options.push({
+          value: this._model.language,
+          label: this._model.language
+        });
+      }
+    } else {
+      delete this._model.language;
+    }
+
+    this._rerender();
+  }
+
+  insertSound(handler) {
+    this.dispatchEvent(new InsertSoundEvent(handler));
+  }
+
+  onDeleteSound(src, done) {
+    this.dispatchEvent(new DeleteSoundEvent(src, done));
+  }
+
+  _rerender() {
+    let element = /*#__PURE__*/React.createElement(Main, {
+      model: this._model,
+      configuration: this._configuration,
+      onModelChanged: this.onModelChanged,
+      onConfigurationChanged: this.onConfigurationChanged,
+      imageSupport: {
+        add: this.insertImage,
+        delete: this.deleteImage
+      },
+      uploadSoundSupport: {
+        add: this.insertSound.bind(this),
+        delete: this.onDeleteSound.bind(this)
+      }
+    });
+    ReactDOM.render(element, this);
+  }
+
+}
+
+PlacementOrdering.createDefaultModel = (model = {}) => {
+  const mapChoicesToReturnCorrectResponse = choices => choices && choices.map(ch => ({
+    id: ch.id,
+    weight: 0
+  }));
+
+  let correctResponse = addWeightToCorrectResponse(model.correctResponse) || mapChoicesToReturnCorrectResponse(model.choices);
+
+  const defaultModel = _extends({}, defaultValues.model, model);
+
+  if (correctResponse) {
+    defaultModel.correctResponse = correctResponse;
+  }
+
+  return defaultModel;
+};
+
+export { addWeightToCorrectResponse, PlacementOrdering as default };
+//# sourceMappingURL=configure.js.map