@pie-lib/graphing-solution-set 2.31.1 → 2.31.3

package/esm/index.js

@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 import isEqual from 'lodash/isEqual';
 import cloneDeep from 'lodash/cloneDeep';
 import { types, utils, createGraphProps, Root as Root$1, gridDraggable, trig } from '@pie-lib/plot';
-import debug from 'debug';
+import debug$1 from 'debug';
 import { Axis } from '@vx/axis';
 import classNames from 'classnames';
 import { withStyles } from '@material-ui/core/styles';
@@ -18,7 +18,6 @@ import EditableHtml from '@pie-lib/editable-html';
 import { mouse, select } from 'd3-selection';
 import { connect, Provider } from 'react-redux';
 import { combineReducers, createStore, applyMiddleware } from 'redux';
-import undoable, { ActionCreators } from 'redux-undo';
 import uniq from 'lodash/uniq';
 import isString from 'lodash/isString';
 import Radio from '@material-ui/core/Radio';
@@ -31,7 +30,7 @@ import ReactDOM from 'react-dom';
 import AutosizeInput from 'react-input-autosize';
 import { withStyles as withStyles$2 } from '@material-ui/core/styles/index';
 import InputBase from '@material-ui/core/InputBase';
-import ExpandMoreIcon from '@material-ui/icons/ExpandMore';
+import require$$3 from '@material-ui/core/SvgIcon';
 import ExpansionPanelSummary$1 from '@material-ui/core/ExpansionPanelSummary';
 import Typography$1 from '@material-ui/core/Typography';
 import ExpansionPanelDetails$1 from '@material-ui/core/ExpansionPanelDetails';
@@ -1032,7 +1031,7 @@ Bg.propTypes = {
 };
 Bg.defaultProps = {};
 
-const log$1 = debug('pie-lib:graphing-solution-set:graph');
+const log$1 = debug$1('pie-lib:graphing-solution-set:graph');
 const graphPropTypes = {
   axesSettings: PropTypes.shape(AxisPropTypes),
   backgroundMarks: PropTypes.array,
@@ -1366,6 +1365,629 @@ const marks = (state = [], action) => {
   }
 };
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var lib = {};
+
+var actions = {};
+
+var hasRequiredActions;
+
+function requireActions () {
+	if (hasRequiredActions) return actions;
+	hasRequiredActions = 1;
+
+	Object.defineProperty(actions, "__esModule", {
+	  value: true
+	});
+	var ActionTypes = actions.ActionTypes = {
+	  UNDO: '@@redux-undo/UNDO',
+	  REDO: '@@redux-undo/REDO',
+	  JUMP_TO_FUTURE: '@@redux-undo/JUMP_TO_FUTURE',
+	  JUMP_TO_PAST: '@@redux-undo/JUMP_TO_PAST',
+	  JUMP: '@@redux-undo/JUMP',
+	  CLEAR_HISTORY: '@@redux-undo/CLEAR_HISTORY'
+	};
+
+	actions.ActionCreators = {
+	  undo: function undo() {
+	    return { type: ActionTypes.UNDO };
+	  },
+	  redo: function redo() {
+	    return { type: ActionTypes.REDO };
+	  },
+	  jumpToFuture: function jumpToFuture(index) {
+	    return { type: ActionTypes.JUMP_TO_FUTURE, index: index };
+	  },
+	  jumpToPast: function jumpToPast(index) {
+	    return { type: ActionTypes.JUMP_TO_PAST, index: index };
+	  },
+	  jump: function jump(index) {
+	    return { type: ActionTypes.JUMP, index: index };
+	  },
+	  clearHistory: function clearHistory() {
+	    return { type: ActionTypes.CLEAR_HISTORY };
+	  }
+	};
+	return actions;
+}
+
+var helpers = {};
+
+var hasRequiredHelpers;
+
+function requireHelpers () {
+	if (hasRequiredHelpers) return helpers;
+	hasRequiredHelpers = 1;
+
+	Object.defineProperty(helpers, "__esModule", {
+	  value: true
+	});
+	helpers.parseActions = parseActions;
+	helpers.isHistory = isHistory;
+	helpers.distinctState = distinctState;
+	helpers.includeAction = includeAction;
+	helpers.excludeAction = excludeAction;
+	helpers.combineFilters = combineFilters;
+	helpers.groupByActionTypes = groupByActionTypes;
+	helpers.newHistory = newHistory;
+	// parseActions helper: takes a string (or array)
+	//                      and makes it an array if it isn't yet
+	function parseActions(rawActions) {
+	  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+	  if (Array.isArray(rawActions)) {
+	    return rawActions;
+	  } else if (typeof rawActions === 'string') {
+	    return [rawActions];
+	  }
+	  return defaultValue;
+	}
+
+	// isHistory helper: check for a valid history object
+	function isHistory(history) {
+	  return typeof history.present !== 'undefined' && typeof history.future !== 'undefined' && typeof history.past !== 'undefined' && Array.isArray(history.future) && Array.isArray(history.past);
+	}
+
+	// distinctState helper: deprecated, does nothing in latest beta
+	/* istanbul ignore next */
+	function distinctState() {
+	  console.warn('distinctState is deprecated in beta4 and newer. ' + 'The distinctState behavior is now default, which means only ' + 'actions resulting in a new state are recorded. ' + 'See https://github.com/omnidan/redux-undo#filtering-actions ' + 'for more details.');
+	  return function () {
+	    return true;
+	  };
+	}
+
+	// includeAction helper: whitelist actions to be added to the history
+	function includeAction(rawActions) {
+	  var actions = parseActions(rawActions);
+	  return function (action) {
+	    return actions.indexOf(action.type) >= 0;
+	  };
+	}
+
+	// excludeAction helper: blacklist actions from being added to the history
+	function excludeAction(rawActions) {
+	  var actions = parseActions(rawActions);
+	  return function (action) {
+	    return actions.indexOf(action.type) < 0;
+	  };
+	}
+
+	// combineFilters helper: combine multiple filters to one
+	function combineFilters() {
+	  for (var _len = arguments.length, filters = Array(_len), _key = 0; _key < _len; _key++) {
+	    filters[_key] = arguments[_key];
+	  }
+
+	  return filters.reduce(function (prev, curr) {
+	    return function (action, currentState, previousHistory) {
+	      return prev(action, currentState, previousHistory) && curr(action, currentState, previousHistory);
+	    };
+	  }, function () {
+	    return true;
+	  });
+	}
+
+	function groupByActionTypes(rawActions) {
+	  var actions = parseActions(rawActions);
+	  return function (action) {
+	    return actions.indexOf(action.type) >= 0 ? action.type : null;
+	  };
+	}
+
+	function newHistory(past, present, future) {
+	  var group = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+	  return {
+	    past: past,
+	    present: present,
+	    future: future,
+	    group: group,
+	    _latestUnfiltered: present,
+	    index: past.length,
+	    limit: past.length + future.length + 1
+	  };
+	}
+	return helpers;
+}
+
+var reducer$1 = {exports: {}};
+
+var debug = {};
+
+var hasRequiredDebug;
+
+function requireDebug () {
+	if (hasRequiredDebug) return debug;
+	hasRequiredDebug = 1;
+
+	Object.defineProperty(debug, "__esModule", {
+	  value: true
+	});
+
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+	var __DEBUG__ = void 0;
+	var displayBuffer = void 0;
+
+	var colors = {
+	  prevState: '#9E9E9E',
+	  action: '#03A9F4',
+	  nextState: '#4CAF50'
+
+	  /* istanbul ignore next: debug messaging is not tested */
+	};function initBuffer() {
+	  displayBuffer = {
+	    header: [],
+	    prev: [],
+	    action: [],
+	    next: [],
+	    msgs: []
+	  };
+	}
+
+	/* istanbul ignore next: debug messaging is not tested */
+	function printBuffer() {
+	  var _displayBuffer = displayBuffer,
+	      header = _displayBuffer.header,
+	      prev = _displayBuffer.prev,
+	      next = _displayBuffer.next,
+	      action = _displayBuffer.action,
+	      msgs = _displayBuffer.msgs;
+
+	  if (console.group) {
+	    var _console, _console2, _console3, _console4, _console5;
+
+	    (_console = console).groupCollapsed.apply(_console, _toConsumableArray(header));
+	    (_console2 = console).log.apply(_console2, _toConsumableArray(prev));
+	    (_console3 = console).log.apply(_console3, _toConsumableArray(action));
+	    (_console4 = console).log.apply(_console4, _toConsumableArray(next));
+	    (_console5 = console).log.apply(_console5, _toConsumableArray(msgs));
+	    console.groupEnd();
+	  } else {
+	    var _console6, _console7, _console8, _console9, _console10;
+
+	    (_console6 = console).log.apply(_console6, _toConsumableArray(header));
+	    (_console7 = console).log.apply(_console7, _toConsumableArray(prev));
+	    (_console8 = console).log.apply(_console8, _toConsumableArray(action));
+	    (_console9 = console).log.apply(_console9, _toConsumableArray(next));
+	    (_console10 = console).log.apply(_console10, _toConsumableArray(msgs));
+	  }
+	}
+
+	/* istanbul ignore next: debug messaging is not tested */
+	function colorFormat(text, color, obj) {
+	  return ['%c' + text, 'color: ' + color + '; font-weight: bold', obj];
+	}
+
+	/* istanbul ignore next: debug messaging is not tested */
+	function start(action, state) {
+	  initBuffer();
+	  if (__DEBUG__) {
+	    if (console.group) {
+	      displayBuffer.header = ['%credux-undo', 'font-style: italic', 'action', action.type];
+	      displayBuffer.action = colorFormat('action', colors.action, action);
+	      displayBuffer.prev = colorFormat('prev history', colors.prevState, state);
+	    } else {
+	      displayBuffer.header = ['redux-undo action', action.type];
+	      displayBuffer.action = ['action', action];
+	      displayBuffer.prev = ['prev history', state];
+	    }
+	  }
+	}
+
+	/* istanbul ignore next: debug messaging is not tested */
+	function end(nextState) {
+	  if (__DEBUG__) {
+	    if (console.group) {
+	      displayBuffer.next = colorFormat('next history', colors.nextState, nextState);
+	    } else {
+	      displayBuffer.next = ['next history', nextState];
+	    }
+	    printBuffer();
+	  }
+	}
+
+	/* istanbul ignore next: debug messaging is not tested */
+	function log() {
+	  if (__DEBUG__) {
+	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
+
+	    displayBuffer.msgs = displayBuffer.msgs.concat([].concat(args, ['\n']));
+	  }
+	}
+
+	/* istanbul ignore next: debug messaging is not tested */
+	function set(debug) {
+	  __DEBUG__ = debug;
+	}
+
+	debug.set = set;
+	debug.start = start;
+	debug.end = end;
+	debug.log = log;
+	return debug;
+}
+
+var hasRequiredReducer;
+
+function requireReducer () {
+	if (hasRequiredReducer) return reducer$1.exports;
+	hasRequiredReducer = 1;
+	(function (module, exports) {
+
+		Object.defineProperty(exports, "__esModule", {
+		  value: true
+		});
+
+		var _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; };
+
+		exports.default = undoable;
+
+		var _debug = requireDebug();
+
+		var debug = _interopRequireWildcard(_debug);
+
+		var _actions = requireActions();
+
+		var _helpers = requireHelpers();
+
+		function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+		// createHistory
+		function createHistory(state, ignoreInitialState) {
+		  // ignoreInitialState essentially prevents the user from undoing to the
+		  // beginning, in the case that the undoable reducer handles initialization
+		  // in a way that can't be redone simply
+		  var history = (0, _helpers.newHistory)([], state, []);
+		  if (ignoreInitialState) {
+		    history._latestUnfiltered = null;
+		  }
+		  return history;
+		}
+
+		// lengthWithoutFuture: get length of history
+		function lengthWithoutFuture(history) {
+		  return history.past.length + 1;
+		}
+
+		// insert: insert `state` into history, which means adding the current state
+		//         into `past`, setting the new `state` as `present` and erasing
+		//         the `future`.
+		function insert(history, state, limit, group) {
+		  debug.log('inserting', state);
+		  debug.log('new free: ', limit - lengthWithoutFuture(history));
+
+		  var past = history.past,
+		      _latestUnfiltered = history._latestUnfiltered;
+
+		  var historyOverflow = limit && lengthWithoutFuture(history) >= limit;
+
+		  var pastSliced = past.slice(historyOverflow ? 1 : 0);
+		  var newPast = _latestUnfiltered != null ? [].concat(_toConsumableArray(pastSliced), [_latestUnfiltered]) : pastSliced;
+
+		  return (0, _helpers.newHistory)(newPast, state, [], group);
+		}
+
+		// jumpToFuture: jump to requested index in future history
+		function jumpToFuture(history, index) {
+		  if (index < 0 || index >= history.future.length) return history;
+
+		  var past = history.past,
+		      future = history.future,
+		      _latestUnfiltered = history._latestUnfiltered;
+
+
+		  var newPast = [].concat(_toConsumableArray(past), [_latestUnfiltered], _toConsumableArray(future.slice(0, index)));
+		  var newPresent = future[index];
+		  var newFuture = future.slice(index + 1);
+
+		  return (0, _helpers.newHistory)(newPast, newPresent, newFuture);
+		}
+
+		// jumpToPast: jump to requested index in past history
+		function jumpToPast(history, index) {
+		  if (index < 0 || index >= history.past.length) return history;
+
+		  var past = history.past,
+		      future = history.future,
+		      _latestUnfiltered = history._latestUnfiltered;
+
+
+		  var newPast = past.slice(0, index);
+		  var newFuture = [].concat(_toConsumableArray(past.slice(index + 1)), [_latestUnfiltered], _toConsumableArray(future));
+		  var newPresent = past[index];
+
+		  return (0, _helpers.newHistory)(newPast, newPresent, newFuture);
+		}
+
+		// jump: jump n steps in the past or forward
+		function jump(history, n) {
+		  if (n > 0) return jumpToFuture(history, n - 1);
+		  if (n < 0) return jumpToPast(history, history.past.length + n);
+		  return history;
+		}
+
+		// helper to dynamically match in the reducer's switch-case
+		function actionTypeAmongClearHistoryType(actionType, clearHistoryType) {
+		  return clearHistoryType.indexOf(actionType) > -1 ? actionType : !actionType;
+		}
+
+		// redux-undo higher order reducer
+		function undoable(reducer) {
+		  var rawConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+		  debug.set(rawConfig.debug);
+
+		  var config = {
+		    initTypes: (0, _helpers.parseActions)(rawConfig.initTypes, ['@@redux-undo/INIT']),
+		    limit: rawConfig.limit,
+		    filter: rawConfig.filter || function () {
+		      return true;
+		    },
+		    groupBy: rawConfig.groupBy || function () {
+		      return null;
+		    },
+		    undoType: rawConfig.undoType || _actions.ActionTypes.UNDO,
+		    redoType: rawConfig.redoType || _actions.ActionTypes.REDO,
+		    jumpToPastType: rawConfig.jumpToPastType || _actions.ActionTypes.JUMP_TO_PAST,
+		    jumpToFutureType: rawConfig.jumpToFutureType || _actions.ActionTypes.JUMP_TO_FUTURE,
+		    jumpType: rawConfig.jumpType || _actions.ActionTypes.JUMP,
+		    clearHistoryType: Array.isArray(rawConfig.clearHistoryType) ? rawConfig.clearHistoryType : [rawConfig.clearHistoryType || _actions.ActionTypes.CLEAR_HISTORY],
+		    neverSkipReducer: rawConfig.neverSkipReducer || false,
+		    ignoreInitialState: rawConfig.ignoreInitialState || false,
+		    syncFilter: rawConfig.syncFilter || false
+		  };
+
+		  var initialState = config.history;
+		  return function () {
+		    for (var _len = arguments.length, slices = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+		      slices[_key - 2] = arguments[_key];
+		    }
+
+		    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+		    var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+		    debug.start(action, state);
+
+		    var history = state;
+		    if (!initialState) {
+		      debug.log('history is uninitialized');
+
+		      if (state === undefined) {
+		        var clearHistoryAction = { type: _actions.ActionTypes.CLEAR_HISTORY };
+		        var start = reducer.apply(undefined, [state, clearHistoryAction].concat(slices));
+
+		        history = createHistory(start, config.ignoreInitialState);
+
+		        debug.log('do not set initialState on probe actions');
+		      } else if ((0, _helpers.isHistory)(state)) {
+		        history = initialState = config.ignoreInitialState ? state : (0, _helpers.newHistory)(state.past, state.present, state.future);
+		        debug.log('initialHistory initialized: initialState is a history', initialState);
+		      } else {
+		        history = initialState = createHistory(state, config.ignoreInitialState);
+		        debug.log('initialHistory initialized: initialState is not a history', initialState);
+		      }
+		    }
+
+		    var skipReducer = function skipReducer(res) {
+		      return config.neverSkipReducer ? _extends({}, res, {
+		        present: reducer.apply(undefined, [res.present, action].concat(slices))
+		      }) : res;
+		    };
+
+		    var res = void 0;
+		    switch (action.type) {
+		      case undefined:
+		        return history;
+
+		      case config.undoType:
+		        res = jump(history, -1);
+		        debug.log('perform undo');
+		        debug.end(res);
+		        return skipReducer(res);
+
+		      case config.redoType:
+		        res = jump(history, 1);
+		        debug.log('perform redo');
+		        debug.end(res);
+		        return skipReducer(res);
+
+		      case config.jumpToPastType:
+		        res = jumpToPast(history, action.index);
+		        debug.log('perform jumpToPast to ' + action.index);
+		        debug.end(res);
+		        return skipReducer(res);
+
+		      case config.jumpToFutureType:
+		        res = jumpToFuture(history, action.index);
+		        debug.log('perform jumpToFuture to ' + action.index);
+		        debug.end(res);
+		        return skipReducer(res);
+
+		      case config.jumpType:
+		        res = jump(history, action.index);
+		        debug.log('perform jump to ' + action.index);
+		        debug.end(res);
+		        return skipReducer(res);
+
+		      case actionTypeAmongClearHistoryType(action.type, config.clearHistoryType):
+		        res = createHistory(history.present);
+		        debug.log('perform clearHistory');
+		        debug.end(res);
+		        return skipReducer(res);
+
+		      default:
+		        res = reducer.apply(undefined, [history.present, action].concat(slices));
+
+		        if (config.initTypes.some(function (actionType) {
+		          return actionType === action.type;
+		        })) {
+		          debug.log('reset history due to init action');
+		          debug.end(initialState);
+		          return initialState;
+		        }
+
+		        if (history._latestUnfiltered === res) {
+		          // Don't handle this action. Do not call debug.end here,
+		          // because this action should not produce side effects to the console
+		          return history;
+		        }
+
+		        var filtered = typeof config.filter === 'function' && !config.filter(action, res, history);
+		        var group = config.groupBy(action, res, history);
+
+		        if (filtered) {
+		          // if filtering an action, merely update the present
+		          var filteredState = (0, _helpers.newHistory)(history.past, res, history.future, history.group);
+		          if (!config.syncFilter) {
+		            filteredState._latestUnfiltered = history._latestUnfiltered;
+		          }
+		          debug.log('filter ignored action, not storing it in past');
+		          debug.end(filteredState);
+		          return filteredState;
+		        } else if (group != null && group === history.group) {
+		          var groupedState = (0, _helpers.newHistory)(history.past, res, history.future, history.group);
+		          debug.log('groupBy grouped the action with the previous action');
+		          debug.end(groupedState);
+		          return groupedState;
+		        } else {
+		          // If the action wasn't filtered, insert normally
+		          history = insert(history, res, config.limit, group);
+
+		          debug.log('inserted new state into history');
+		          debug.end(history);
+		          return history;
+		        }
+		    }
+		  };
+		}
+		module.exports = exports['default']; 
+	} (reducer$1, reducer$1.exports));
+	return reducer$1.exports;
+}
+
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	(function (exports) {
+
+		Object.defineProperty(exports, "__esModule", {
+		  value: true
+		});
+
+		var _actions = requireActions();
+
+		Object.defineProperty(exports, 'ActionTypes', {
+		  enumerable: true,
+		  get: function get() {
+		    return _actions.ActionTypes;
+		  }
+		});
+		Object.defineProperty(exports, 'ActionCreators', {
+		  enumerable: true,
+		  get: function get() {
+		    return _actions.ActionCreators;
+		  }
+		});
+
+		var _helpers = requireHelpers();
+
+		Object.defineProperty(exports, 'parseActions', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.parseActions;
+		  }
+		});
+		Object.defineProperty(exports, 'isHistory', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.isHistory;
+		  }
+		});
+		Object.defineProperty(exports, 'distinctState', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.distinctState;
+		  }
+		});
+		Object.defineProperty(exports, 'includeAction', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.includeAction;
+		  }
+		});
+		Object.defineProperty(exports, 'excludeAction', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.excludeAction;
+		  }
+		});
+		Object.defineProperty(exports, 'combineFilters', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.combineFilters;
+		  }
+		});
+		Object.defineProperty(exports, 'groupByActionTypes', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.groupByActionTypes;
+		  }
+		});
+		Object.defineProperty(exports, 'newHistory', {
+		  enumerable: true,
+		  get: function get() {
+		    return _helpers.newHistory;
+		  }
+		});
+
+		var _reducer = requireReducer();
+
+		Object.defineProperty(exports, 'default', {
+		  enumerable: true,
+		  get: function get() {
+		    return _interopRequireDefault(_reducer).default;
+		  }
+		});
+
+		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 
+	} (lib));
+	return lib;
+}
+
+var libExports = requireLib();
+var undoable = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
 var reducer = (() => combineReducers({
   marks: undoable(marks, {
     debug: false
@@ -1966,7 +2588,7 @@ var MarkLabel$1 = withStyles(styles$5, {
   withTheme: true
 })(MarkLabel);
 
-const log = debug('pie-lib:graphing-solution-set:polygon');
+const log = debug$1('pie-lib:graphing-solution-set:polygon');
 const swap = (arr, ...rest) => {
   const pairs = chunk(rest, 2);
   return pairs.reduce((acc, pr) => {
@@ -3377,6 +3999,427 @@ var index = /*#__PURE__*/Object.freeze({
   toolsArr: toolsArr
 });
 
+var ExpandMore = {};
+
+var interopRequireDefault = {exports: {}};
+
+var hasRequiredInteropRequireDefault;
+
+function requireInteropRequireDefault () {
+	if (hasRequiredInteropRequireDefault) return interopRequireDefault.exports;
+	hasRequiredInteropRequireDefault = 1;
+	(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));
+	return interopRequireDefault.exports;
+}
+
+var createSvgIcon = {};
+
+var pure = {};
+
+var shouldUpdate = {};
+
+var inheritsLoose = {exports: {}};
+
+var setPrototypeOf = {exports: {}};
+
+var hasRequiredSetPrototypeOf;
+
+function requireSetPrototypeOf () {
+	if (hasRequiredSetPrototypeOf) return setPrototypeOf.exports;
+	hasRequiredSetPrototypeOf = 1;
+	(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));
+	return setPrototypeOf.exports;
+}
+
+var hasRequiredInheritsLoose;
+
+function requireInheritsLoose () {
+	if (hasRequiredInheritsLoose) return inheritsLoose.exports;
+	hasRequiredInheritsLoose = 1;
+	(function (module) {
+		var setPrototypeOf = requireSetPrototypeOf();
+
+		function _inheritsLoose(subClass, superClass) {
+		  subClass.prototype = Object.create(superClass.prototype);
+		  subClass.prototype.constructor = subClass;
+		  setPrototypeOf(subClass, superClass);
+		}
+
+		module.exports = _inheritsLoose, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (inheritsLoose));
+	return inheritsLoose.exports;
+}
+
+var setDisplayName = {};
+
+var setStatic = {};
+
+var hasRequiredSetStatic;
+
+function requireSetStatic () {
+	if (hasRequiredSetStatic) return setStatic;
+	hasRequiredSetStatic = 1;
+
+	setStatic.__esModule = true;
+	setStatic.default = void 0;
+
+	var setStatic$1 = function setStatic(key, value) {
+	  return function (BaseComponent) {
+	    /* eslint-disable no-param-reassign */
+	    BaseComponent[key] = value;
+	    /* eslint-enable no-param-reassign */
+
+	    return BaseComponent;
+	  };
+	};
+
+	var _default = setStatic$1;
+	setStatic.default = _default;
+	return setStatic;
+}
+
+var hasRequiredSetDisplayName;
+
+function requireSetDisplayName () {
+	if (hasRequiredSetDisplayName) return setDisplayName;
+	hasRequiredSetDisplayName = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	setDisplayName.__esModule = true;
+	setDisplayName.default = void 0;
+
+	var _setStatic = _interopRequireDefault(requireSetStatic());
+
+	var setDisplayName$1 = function setDisplayName(displayName) {
+	  return (0, _setStatic.default)('displayName', displayName);
+	};
+
+	var _default = setDisplayName$1;
+	setDisplayName.default = _default;
+	return setDisplayName;
+}
+
+var wrapDisplayName = {};
+
+var getDisplayName = {};
+
+var hasRequiredGetDisplayName;
+
+function requireGetDisplayName () {
+	if (hasRequiredGetDisplayName) return getDisplayName;
+	hasRequiredGetDisplayName = 1;
+
+	getDisplayName.__esModule = true;
+	getDisplayName.default = void 0;
+
+	var getDisplayName$1 = function getDisplayName(Component) {
+	  if (typeof Component === 'string') {
+	    return Component;
+	  }
+
+	  if (!Component) {
+	    return undefined;
+	  }
+
+	  return Component.displayName || Component.name || 'Component';
+	};
+
+	var _default = getDisplayName$1;
+	getDisplayName.default = _default;
+	return getDisplayName;
+}
+
+var hasRequiredWrapDisplayName;
+
+function requireWrapDisplayName () {
+	if (hasRequiredWrapDisplayName) return wrapDisplayName;
+	hasRequiredWrapDisplayName = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	wrapDisplayName.__esModule = true;
+	wrapDisplayName.default = void 0;
+
+	var _getDisplayName = _interopRequireDefault(requireGetDisplayName());
+
+	var wrapDisplayName$1 = function wrapDisplayName(BaseComponent, hocName) {
+	  return hocName + "(" + (0, _getDisplayName.default)(BaseComponent) + ")";
+	};
+
+	var _default = wrapDisplayName$1;
+	wrapDisplayName.default = _default;
+	return wrapDisplayName;
+}
+
+var hasRequiredShouldUpdate;
+
+function requireShouldUpdate () {
+	if (hasRequiredShouldUpdate) return shouldUpdate;
+	hasRequiredShouldUpdate = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	shouldUpdate.__esModule = true;
+	shouldUpdate.default = void 0;
+
+	var _inheritsLoose2 = _interopRequireDefault(requireInheritsLoose());
+
+	var _react = React;
+
+	var _setDisplayName = _interopRequireDefault(requireSetDisplayName());
+
+	var _wrapDisplayName = _interopRequireDefault(requireWrapDisplayName());
+
+	var shouldUpdate$1 = function shouldUpdate(test) {
+	  return function (BaseComponent) {
+	    var factory = (0, _react.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.Component);
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      return (0, _setDisplayName.default)((0, _wrapDisplayName.default)(BaseComponent, 'shouldUpdate'))(ShouldUpdate);
+	    }
+
+	    return ShouldUpdate;
+	  };
+	};
+
+	var _default = shouldUpdate$1;
+	shouldUpdate.default = _default;
+	return shouldUpdate;
+}
+
+var shallowEqual = {};
+
+/**
+ * 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 shallowEqual_1;
+var hasRequiredShallowEqual$1;
+
+function requireShallowEqual$1 () {
+	if (hasRequiredShallowEqual$1) return shallowEqual_1;
+	hasRequiredShallowEqual$1 = 1;
+
+	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(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;
+	}
+
+	shallowEqual_1 = shallowEqual;
+	return shallowEqual_1;
+}
+
+var hasRequiredShallowEqual;
+
+function requireShallowEqual () {
+	if (hasRequiredShallowEqual) return shallowEqual;
+	hasRequiredShallowEqual = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	shallowEqual.__esModule = true;
+	shallowEqual.default = void 0;
+
+	var _shallowEqual = _interopRequireDefault(requireShallowEqual$1());
+
+	var _default = _shallowEqual.default;
+	shallowEqual.default = _default;
+	return shallowEqual;
+}
+
+var hasRequiredPure;
+
+function requirePure () {
+	if (hasRequiredPure) return pure;
+	hasRequiredPure = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	pure.__esModule = true;
+	pure.default = void 0;
+
+	var _shouldUpdate = _interopRequireDefault(requireShouldUpdate());
+
+	var _shallowEqual = _interopRequireDefault(requireShallowEqual());
+
+	var _setDisplayName = _interopRequireDefault(requireSetDisplayName());
+
+	var _wrapDisplayName = _interopRequireDefault(requireWrapDisplayName());
+
+	var pure$1 = 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 = pure$1;
+	pure.default = _default;
+	return pure;
+}
+
+var hasRequiredCreateSvgIcon;
+
+function requireCreateSvgIcon () {
+	if (hasRequiredCreateSvgIcon) return createSvgIcon;
+	hasRequiredCreateSvgIcon = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	Object.defineProperty(createSvgIcon, "__esModule", {
+	  value: true
+	});
+	createSvgIcon.default = void 0;
+
+	var _react = _interopRequireDefault(React);
+
+	var _pure = _interopRequireDefault(requirePure());
+
+	var _SvgIcon = _interopRequireDefault(require$$3);
+
+	function createSvgIcon$1(path, displayName) {
+	  var Icon = function Icon(props) {
+	    return _react.default.createElement(_SvgIcon.default, props, path);
+	  };
+
+	  Icon.displayName = "".concat(displayName, "Icon");
+	  Icon = (0, _pure.default)(Icon);
+	  Icon.muiName = 'SvgIcon';
+	  return Icon;
+	}
+	var _default = createSvgIcon$1;
+	createSvgIcon.default = _default;
+	return createSvgIcon;
+}
+
+var hasRequiredExpandMore;
+
+function requireExpandMore () {
+	if (hasRequiredExpandMore) return ExpandMore;
+	hasRequiredExpandMore = 1;
+
+	var _interopRequireDefault = requireInteropRequireDefault();
+
+	Object.defineProperty(ExpandMore, "__esModule", {
+	  value: true
+	});
+	ExpandMore.default = void 0;
+
+	var _react = _interopRequireDefault(React);
+
+	var _createSvgIcon = _interopRequireDefault(/*@__PURE__*/ requireCreateSvgIcon());
+
+	var _default = (0, _createSvgIcon.default)(_react.default.createElement(_react.default.Fragment, null, _react.default.createElement("path", {
+	  d: "M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"
+	}), _react.default.createElement("path", {
+	  fill: "none",
+	  d: "M0 0h24v24H0z"
+	})), 'ExpandMore');
+
+	ExpandMore.default = _default;
+	return ExpandMore;
+}
+
+var ExpandMoreExports = /*@__PURE__*/ requireExpandMore();
+var ExpandMoreIcon = /*@__PURE__*/getDefaultExportFromCjs(ExpandMoreExports);
+
 const setToolbarAvailability = toolbarTools => toolsArr.map(tA => _extends({}, tA, {
   toolbar: !!toolbarTools.find(t => t === tA.type)
 })) || [];
@@ -3629,8 +4672,8 @@ const mapStateToProps = s => ({
 
 const mapDispatchToProps = dispatch => ({
   onChangeMarks: m => dispatch(changeMarks(m)),
-  onUndo: () => dispatch(ActionCreators.undo()),
-  onRedo: () => dispatch(ActionCreators.redo()),
+  onUndo: () => dispatch(libExports.ActionCreators.undo()),
+  onRedo: () => dispatch(libExports.ActionCreators.redo()),
   onReset: () => dispatch(changeMarks([]))
 });